[unix-history] / portlib / scanf.c

# include	"iodec.h"

/*
**	formatted read routine
**
**		based on scanf() in the portable C library
*/


int	(*__getc)(), (*__ungc)();
int	__input;

scanf(paramlist)
char	*paramlist;
{
	extern		cgetc(), ungetc();
	extern		__gets(), __ungs();
	register char	**p;
	extern int	cin;
	register int	nmatch;
	char		*format;
	register char	ch;
	char		match_ch;

	p = &paramlist;
	__getc = cgetc;
	__ungc = ungetc;
	__input = cin;
	if (paramlist == -1)
	{
		p++;
		__getc = __gets;
		__ungc = __ungs;
		__input = p++;
	}
	else
		if (paramlist >= 0 && paramlist < MAXFILES)
		{
			__input = *p++;
		}
	nmatch = 0;
	format = *p++;
	while (1)
	{
		switch (ch = *format++)
		{

		  case '\0':
			return (nmatch);

		  case '%':
			if (*format != '%')
			{
				switch (__scan(&format, *p))
				{
	
				  case 1:	/* good return */
					p++;
					nmatch++;
				  case 0:	/* no return */
					break;
	
				  case -1:	/* no match */
					return (nmatch);
	
				  case -2:	/* end of file */
					return (nmatch ? nmatch : -1);
	
				  default:	/* syntax error */
					return (-1);
	
				}
				break;
			}
			format++;

		  default:
			match_ch = __next(0);
			if (ch != match_ch)
			{
				(*__ungc)(match_ch, __input);
				return (nmatch ? nmatch : -2);
			}
			break;

		}
	}
}


__scan(spec, result)
char	**spec;
char	*result;
{
	register int	longf, length;
	register char	ch;
	extern int	__strend(), __splend();

	longf = length = 0;
	while (1)
	{
		switch (ch = *(*spec)++)
		{
		  case '*':
			result = 0;
			break;
	
		  case '0':
		  case '1':
		  case '2':
		  case '3':
		  case '4':
		  case '5':
		  case '6':
		  case '7':
		  case '8':
		  case '9':
			length = length * 10 + ch - '0';
			break;
	
		  case 'l':
			if (longf)
				return (-3);
			longf = 1;
			break;
	
		  case 'h':	/* short */
			if (longf)
				return (-3);
			longf = -1;
			break;
	
		  case 'o':
		  case 'O':
			return (__dec(result, length ? length : 100, 8, longf));
	
		  case 'd':
		  case 'D':
			return (__dec(result, length ? length : 100, 10, longf));
	
		  case 'x':
		  case 'X':
			return (__dec(result, length ? length : 100, 16, longf));
	
		  case 'c':
		  case 'C':
			if (longf)
				return (-3);
			return (__char(result, length ? length : 1));
	
		  case 's':
		  case 'S':
			if (longf)
				return (-3);
			return (__str(result, length ? length : 100, __strend));
	
		  case 'e':
		  case 'E':
		  case 'f':
		  case 'F':
			if (longf < 0)
				return (-3);
			return (__float(result, length ? length : 100, longf));
	
		  case '[':
			if (longf)
				return (-3);
			if (__inits(spec))
				return (-3);
			return (__str(result, length ? length : 100, __splend));
	
		  default:
			return (-3);
	
		}
	}
}


__dec(result, length, base, longf)
int	*result;
int	length;
int	base;
int	longf;
{
	register char	ch;
	long		n, *lresult;
	register int	val;
	long		lres;
	int		ires;
	int		minus, ok;
	register int	ndigit;

	ires = 0;
	lres = 0;
	ndigit = minus = 0;
	switch (ch = __next(1))
	{

	  case '\0':
		return (-2);

	  case '-':
		minus = 1;
	  case '+':
		ndigit++;
		ch = __next(-1);
	}
	ok = 0;
	while ((val = __digit(ch, base)) >= 0 && ndigit++ < length)
	{
		ok++;
		if (longf)
			lres = lres * base + val;
		else
			ires = ires * base + val;
		ch = __next(0);
	}
	(*__ungc)(ch, __input);
	if (!ok)
		return (-1);
	if (!result)
		return (0);
	if (minus)
		if (longf)
			lres = -lres;
		else
			ires = -ires;
	if (longf)
	{
		lresult = result;
		*lresult = lres;
	}
	else
		*result = ires;
	return (1);
}


