xref: /titanic_51/usr/src/lib/libbc/libc/stdio/common/doscan.c (revision b819cea2f73f98c5662230cc9affc8cc84f77fcf)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1984 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 #pragma ident	"%Z%%M%	%I%	%E% SMI"
31 
32 /*LINTLIBRARY*/
33 #include <stdio.h>
34 #include <ctype.h>
35 #include <stdarg.h>
36 #include <values.h>
37 #include <floatingpoint.h>
38 #include <errno.h>
39 #include <memory.h>
40 
41 #define NCHARS	(1 << BITSPERBYTE)
42 #define locgetc()	(chcount+=1,getc(iop))
43 #define locungetc(x)	(chcount-=1,ungetc(x,iop))
44 
45 static int chcount,flag_eof;
46 
47 static int	number(int, int, int, int, FILE *, va_list *);
48 static int	string(int, int, int, char *, FILE *, va_list *);
49 static unsigned char	*setup(unsigned char *, char *);
50 
51 #ifdef S5EMUL
52 #define	isws(c)		isspace(c)
53 #else
54 /*
55  * _sptab[c+1] is 1 iff 'c' is a white space character according to the
56  * 4.2BSD "scanf" definition - namely, SP, TAB, and NL are the only
57  * whitespace characters.
58  */
59 static char _sptab[1+256] = {
60 	0,				/* EOF - not a whitespace char */
61 	0,0,0,0,0,0,0,0,
62 	0,1,1,0,0,0,0,0,
63 	0,0,0,0,0,0,0,0,
64 	0,0,0,0,0,0,0,0,
65 	1,0,0,0,0,0,0,0,
66 	0,0,0,0,0,0,0,0,
67 	0,0,0,0,0,0,0,0,
68 	0,0,0,0,0,0,0,0,
69 	0,0,0,0,0,0,0,0,
70 	0,0,0,0,0,0,0,0,
71 	0,0,0,0,0,0,0,0,
72 	0,0,0,0,0,0,0,0,
73 	0,0,0,0,0,0,0,0,
74 	0,0,0,0,0,0,0,0,
75 	0,0,0,0,0,0,0,0,
76 	0,0,0,0,0,0,0,0,
77 };
78 
79 #define	isws(c)		((_sptab + 1)[c] != 0)
80 #endif
81 
82 int
83 _doscan(FILE *iop, unsigned char *fmt, va_list va_alist)
84 {
85 	char tab[NCHARS];
86 	int ch;
87 	int nmatch = 0, len, inchar, stow, size;
88 	chcount=0; flag_eof=0;
89 
90 	/*******************************************************
91 	 * Main loop: reads format to determine a pattern,
92 	 *		and then goes to read input stream
93 	 *		in attempt to match the pattern.
94 	 *******************************************************/
95 	for ( ; ; )
96 	{
97 		if ( (ch = *fmt++) == '\0')
98 			return(nmatch); /* end of format */
99 		if (isws(ch))
100 		{
101 		  	if (!flag_eof)
102 			{
103 			   while (isws(inchar = locgetc()))
104 				;
105 			   if (inchar == EOF) {
106 				chcount--;
107 				flag_eof = 1;
108 			   }
109 			   else if (locungetc(inchar) == EOF)
110 				flag_eof = 1;
111 			}
112 		  continue;
113 		}
114 		if (ch != '%' || (ch = *fmt++) == '%')
115                 {
116 			if ( (inchar = locgetc()) == ch )
117 				continue;
118 			if (inchar != EOF) {
119 				if (locungetc(inchar) != EOF)
120 					return(nmatch); /* failed to match input */
121 			} else {
122 				chcount--;
123 			}
124 			break;
125 		}
126 		if (ch == '*')
127 		{
128 			stow = 0;
129 			ch = *fmt++;
130 		}
131 		else
132 			stow = 1;
133 
134 		for (len = 0; isdigit(ch); ch = *fmt++)
135 			len = len * 10 + ch - '0';
136 		if (len == 0)
137 			len = MAXINT;
138 		if ( (size = ch) == 'l' || (size == 'h') || (size == 'L') )
139 			ch = *fmt++;
140 		if (ch == '\0' ||
141 		    ch == '[' && (fmt = setup(fmt, tab)) == NULL)
142 			return(EOF); /* unexpected end of format */
143 		if (isupper(ch))  /* no longer documented */
144 		{
145 			/*
146 			 * The rationale behind excluding the size
147 			 * of 'L' is that the 'L' size specifier was
148 			 * introduced in ANSI/ISO-C.  If the user
149 			 * specifies a format of %LG, it can mean
150 			 * nothing other than "long double", be the
151 			 * code ANSI or not.  Mapping it to "double"
152 			 * makes no sense.
153 			 */
154 			if (size != 'L')
155 				size = 'l';
156 #ifdef S5EMUL
157 			ch = _tolower(ch);
158 #else
159 			ch = tolower(ch);
160 #endif
161 		}
162 		switch(ch)
163 		{
164 		 case 'c':
165 		 case 's':
166 		 case '[':
167 			  if ((size = string(stow,ch,len,tab,iop,&va_alist)) < 0)
168 				goto out;	/* EOF seen, nothing converted */
169 			  break;
170                  case 'n':
171 			  if (stow == 0)
172 				continue;
173 			  if (size == 'h')
174 				*va_arg(va_alist, short *) = (short) chcount;
175 		          else if (size == 'l')
176 				*va_arg(va_alist, long *) = (long) chcount;
177 			  else
178 			  	*va_arg(va_alist, int *) = (int) chcount;
179 			  continue;
180                  default:
181 			 if ((size = number(stow, ch, len, size, iop, &va_alist)) < 0)
182 				goto out;	/* EOF seen, nothing converted */
183 			 break;
184                  }
185 		   if (size)
186 			nmatch += stow;
187 		   else
188 			return((flag_eof && !nmatch) ? EOF : nmatch);
189 		continue;
190 	}
191 out:
192 	return (nmatch != 0 ? nmatch : EOF); /* end of input */
193 }
194 
195 /*
196  **************************************************************
197  * Functions to read the input stream in an attempt to match incoming
198  * data to the current pattern from the main loop of _doscan().
199  **************************************************************
200  */
201 static int
202 number(int stow, int type, int len, int size, FILE *iop, va_list *listp)
203 {
204 	char numbuf[64], inchar, lookahead;
205 	char *np = numbuf;
206 	int c, base;
207 	int digitseen = 0, floater = 0, negflg = 0;
208 	long lcval = 0;
209 	switch(type)
210 	{
211 	case 'e':
212 	case 'f':
213 	case 'g':
214 		floater++;
215 	case 'd':
216 	case 'u':
217 	case 'i':
218 		base = 10;
219 		break;
220 	case 'o':
221 		base = 8;
222 		break;
223 	case 'x':
224 		base = 16;
225 		break;
226 	default:
227 		return(0); /* unrecognized conversion character */
228 	}
229 	if (!flag_eof)
230 	{
231 		while (isws(c = locgetc()))
232 			;
233 	}
234 	else
235 		c = locgetc();
236 	if (c == EOF) {
237 		chcount--;
238 		return(-1);	/* EOF before match */
239 	}
240         if (floater != 0) {     /* Handle floating point with
241                                  * file_to_decimal. */
242                 decimal_mode    dm;
243                 decimal_record  dr;
244                 fp_exception_field_type efs;
245                 enum decimal_string_form form;
246                 char           *echar;
247                 int             nread, ic;
248                 char            buffer[1024];
249                 char           *nb = buffer;
250 
251                 locungetc(c);
252 		if (len > 1024)
253 			len = 1024;
254                 file_to_decimal(&nb, len, 0, &dr, &form, &echar, iop, &nread);
255                 if (stow && (form != invalid_form)) {
256                         dm.rd = fp_direction;
257                         if (size == 'l') {      /* double */
258                                 decimal_to_double((double *) va_arg(*listp, double *), &dm, &dr, &efs);
259                         } else if (size == 'L') {      /* quad */
260                                 decimal_to_quadruple((quadruple *)va_arg(*listp, double *), &dm, &dr, &efs);
261                         } else {/* single */
262                                 decimal_to_single((float *) va_arg(*listp, float *), &dm, &dr, &efs);
263                         }
264 			if ((efs & (1 << fp_overflow)) != 0) {
265 				errno = ERANGE;
266 			}
267 			if ((efs & (1 << fp_underflow)) != 0) {
268 				errno = ERANGE;
269                         }
270                 }
271 		chcount += nread;	/* Count characters read. */
272                 c = *nb;        /* Get first unused character. */
273                 ic = c;
274                 if (c == NULL) {
275                         ic = locgetc();
276                         c = ic;
277                         /*
278                          * If null, first unused may have been put back
279                          * already.
280                          */
281                 }
282                 if (ic == EOF) {
283                         chcount--;
284                         flag_eof = 1;
285                 } else if (locungetc(c) == EOF)
286                         flag_eof = 1;
287                 return ((form == invalid_form) ? 0 : 1);        /* successful match if
288                                                                  * non-zero */
289         }
290 	switch(c) {
291 	case '-':
292 		negflg++;
293 		if (type == 'u')
294 			break;
295 	case '+': /* fall-through */
296 		if (--len <= 0)
297 			break;
298 		if ( (c = locgetc()) != '0')
299 			break;
300         case '0':
301                 if ( (type != 'i') || (len <= 1) )
302 		   break;
303 	        if ( ((inchar = locgetc()) == 'x') || (inchar == 'X') )
304 	        {
305 		      /* If not using sscanf and *
306 		       * at the buffer's end     *
307 		       * then LOOK ahead         */
308 
309                    if ( (iop->_flag & _IOSTRG) || (iop->_cnt != 0) )
310 		      lookahead = locgetc();
311 		   else
312 		   {
313 		      if ( read(fileno(iop),np,1) == 1)
314 		         lookahead = *np;
315                       else
316 		         lookahead = EOF;
317                       chcount += 1;
318                    }
319 		   if ( isxdigit(lookahead) )
320 		   {
321 		       base =16;
322 
323 		       if ( len <= 2)
324 		       {
325 			  locungetc(lookahead);
326 			  len -= 1;            /* Take into account the 'x'*/
327                        }
328 		       else
329 		       {
330 		          c = lookahead;
331 			  len -= 2;           /* Take into account '0x'*/
332 		       }
333                    }
334 	           else
335 	           {
336 	               locungetc(lookahead);
337 	               locungetc(inchar);
338                    }
339 		}
340 	        else
341 	        {
342 		    locungetc(inchar);
343 	            base = 8;
344                 }
345 	}
346 	if (!negflg || type != 'u')
347 	    for (; --len  >= 0 ; *np++ = c, c = locgetc())
348 	    {
349 		if (np > numbuf + 62)
350 		{
351 		    errno = ERANGE;
352 		    return(0);
353                 }
354 		if (isdigit(c))
355 		{
356 			int digit;
357 			digit = c - '0';
358 			if (base == 8)
359 			{
360 				if (digit >= 8)
361 					break;
362 				if (stow)
363 					lcval = (lcval<<3) + digit;
364 			}
365 			else
366 			{
367 				if (stow)
368 				{
369 					if (base == 10)
370 						lcval = (((lcval<<2) + lcval)<<1) + digit;
371 					else /* base == 16 */
372 						lcval = (lcval<<4) + digit;
373 				}
374 			}
375 			digitseen++;
376 
377 
378 			continue;
379 		}
380 		else if (base == 16 && isxdigit(c))
381 		{
382 			int digit;
383 			digit = c - (isupper(c) ? 'A' - 10 : 'a' - 10);
384 			if (stow)
385 				lcval = (lcval<<4) + digit;
386 			digitseen++;
387 			continue;
388 		}
389 		break;
390 	    }
391 
392 
393 	if (stow && digitseen)
394 		{
395 	 	/* suppress possible overflow on 2's-comp negation */
396 			if (negflg && lcval != HIBITL)
397 				lcval = -lcval;
398 			if (size == 'l')
399 				*va_arg(*listp, long *) = lcval;
400 			else if (size == 'h')
401 				*va_arg(*listp, short *) = (short)lcval;
402 			else
403 				*va_arg(*listp, int *) = (int)lcval;
404 		}
405 	if (c == EOF) {
406 		chcount--;
407 		flag_eof=1;
408 	} else if (locungetc(c) == EOF)
409 		flag_eof=1;
410 	return (digitseen); /* successful match if non-zero */
411 }
412 
413 static int
414 string(int stow, int type, int len, char *tab, FILE *iop, va_list *listp)
415 {
416 	int ch;
417 	char *ptr;
418 	char *start;
419 
420 	start = ptr = stow ? va_arg(*listp, char *) : NULL;
421 	if (type == 's')
422 	{
423 		if (!flag_eof)
424 		{
425 			while (isws(ch = locgetc()))
426 				;
427 		}
428 		else
429 			ch = locgetc();
430 		if (ch == EOF)
431 			return(-1);	/* EOF before match */
432 		while (ch != EOF && !isws(ch))
433 		{
434 			if (stow)
435 				*ptr = ch;
436 			ptr++;
437 			if (--len <= 0)
438 				break;
439 			ch = locgetc();
440 		}
441 	} else if (type == 'c') {
442 		if (len == MAXINT)
443 			len = 1;
444 		while ( (ch = locgetc()) != EOF)
445 		{
446 			if (stow)
447 				*ptr = ch;
448 			ptr++;
449 			if (--len <= 0)
450 				break;
451 		}
452 	} else { /* type == '[' */
453 		while ( (ch = locgetc()) != EOF && !tab[ch])
454 		{
455 			if (stow)
456 				*ptr = ch;
457 			ptr++;
458 			if (--len <= 0)
459 				break;
460 		}
461 	}
462 	if (ch == EOF )
463 	{
464 		chcount-=1;
465 		flag_eof = 1;
466 	}
467 	else if (len > 0 && locungetc(ch) == EOF)
468 		flag_eof = 1;
469 	if (ptr == start)
470 		return(0); /* no match */
471 	if (stow && type != 'c')
472 		*ptr = '\0';
473 	return (1); /* successful match */
474 }
475 
476 static unsigned char *
477 setup(unsigned char *fmt, char *tab)
478 {
479 	int b, c, d, t = 0;
480 
481 	if (*fmt == '^')
482 	{
483 		t++;
484 		fmt++;
485 	}
486 	(void) memset(tab, !t, NCHARS);
487 	if ( (c = *fmt) == ']' || c == '-')  /* first char is special */
488 	{
489 		tab[c] = t;
490 		fmt++;
491 	}
492 	while ( (c = *fmt++) != ']')
493 	{
494 		if (c == '\0')
495 			return(NULL); /* unexpected end of format */
496 		if (c == '-' && (d = *fmt) != ']' && (b = fmt[-2]) < d)
497 		{
498 			(void) memset(&tab[b], t, d - b + 1);
499 			fmt++;
500 		}
501 		else
502 			tab[c] = t;
503 	}
504 	return (fmt);
505 }
506