![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iovfscanf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / libg++ / libio|
Return to iovfscanf.c CVS log | Up to [Apple XNU] / GNUtools / libg++ / libio |
1.1 root 1: /*
2: Copyright (C) 1993 Free Software Foundation
3:
4: This file is part of the GNU IO Library. This library is free
5: software; you can redistribute it and/or modify it under the
6: terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This library is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with GNU CC; see the file COPYING. If not, write to
17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: As a special exception, if you link this library with files
20: compiled with a GNU compiler to produce an executable, this does not cause
21: the resulting executable to be covered by the GNU General Public License.
22: This exception does not however invalidate any other reasons why
23: the executable file might be covered by the GNU General Public License. */
24:
25: /*
26: * Copyright (c) 1990 The Regents of the University of California.
27: * All rights reserved.
28: *
29: * Redistribution and use in source and binary forms are permitted
30: * provided that the above copyright notice and this paragraph are
31: * duplicated in all such forms and that any documentation,
32: * advertising materials, and other materials related to such
33: * distribution and use acknowledge that the software was developed
34: * by the University of California, Berkeley. The name of the
35: * University may not be used to endorse or promote products derived
36: * from this software without specific prior written permission.
37: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
38: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
39: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
40: */
41:
42: /* Extensively hacked for GNU iostream by Per Bothner 1991, 1992, 1993.
43: Changes copyright Free Software Foundation 1992, 1993. */
44:
45: #if defined(LIBC_SCCS) && !defined(lint)
46: static char sccsid[] = "%W% (Berkeley) %G%";
47: #endif /* LIBC_SCCS and not lint */
48:
49: #include <libioP.h>
50: #include <ctype.h>
51: #ifdef __STDC__
52: #include <stdarg.h>
53: #else
54: #include <varargs.h>
55: #endif
56:
57: #ifndef NO_FLOATING_POINT
58: #define FLOATING_POINT
59: #endif
60:
61: #ifdef FLOATING_POINT
62: #include "floatio.h"
63: #define BUF (MAXEXP+MAXFRACT+3) /* 3 = sign + decimal point + NUL */
64: #else
65: #define BUF 40
66: #endif
67:
68: /*
69: * Flags used during conversion.
70: */
71: #define LONG 0x01 /* l: long or double */
72: #define LONGDBL 0x02 /* L: long double; unimplemented */
73: #define SHORT 0x04 /* h: short */
74: #define SUPPRESS 0x08 /* suppress assignment */
75: #define POINTER 0x10 /* weird %p pointer (`fake hex') */
76: #define NOSKIP 0x20 /* do not skip blanks */
77:
78: /*
79: * The following are used in numeric conversions only:
80: * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
81: * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
82: */
83: #define SIGNOK 0x40 /* +/- is (still) legal */
84: #define NDIGITS 0x80 /* no digits detected */
85:
86: #define DPTOK 0x100 /* (float) decimal point is still legal */
87: #define EXPOK 0x200 /* (float) exponent (e+3, etc) still legal */
88:
89: #define PFXOK 0x100 /* 0x prefix is (still) legal */
90: #define NZDIGITS 0x200 /* no zero digits detected */
91:
92: /*
93: * Conversion types.
94: */
95: #define CT_CHAR 0 /* %c conversion */
96: #define CT_CCL 1 /* %[...] conversion */
97: #define CT_STRING 2 /* %s conversion */
98: #define CT_INT 3 /* integer, i.e., strtol or strtoul */
99: #define CT_FLOAT 4 /* floating, i.e., strtod */
100:
101: #define u_char unsigned char
102: #define u_long unsigned long
103:
104: extern u_long strtoul _PARAMS((const char*, char**, int));
105: extern long strtol _PARAMS((const char*, char**, int));
106: static const u_char *__sccl _PARAMS((char *tab, const u_char *fmt));
107: #ifndef USE_DTOA
108: extern double atof();
109: #endif
110:
111: /* If errp != NULL, *errp|=1 if we see a premature EOF;
112: *errp|=2 if we an invalid character. */
113:
114: int
115: _IO_vfscanf(fp, fmt0, ap, errp)
116: register _IO_FILE *fp;
117: char const *fmt0;
118: _IO_va_list ap;
119: int *errp;
120: {
121: register const u_char *fmt = (const u_char *)fmt0;
122: register int c; /* character from format, or conversion */
123: register _IO_ssize_t width; /* field width, or 0 */
124: register char *p; /* points into all kinds of strings */
125: register int n; /* handy integer */
126: register int flags; /* flags as defined above */
127: register char *p0; /* saves original value of p when necessary */
128: int nassigned; /* number of fields assigned */
129: int nread; /* number of characters consumed from fp */
130: /* Assignments to base and ccfn are just to suppress warnings from gcc.*/
131: int base = 0; /* base argument to strtol/strtoul */
132: typedef u_long (*strtoulfn) _PARAMS((const char*, char**, int));
133: strtoulfn ccfn = 0;
134: /* conversion function (strtol/strtoul) */
135: char ccltab[256]; /* character class table for %[...] */
136: char buf[BUF]; /* buffer for numeric conversions */
137: int seen_eof = 0;
138:
139: /* `basefix' is used to avoid `if' tests in the integer scanner */
140: static short basefix[17] =
141: { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
142:
143: nassigned = 0;
144: nread = 0;
145: for (;;) {
146: c = *fmt++;
147: if (c == 0)
148: goto done;
149: if (isspace(c)) {
150: for (;;) {
151: c = _IO_getc(fp);
152: if (c == EOF) {
153: seen_eof++;
154: break;
155: }
156: if (!isspace(c)) {
157: _IO_ungetc (c, fp);
158: break;
159: }
160: nread++;
161: }
162: continue;
163: }
164: if (c != '%')
165: goto literal;
166: width = 0;
167: flags = 0;
168: /*
169: * switch on the format. continue if done;
170: * break once format type is derived.
171: */
172: again: c = *fmt++;
173: switch (c) {
174: case '%':
175: literal:
176: n = _IO_getc(fp);
177: if (n == EOF)
178: goto eof_failure;
179: if (n != c) {
180: _IO_ungetc (n, fp);
181: goto match_failure;
182: }
183: nread++;
184: continue;
185:
186: case '*':
187: flags |= SUPPRESS;
188: goto again;
189: case 'l':
190: flags |= LONG;
191: goto again;
192: case 'L':
193: flags |= LONGDBL;
194: goto again;
195: case 'h':
196: flags |= SHORT;
197: goto again;
198:
199: case '0': case '1': case '2': case '3': case '4':
200: case '5': case '6': case '7': case '8': case '9':
201: width = width * 10 + c - '0';
202: goto again;
203:
204: /*
205: * Conversions.
206: * Those marked `compat' are for 4.[123]BSD compatibility.
207: *
208: * (According to ANSI, E and X formats are supposed
209: * to the same as e and x. Sorry about that.)
210: */
211: case 'D': /* compat */
212: flags |= LONG;
213: /* FALLTHROUGH */
214: case 'd':
215: c = CT_INT;
216: ccfn = (strtoulfn)strtol;
217: base = 10;
218: break;
219:
220: case 'i':
221: c = CT_INT;
222: ccfn = (strtoulfn)strtol;
223: base = 0;
224: break;
225:
226: case 'O': /* compat */
227: flags |= LONG;
228: /* FALLTHROUGH */
229: case 'o':
230: c = CT_INT;
231: ccfn = strtoul;
232: base = 8;
233: break;
234:
235: case 'u':
236: c = CT_INT;
237: ccfn = strtoul;
238: base = 10;
239: break;
240:
241: case 'X':
242: case 'x':
243: flags |= PFXOK; /* enable 0x prefixing */
244: c = CT_INT;
245: ccfn = strtoul;
246: base = 16;
247: break;
248:
249: #ifdef FLOATING_POINT
250: case 'E': case 'F':
251: case 'e': case 'f': case 'g':
252: c = CT_FLOAT;
253: break;
254: #endif
255:
256: case 's':
257: c = CT_STRING;
258: break;
259:
260: case '[':
261: fmt = __sccl(ccltab, fmt);
262: flags |= NOSKIP;
263: c = CT_CCL;
264: break;
265:
266: case 'c':
267: flags |= NOSKIP;
268: c = CT_CHAR;
269: break;
270:
271: case 'p': /* pointer format is like hex */
272: flags |= POINTER | PFXOK;
273: c = CT_INT;
274: ccfn = strtoul;
275: base = 16;
276: break;
277:
278: case 'n':
279: if (flags & SUPPRESS) /* ??? */
280: continue;
281: if (flags & SHORT)
282: *va_arg(ap, short *) = nread;
283: else if (flags & LONG)
284: *va_arg(ap, long *) = nread;
285: else
286: *va_arg(ap, int *) = nread;
287: continue;
288:
289: /*
290: * Disgusting backwards compatibility hacks. XXX
291: */
292: case '\0': /* compat */
293: nassigned = EOF;
294: goto done;
295:
296: default: /* compat */
297: if (isupper(c))
298: flags |= LONG;
299: c = CT_INT;
300: ccfn = (strtoulfn)strtol;
301: base = 10;
302: break;
303: }
304:
305: /*
306: * We have a conversion that requires input.
307: */
308: if (_IO_peekc(fp) == EOF)
309: goto eof_failure;
310:
311: /*
312: * Consume leading white space, except for formats
313: * that suppress this.
314: */
315: if ((flags & NOSKIP) == 0) {
316: n = (unsigned char)*fp->_IO_read_ptr;
317: while (isspace(n)) {
318: fp->_IO_read_ptr++;
319: nread++;
320: n = _IO_peekc(fp);
321: if (n == EOF)
322: goto eof_failure;
323: }
324: /* Note that there is at least one character in
325: the buffer, so conversions that do not set NOSKIP
326: can no longer result in an input failure. */
327: }
328:
329: /*
330: * Do the conversion.
331: */
332: switch (c) {
333:
334: case CT_CHAR:
335: /* scan arbitrary characters (sets NOSKIP) */
336: if (width == 0) /* FIXME! */
337: width = 1;
338: if (flags & SUPPRESS) {
339: _IO_size_t sum = 0;
340: for (;;) {
341: n = fp->_IO_read_end - fp->_IO_read_ptr;
342: if (n < (int)width) {
343: sum += n;
344: width -= n;
345: fp->_IO_read_ptr += n;
346: if (__underflow(fp) == EOF)
347: if (sum == 0)
348: goto eof_failure;
349: else {
350: seen_eof++;
351: break;
352: }
353: } else {
354: sum += width;
355: fp->_IO_read_ptr += width;
356: break;
357: }
358: }
359: nread += sum;
360: } else {
361: _IO_size_t r =
362: (*fp->_jumps->__xsgetn)(fp,
363: (char*)va_arg(ap, char*),
364: width);
365: if (r != width)
366: goto eof_failure;
367: nread += r;
368: nassigned++;
369: }
370: break;
371:
372: case CT_CCL:
373: /* scan a (nonempty) character class (sets NOSKIP) */
374: if (width == 0)
375: width = ~0; /* `infinity' */
376: /* take only those things in the class */
377: if (flags & SUPPRESS) {
378: n = 0;
379: while (ccltab[(unsigned char)*fp->_IO_read_ptr]) {
380: n++, fp->_IO_read_ptr++;
381: if (--width == 0)
382: break;
383: if (_IO_peekc(fp) == EOF) {
384: if (n == 0)
385: goto eof_failure;
386: seen_eof++;
387: break;
388: }
389: }
390: if (n == 0)
391: goto match_failure;
392: } else {
393: p0 = p = va_arg(ap, char *);
394: while (ccltab[(unsigned char)*fp->_IO_read_ptr]) {
395: *p++ = *fp->_IO_read_ptr++;
396: if (--width == 0)
397: break;
398: if (_IO_peekc(fp) == EOF) {
399: if (p == p0)
400: goto eof_failure;
401: seen_eof++;
402: break;
403: }
404: }
405: n = p - p0;
406: if (n == 0)
407: goto match_failure;
408: *p = 0;
409: nassigned++;
410: }
411: nread += n;
412: break;
413:
414: case CT_STRING:
415: /* like CCL, but zero-length string OK, & no NOSKIP */
416: if (width == 0)
417: width = ~0;
418: if (flags & SUPPRESS) {
419: n = 0;
420: while (!isspace((unsigned char)*fp->_IO_read_ptr)) {
421: n++, fp->_IO_read_ptr++;
422: if (--width == 0)
423: break;
424: if (_IO_peekc(fp) == EOF) {
425: seen_eof++;
426: break;
427: }
428: }
429: nread += n;
430: } else {
431: p0 = p = va_arg(ap, char *);
432: while (!isspace((unsigned char)*fp->_IO_read_ptr)) {
433: *p++ = *fp->_IO_read_ptr++;
434: if (--width == 0)
435: break;
436: if (_IO_peekc(fp) == EOF) {
437: seen_eof++;
438: break;
439: }
440: }
441: *p = 0;
442: nread += p - p0;
443: nassigned++;
444: }
445: continue;
446:
447: case CT_INT:
448: /* scan an integer as if by strtol/strtoul */
449: if (width == 0 || width > sizeof(buf) - 1)
450: width = sizeof(buf) - 1;
451: flags |= SIGNOK | NDIGITS | NZDIGITS;
452: for (p = buf; width; width--) {
453: c = (unsigned char)*fp->_IO_read_ptr;
454: /*
455: * Switch on the character; `goto ok'
456: * if we accept it as a part of number.
457: */
458: switch (c) {
459:
460: /*
461: * The digit 0 is always legal, but is
462: * special. For %i conversions, if no
463: * digits (zero or nonzero) have been
464: * scanned (only signs), we will have
465: * base==0. In that case, we should set
466: * it to 8 and enable 0x prefixing.
467: * Also, if we have not scanned zero digits
468: * before this, do not turn off prefixing
469: * (someone else will turn it off if we
470: * have scanned any nonzero digits).
471: */
472: case '0':
473: if (base == 0) {
474: base = 8;
475: flags |= PFXOK;
476: }
477: if (flags & NZDIGITS)
478: flags &= ~(SIGNOK|NZDIGITS|NDIGITS);
479: else
480: flags &= ~(SIGNOK|PFXOK|NDIGITS);
481: goto ok;
482:
483: /* 1 through 7 always legal */
484: case '1': case '2': case '3':
485: case '4': case '5': case '6': case '7':
486: base = basefix[base];
487: flags &= ~(SIGNOK | PFXOK | NDIGITS);
488: goto ok;
489:
490: /* digits 8 and 9 ok iff decimal or hex */
491: case '8': case '9':
492: base = basefix[base];
493: if (base <= 8)
494: break; /* not legal here */
495: flags &= ~(SIGNOK | PFXOK | NDIGITS);
496: goto ok;
497:
498: /* letters ok iff hex */
499: case 'A': case 'B': case 'C':
500: case 'D': case 'E': case 'F':
501: case 'a': case 'b': case 'c':
502: case 'd': case 'e': case 'f':
503: /* no need to fix base here */
504: if (base <= 10)
505: break; /* not legal here */
506: flags &= ~(SIGNOK | PFXOK | NDIGITS);
507: goto ok;
508:
509: /* sign ok only as first character */
510: case '+': case '-':
511: if (flags & SIGNOK) {
512: flags &= ~SIGNOK;
513: goto ok;
514: }
515: break;
516:
517: /* x ok iff flag still set & 2nd char */
518: case 'x': case 'X':
519: if (flags & PFXOK && p == buf + 1) {
520: base = 16; /* if %i */
521: flags &= ~PFXOK;
522: goto ok;
523: }
524: break;
525: }
526:
527: /*
528: * If we got here, c is not a legal character
529: * for a number. Stop accumulating digits.
530: */
531: break;
532: ok:
533: /*
534: * c is legal: store it and look at the next.
535: */
536: *p++ = c;
537: fp->_IO_read_ptr++;
538: if (_IO_peekc(fp) == EOF) {
539: seen_eof++;
540: break; /* EOF */
541: }
542: }
543: /*
544: * If we had only a sign, it is no good; push
545: * back the sign. If the number ends in `x',
546: * it was [sign] '0' 'x', so push back the x
547: * and treat it as [sign] '0'.
548: */
549: if (flags & NDIGITS) {
550: if (p > buf)
551: (void) _IO_ungetc(*(u_char *)--p, fp);
552: goto match_failure;
553: }
554: c = ((u_char *)p)[-1];
555: if (c == 'x' || c == 'X') {
556: --p;
557: (void) _IO_ungetc (c, fp);
558: }
559: if ((flags & SUPPRESS) == 0) {
560: u_long res;
561:
562: *p = 0;
563: res = (*ccfn)(buf, (char **)NULL, base);
564: if (flags & POINTER)
565: *va_arg(ap, void **) = (void *)res;
566: else if (flags & SHORT)
567: *va_arg(ap, short *) = res;
568: else if (flags & LONG)
569: *va_arg(ap, long *) = res;
570: else
571: *va_arg(ap, int *) = res;
572: nassigned++;
573: }
574: nread += p - buf;
575: break;
576:
577: #ifdef FLOATING_POINT
578: case CT_FLOAT:
579: /* scan a floating point number as if by strtod */
580: if (width == 0 || width > sizeof(buf) - 1)
581: width = sizeof(buf) - 1;
582: flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
583: for (p = buf; width; width--) {
584: c = (unsigned char)*fp->_IO_read_ptr;
585: /*
586: * This code mimicks the integer conversion
587: * code, but is much simpler.
588: */
589: switch (c) {
590:
591: case '0': case '1': case '2': case '3':
592: case '4': case '5': case '6': case '7':
593: case '8': case '9':
594: flags &= ~(SIGNOK | NDIGITS);
595: goto fok;
596:
597: case '+': case '-':
598: if (flags & SIGNOK) {
599: flags &= ~SIGNOK;
600: goto fok;
601: }
602: break;
603: case '.':
604: if (flags & DPTOK) {
605: flags &= ~(SIGNOK | DPTOK);
606: goto fok;
607: }
608: break;
609: case 'e': case 'E':
610: /* no exponent without some digits */
611: if ((flags&(NDIGITS|EXPOK)) == EXPOK) {
612: flags =
613: (flags & ~(EXPOK|DPTOK)) |
614: SIGNOK | NDIGITS;
615: goto fok;
616: }
617: break;
618: }
619: break;
620: fok:
621: *p++ = c;
622: fp->_IO_read_ptr++;
623: if (_IO_peekc(fp) == EOF) {
624: seen_eof++;
625: break; /* EOF */
626: }
627: }
628: /*
629: * If no digits, might be missing exponent digits
630: * (just give back the exponent) or might be missing
631: * regular digits, but had sign and/or decimal point.
632: */
633: if (flags & NDIGITS) {
634: if (flags & EXPOK) {
635: /* no digits at all */
636: while (p > buf)
637: _IO_ungetc (*(u_char *)--p, fp);
638: goto match_failure;
639: }
640: /* just a bad exponent (e and maybe sign) */
641: c = *(u_char *)--p;
642: if (c != 'e' && c != 'E') {
643: (void) _IO_ungetc (c, fp);/* sign */
644: c = *(u_char *)--p;
645: }
646: (void) _IO_ungetc (c, fp);
647: }
648: if ((flags & SUPPRESS) == 0) {
649: double res;
650: *p = 0;
651: #ifdef USE_DTOA
652: res = _IO_strtod(buf, NULL);
653: #else
654: res = atof(buf);
655: #endif
656: if (flags & LONG)
657: *va_arg(ap, double *) = res;
658: else
659: *va_arg(ap, float *) = res;
660: nassigned++;
661: }
662: nread += p - buf;
663: break;
664: #endif /* FLOATING_POINT */
665: }
666: }
667: eof_failure:
668: seen_eof++;
669: input_failure:
670: if (nassigned == 0)
671: nassigned = -1;
672: match_failure:
673: if (errp)
674: *errp |= 2;
675: done:
676: if (errp && seen_eof)
677: *errp |= 1;
678: return (nassigned);
679: }
680:
681: /*
682: * Fill in the given table from the scanset at the given format
683: * (just after `['). Return a pointer to the character past the
684: * closing `]'. The table has a 1 wherever characters should be
685: * considered part of the scanset.
686: */
687: static const u_char *__sccl(tab, fmt)
688: register char *tab;
689: register const u_char *fmt;
690: {
691: register int c, n, v;
692:
693: /* first `clear' the whole table */
694: c = *fmt++; /* first char hat => negated scanset */
695: if (c == '^') {
696: v = 1; /* default => accept */
697: c = *fmt++; /* get new first char */
698: } else
699: v = 0; /* default => reject */
700: /* should probably use memset here */
701: for (n = 0; n < 256; n++)
702: tab[n] = v;
703: if (c == 0)
704: return (fmt - 1);/* format ended before closing ] */
705:
706: /*
707: * Now set the entries corresponding to the actual scanset
708: * to the opposite of the above.
709: *
710: * The first character may be ']' (or '-') without being special;
711: * the last character may be '-'.
712: */
713: v = 1 - v;
714: for (;;) {
715: tab[c] = v; /* take character c */
716: doswitch:
717: n = *fmt++; /* and examine the next */
718: switch (n) {
719:
720: case 0: /* format ended too soon */
721: return (fmt - 1);
722:
723: case '-':
724: /*
725: * A scanset of the form
726: * [01+-]
727: * is defined as `the digit 0, the digit 1,
728: * the character +, the character -', but
729: * the effect of a scanset such as
730: * [a-zA-Z0-9]
731: * is implementation defined. The V7 Unix
732: * scanf treats `a-z' as `the letters a through
733: * z', but treats `a-a' as `the letter a, the
734: * character -, and the letter a'.
735: *
736: * For compatibility, the `-' is not considerd
737: * to define a range if the character following
738: * it is either a close bracket (required by ANSI)
739: * or is not numerically greater than the character
740: * we just stored in the table (c).
741: */
742: n = *fmt;
743: if (n == ']' || n < c) {
744: c = '-';
745: break; /* resume the for(;;) */
746: }
747: fmt++;
748: do { /* fill in the range */
749: tab[++c] = v;
750: } while (c < n);
751: #if 1 /* XXX another disgusting compatibility hack */
752: /*
753: * Alas, the V7 Unix scanf also treats formats
754: * such as [a-c-e] as `the letters a through e'.
755: * This too is permitted by the standard....
756: */
757: goto doswitch;
758: #else
759: c = *fmt++;
760: if (c == 0)
761: return (fmt - 1);
762: if (c == ']')
763: return (fmt);
764: #endif
765: break;
766:
767: case ']': /* end of scanset */
768: return (fmt);
769:
770: default: /* just another character */
771: c = n;
772: break;
773: }
774: }
775: /* NOTREACHED */
776: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.