__next(mode)
int	mode;
{
/*
 *	mode -1:  get next non-space or non-tab
 *	mode 0:   get next character
 *	mode 1:   get next non-space, non-tab, or non-newline
 */
	register int	ch;

	ch = (*__getc)(__input);
	if (mode == 0)
		return (ch);
	while (ch == ' ' || ch == '\t' || ch == '\n')
	{
		if (ch == '\n' && mode < 0)
			break;
		ch = (*__getc)(__input);
	}
	return (ch);
}


__digit(ch, base)
char	ch;
int	base;
{
	register int	n;

	if (ch < '0')
		return (-1);
	if (ch <= '7')
		return (ch - '0');
	if (base == 8)
		return (-1);
	if (ch <= '9')
		return (ch - '0');
	if (base == 10 || ch < 'A')
		return (-1);
	if (ch <= 'F')
		return (ch - 'A' + 10);
	if (ch < 'a' || ch > 'f')
		return (-1);
	return (ch - 'a' + 10);
}


__fltend(cha)
char	cha;
{
	register char	ch;
	static char	gote, gotpt, gotsn;

	ch = cha;
	if (ch < 0)
		return (gote = gotpt = gotsn = 0);
	if (ch >= '0' && ch <= '9')
	{
		gotsn = -1;
		return (0);
	}
	if (ch == '+' || ch == '-')
	{
		if (gotsn || gotpt)
			return (1);
		gotsn = 1;
		return (0);
	}
	if (ch == '.')
	{
		if (gote || gotpt)
			return (1);
		gotpt++;
		return (0);
	}
	if (ch != 'e' && ch != 'E')
		return (1);
	if (gote)
		return (1);
	gote++;
	gotsn = 0;
	return (0);
}


__strend(cha)
char	cha;
{
	register char	ch;

	ch = cha;
	if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\0')
		return (1);
	return (0);
}


char	__splset[128];

__splend(ch)
char	ch;
{
	return (__splset[ch]);
}


__inits(spec)
char	**spec;
{
	register char	ch;
	register int	i;
	register int	val;

	ch = *(*spec)++;
	if (ch == '^')
	{
		val = 0;
		ch = *(*spec)++;
	}
	else
		val = 1;
	for (i = 1; i < 128; i++)
		__splset[i] = val;
	val = 1 - val;
	while (ch != ']')
	{
		if (ch == 0)
			return (-1);
		__splset[ch & 0177] = val;
		ch = *(*spec)++;
	}
	__splset[0] = 1;
	return (0);
}


__float(result, length, longf)
double	*result;
int	length;
int	longf;
{
	extern int	__fltend();
	char		temp[101];
	float		*fres;
	register int	r;
	double		x;
	extern double	atof();

	__fltend(-1);
	r = __str(temp, length, __fltend);
	if (r < 0)
		return (r);
	if (!result)
		return (0);
	x = atof(temp);
	if (longf)
	{
		*result = x;
		return (1);
	}
	fres = result;
	*fres = x;
	return (1);
}


__str(result, length, endfn)
char	*result;
int	length;
int	(*endfn)();
{
	register char	ch;
	extern int	__splend();
	register int	imode, notok;

	notok = 1;
	imode = (endfn != __splend);
	while (!(*endfn)(ch = __next(imode)) && length-- > 0)
	{
		if (result)
			*result++ = ch;
		imode = notok = 0;
	}
	(*__ungc)(ch, __input);
	if (notok)
		return (ch ? -1 : -2);
	if (!result)
		return (0);
	*result = 0;
	return (1);
}


__char(result, length)
char	*result;
int	length;
{
	register char	*r, ch;
	register int	l;

	r = result;
	l = length;

	while (l--)
	{
		if ((ch = __next(0)) <= 0)
			if (l + 1 == length)
				return (ch ? -1 : -2);
			else
				return (result != 0);
		if (result)
			*result++ = ch;
	}
	return (result != 0);
}


__gets(s)
char	**s;
{
	register char	c;

	c = **s;
	if (c)
		(*s)++;
	return (c);
}


__ungs(c, s)
char	c;
char	**s;
{
	if (c)
		(*s)--;
}
Commit	Line	Data
520d5775 EA	1	# include "iodec.h"
	2
	3	/*
	4	** formatted read routine
	5	**
	6	** based on scanf() in the portable C library
	7	*/
	8
	9
	10	int (__getc)(), (__ungc)();
	11	int __input;
	12
	13	scanf(paramlist)
	14	char *paramlist;
	15	{
	16	extern cgetc(), ungetc();
	17	extern __gets(), __ungs();
	18	register char **p;
	19	extern int cin;
	20	register int nmatch;
	21	char *format;
	22	register char ch;
	23	char match_ch;
	24
	25	p = &paramlist;
	26	__getc = cgetc;
	27	__ungc = ungetc;
	28	__input = cin;
	29	if (paramlist == -1)
	30	{
	31	p++;
	32	__getc = __gets;
	33	__ungc = __ungs;
	34	__input = p++;
	35	}
	36	else
	37	if (paramlist >= 0 && paramlist < MAXFILES)
	38	{
	39	__input = *p++;
	40	}
	41	nmatch = 0;
	42	format = *p++;
	43	while (1)
	44	{
	45	switch (ch = *format++)
	46	{
	47
	48	case '\0':
	49	return (nmatch);
	50
	51	case '%':
	52	if (*format != '%')
	53	{
	54	switch (__scan(&format, *p))
	55	{
	56
	57	case 1: /* good return */
	58	p++;
	59	nmatch++;
	60	case 0: /* no return */
	61	break;
	62
	63	case -1: /* no match */
	64	return (nmatch);
65
66	case -2: /* end of file */
67	return (nmatch ? nmatch : -1);
68
69	default: /* syntax error */
70	return (-1);
71
72	}
73	break;
74	}
75	format++;
76
77	default:
78	match_ch = __next(0);
79	if (ch != match_ch)
80	{
81	(*__ungc)(match_ch, __input);
82	return (nmatch ? nmatch : -2);
83	}
84	break;
85
86	}
87	}
88	}
89
90
91	__scan(spec, result)
92	char **spec;
93	char *result;
94	{
95	register int longf, length;
96	register char ch;
97	extern int __strend(), __splend();
98
99	longf = length = 0;
100	while (1)
101	{
102	switch (ch = (spec)++)
103	{
104	case '*':
105	result = 0;
106	break;
107
108	case '0':
109	case '1':
110	case '2':
111	case '3':
112	case '4':
113	case '5':
114	case '6':
115	case '7':
116	case '8':
117	case '9':
118	length = length * 10 + ch - '0';
119	break;
120
121	case 'l':
122	if (longf)
123	return (-3);
124	longf = 1;
125	break;
126
127	case 'h': /* short */
128	if (longf)
129	return (-3);
130	longf = -1;
131	break;
132
133	case 'o':
134	case 'O':
135	return (__dec(result, length ? length : 100, 8, longf));
136
137	case 'd':
138	case 'D':
139	return (__dec(result, length ? length : 100, 10, longf));
140
141	case 'x':
142	case 'X':
143	return (__dec(result, length ? length : 100, 16, longf));
144
145	case 'c':
146	case 'C':
147	if (longf)
148	return (-3);
149	return (__char(result, length ? length : 1));
150
151	case 's':
152	case 'S':
153	if (longf)
154	return (-3);
155	return (__str(result, length ? length : 100, __strend));
156
157	case 'e':
158	case 'E':
159	case 'f':
160	case 'F':
161	if (longf < 0)
162	return (-3);
163	return (__float(result, length ? length : 100, longf));
164
165	case '[':
166	if (longf)
167	return (-3);
168	if (__inits(spec))
169	return (-3);
170	return (__str(result, length ? length : 100, __splend));
171
172	default:
173	return (-3);
174
175	}
176	}
177	}
178
179
180	__dec(result, length, base, longf)
181	int *result;
182	int length;
183	int base;
184	int longf;
185	{
186	register char ch;
187	long n, *lresult;
188	register int val;
189	long lres;
190	int ires;
191	int minus, ok;
192	register int ndigit;
193
194	ires = 0;
195	lres = 0;
196	ndigit = minus = 0;
197	switch (ch = __next(1))
198	{
199
200	case '\0':
201	return (-2);
202
203	case '-':
204	minus = 1;
205	case '+':
206	ndigit++;
207	ch = __next(-1);
208	}
209	ok = 0;
210	while ((val = __digit(ch, base)) >= 0 && ndigit++ < length)
211	{
212	ok++;
213	if (longf)
214	lres = lres * base + val;
215	else
216	ires = ires * base + val;
217	ch = __next(0);
218	}
219	(*__ungc)(ch, __input);
220	if (!ok)
221	return (-1);
222	if (!result)
223	return (0);
224	if (minus)
225	if (longf)
226	lres = -lres;
227	else
228	ires = -ires;
229	if (longf)
230	{
231	lresult = result;
232	*lresult = lres;
233	}
234	else
235	*result = ires;
236	return (1);
237	}
238
239
240	__next(mode)
241	int mode;
242	{
243	/*
244	* mode -1: get next non-space or non-tab
245	* mode 0: get next character
246	* mode 1: get next non-space, non-tab, or non-newline
247	*/
248	register int ch;
249
250	ch = (*__getc)(__input);
251	if (mode == 0)
252	return (ch);
253	while (ch == ' ' \|\| ch == '\t' \|\| ch == '\n')
254	{
255	if (ch == '\n' && mode < 0)
256	break;
257	ch = (*__getc)(__input);
258	}
259	return (ch);
260	}
261
262
263	__digit(ch, base)
264	char ch;
265	int base;
266	{
267	register int n;
268
269	if (ch < '0')
270	return (-1);
271	if (ch <= '7')
272	return (ch - '0');
273	if (base == 8)
274	return (-1);
275	if (ch <= '9')
276	return (ch - '0');
277	if (base == 10 \|\| ch < 'A')
278	return (-1);
279	if (ch <= 'F')
280	return (ch - 'A' + 10);
281	if (ch < 'a' \|\| ch > 'f')
282	return (-1);
283	return (ch - 'a' + 10);
284	}
285
286
287	__fltend(cha)
288	char cha;
289	{
290	register char ch;
291	static char gote, gotpt, gotsn;
292
293	ch = cha;
294	if (ch < 0)
295	return (gote = gotpt = gotsn = 0);
296	if (ch >= '0' && ch <= '9')
297	{
298	gotsn = -1;
299	return (0);
300	}
301	if (ch == '+' \|\| ch == '-')
302	{
303	if (gotsn \|\| gotpt)
304	return (1);
305	gotsn = 1;
306	return (0);
307	}
308	if (ch == '.')
309	{
310	if (gote \|\| gotpt)
311	return (1);
312	gotpt++;
313	return (0);
314	}
315	if (ch != 'e' && ch != 'E')
316	return (1);
317	if (gote)
318	return (1);
319	gote++;
320	gotsn = 0;
321	return (0);
322	}
323
324
325	__strend(cha)
326	char cha;
327	{
328	register char ch;
329
330	ch = cha;
331	if (ch == ' ' \|\| ch == '\t' \|\| ch == '\n' \|\| ch == '\0')
332	return (1);
333	return (0);
334	}
335
336
337	char __splset[128];
338
339	__splend(ch)
340	char ch;
341	{
342	return (__splset[ch]);
343	}
344
345
346	__inits(spec)
347	char **spec;
348	{
349	register char ch;
350	register int i;
351	register int val;
352
353	ch = (spec)++;
354	if (ch == '^')
355	{
356	val = 0;
357	ch = (spec)++;
358	}
359	else
360	val = 1;
361	for (i = 1; i < 128; i++)
362	__splset[i] = val;
363	val = 1 - val;
364	while (ch != ']')
365	{
366	if (ch == 0)
367	return (-1);
368	__splset[ch & 0177] = val;
369	ch = (spec)++;
370	}
371	__splset[0] = 1;
372	return (0);
373	}
374
375
376	__float(result, length, longf)
377	double *result;
378	int length;
379	int longf;
380	{
381	extern int __fltend();
382	char temp[101];
383	float *fres;
384	register int r;
385	double x;
386	extern double atof();
387
388	__fltend(-1);
389	r = __str(temp, length, __fltend);
390	if (r < 0)
391	return (r);
392	if (!result)
393	return (0);
394	x = atof(temp);
395	if (longf)
396	{
397	*result = x;
398	return (1);
399	}
400	fres = result;
401	*fres = x;
402	return (1);
403	}
404
405
406	__str(result, length, endfn)
407	char *result;
408	int length;
409	int (*endfn)();
410	{
411	register char ch;
412	extern int __splend();
413	register int imode, notok;
414
415	notok = 1;
416	imode = (endfn != __splend);
417	while (!(*endfn)(ch = __next(imode)) && length-- > 0)
418	{
419	if (result)
420	*result++ = ch;
421	imode = notok = 0;
422	}
423	(*__ungc)(ch, __input);
424	if (notok)
425	return (ch ? -1 : -2);
426	if (!result)
427	return (0);
428	*result = 0;
429	return (1);
430	}
431
432
433	__char(result, length)
434	char *result;
435	int length;
436	{
437	register char *r, ch;
438	register int l;
439
440	r = result;
441	l = length;
442
443	while (l--)
444	{
445	if ((ch = __next(0)) <= 0)
446	if (l + 1 == length)
447	return (ch ? -1 : -2);
448	else
449	return (result != 0);
450	if (result)
451	*result++ = ch;
452	}
453	return (result != 0);
454	}
455
456
457	__gets(s)
458	char **s;
459	{
460	register char c;
461
462	c = **s;
463	if (c)
464	(*s)++;
465	return (c);
466	}
467
468
469	__ungs(c, s)
470	char c;
471	char **s;
472	{
473	if (c)
474	(*s)--;
475	}