?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Wed May 22 00:40:50 1996 David Mosberger-Tang <davidm@azstarnet.com>
[glibc/history.git] / stdio-common / vfscanf.c
blobbadaa2f93d31a28dfef7cfe95ca892b5d96f9443
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB. If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA. */
18
19 #include "../locale/localeinfo.h"
20 #include <errno.h>
21 #include <limits.h>
22 #include <ctype.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #ifdef __GNUC__
29 #define HAVE_LONGLONG
30 #define LONGLONG long long
31 #else
32 #define LONGLONG long
33 #endif
34
35 /* Those are flags in the conversion format. */
36 # define LONG 0x001 /* l: long or double */
37 # define LONGDBL 0x002 /* L: long long or long double */
38 # define SHORT 0x004 /* h: short */
39 # define SUPPRESS 0x008 /* *: suppress assignment */
40 # define POINTER 0x010 /* weird %p pointer (`fake hex') */
41 # define NOSKIP 0x020 /* do not skip blanks */
42 # define WIDTH 0x040 /* width was given */
43 # define GROUP 0x080 /* ': group numbers */
44 # define MALLOC 0x100 /* a: malloc strings */
45
46 # define TYPEMOD (LONG|LONGDBL|SHORT)
47
48
49 #ifdef USE_IN_LIBIO
50 # include <libioP.h>
51 # include <libio.h>
52
53 # define va_list _IO_va_list
54 # define ungetc(c, s) _IO_ungetc (c, s)
55 # define inchar() ((c = _IO_getc_unlocked (s)), (void) ++read_in, c)
56 # define conv_error() do { \
57 if (errp != NULL) *errp |= 2; \
58 if (c != EOF) _IO_ungetc (c, s); \
59 _IO_funlockfile (s); \
60 return done; \
61 } while (0)
62 # define input_error() do { \
63 _IO_funlockfile (s); \
64 if (errp != NULL) *errp |= 1; \
65 return done ?: EOF; \
66 } while (0)
67 # define memory_error() do { \
68 _IO_funlockfile (s); \
69 errno = ENOMEM; \
70 return EOF; \
71 } while (0)
72 # define ARGCHECK(s, format) \
73 do \
74 { \
75 /* Check file argument for consistence. */ \
76 CHECK_FILE (s, EOF); \
77 if (s->_flags & _IO_NO_READS || format == NULL) \
78 { \
79 MAYBE_SET_EINVAL; \
80 return EOF; \
81 } \
82 } while (0)
83 #else
84 # define inchar() ((c = getc (s)), (void) ++read_in, c)
85 # define conv_error() do { \
86 funlockfile (s); \
87 ungetc (c, s); \
88 return done; \
89 } while (0)
90 # define input_error() do { \
91 funlockfile (s); \
92 return done ?: EOF; \
93 } while (0)
94 # define memory_error() do { \
95 funlockfile (s); \
96 errno = ENOMEM; \
97 return EOF; \
98 } while (0)
99 # define ARGCHECK(s, format) \
100 do \
101 { \
102 /* Check file argument for consistence. */ \
103 if (!__validfp (s) || !s->__mode.__read || format == NULL) \
104 { \
105 errno = EINVAL; \
106 return EOF; \
107 } \
108 } while (0)
109 # define flockfile(S) /* nothing */
110 # define funlockfile(S) /* nothing */
111 #endif
112
113
114 /* Read formatted input from S according to the format string
115 FORMAT, using the argument list in ARG.
116 Return the number of assignments made, or -1 for an input error. */
117 #ifdef USE_IN_LIBIO
118 int
119 _IO_vfscanf (s, format, argptr, errp)
120 _IO_FILE *s;
121 const char *format;
122 _IO_va_list argptr;
123 int *errp;
124 #else
125 int
126 __vfscanf (FILE *s, const char *format, va_list argptr)
127 #endif
128 {
129 va_list arg = (va_list) argptr;
130
131 register const char *f = format;
132 register unsigned char fc; /* Current character of the format. */
133 register size_t done = 0; /* Assignments done. */
134 register size_t read_in = 0; /* Chars read in. */
135 register int c; /* Last char read. */
136 register int width; /* Maximum field width. */
137 register int flags; /* Modifiers for current format element. */
138
139 /* Status for reading F-P nums. */
140 char got_dot, got_e, negative;
141 /* If a [...] is a [^...]. */
142 char not_in;
143 /* Base for integral numbers. */
144 int base;
145 /* Signedness for integral numbers. */
146 int number_signed;
147 /* Decimal point character. */
148 wchar_t decimal;
149 /* The thousands character of the current locale. */
150 wchar_t thousands;
151 /* Integral holding variables. */
152 union
153 {
154 long long int q;
155 unsigned long long int uq;
156 long int l;
157 unsigned long int ul;
158 } num;
159 /* Character-buffer pointer. */
160 register char *str, **strptr;
161 size_t strsize;
162 /* We must not react on white spaces immediately because they can
163 possibly be matched even if in the input stream no character is
164 available anymore. */
165 int skip_space = 0;
166 /* Workspace. */
167 char *tw; /* Temporary pointer. */
168 char *wp = NULL; /* Workspace. */
169 size_t wpmax = 0; /* Maximal size of workspace. */
170 size_t wpsize; /* Currently used bytes in workspace. */
171 #define ADDW(Ch) \
172 do \
173 { \
174 if (wpsize == wpmax) \
175 { \
176 char *old = wp; \
177 wpmax = UCHAR_MAX > 2 * wpmax ? UCHAR_MAX : 2 * wpmax; \
178 wp = (char *) alloca (wpmax); \
179 if (old != NULL) \
180 memcpy (wp, old, wpsize); \
181 } \
182 wp[wpsize++] = (Ch); \
183 } \
184 while (0)
185
186 ARGCHECK (s, format);
187
188 /* Figure out the decimal point character. */
189 if (mbtowc (&decimal, _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT),
190 strlen (_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT))) <= 0)
191 decimal = (wchar_t) *_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
192 /* Figure out the thousands separator character. */
193 if (mbtowc (&thousands, _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
194 strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
195 thousands = (wchar_t) *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
196
197 /* Lock the stream. */
198 flockfile (s);
199
200 c = inchar ();
201
202 /* Run through the format string. */
203 while (*f != '\0')
204 {
205 unsigned int argpos;
206 /* Extract the next argument, which is of type TYPE.
207 For a %N$... spec, this is the Nth argument from the beginning;
208 otherwise it is the next argument after the state now in ARG. */
209 #if 0
210 /* XXX Possible optimization. */
211 # define ARG(type) (argpos == 0 ? va_arg (arg, type) : \
212 ({ va_list arg = (va_list) argptr; \
213 arg = (va_list) ((char *) arg \
214 + (argpos - 1) \
215 * __va_rounded_size (void *)); \
216 va_arg (arg, type); \
217 }))
218 #else
219 # define ARG(type) (argpos == 0 ? va_arg (arg, type) : \
220 ({ unsigned int pos = argpos; \
221 va_list arg = (va_list) argptr; \
222 while (--pos > 0) \
223 (void) va_arg (arg, void *); \
224 va_arg (arg, type); \
225 }))
226 #endif
227
228 if (!isascii (*f))
229 {
230 /* Non-ASCII, may be a multibyte. */
231 int len = mblen (f, strlen (f));
232 if (len > 0)
233 {
234 while (len-- > 0)
235 if (c == EOF)
236 input_error ();
237 else if (c == *f++)
238 (void) inchar ();
239 else
240 conv_error ();
241 continue;
242 }
243 }
244
245 fc = *f++;
246 if (fc != '%')
247 {
248 /* Remember to skip spaces. */
249 if (isspace (fc))
250 {
251 skip_space = 1;
252 continue;
253 }
254
255 /* Characters other than format specs must just match. */
256 if (c == EOF)
257 input_error ();
258
259 /* We saw white space char as the last character in the format
260 string. Now it's time to skip all leading white space. */
261 if (skip_space)
262 {
263 while (isspace (c))
264 (void) inchar ();
265 skip_space = 0;
266 }
267
268 if (c == fc)
269 (void) inchar ();
270 else
271 conv_error ();
272
273 continue;
274 }
275
276 /* This is the start of the conversion string. */
277 flags = 0;
278
279 /* Initialize state of modifiers. */
280 argpos = 0;
281
282 /* Prepare temporary buffer. */
283 wpsize = 0;
284
285 /* Check for a positional parameter specification. */
286 if (isdigit (*f))
287 {
288 argpos = *f++ - '0';
289 while (isdigit (*f))
290 argpos = argpos * 10 + (*f++ - '0');
291 if (*f == '$')
292 ++f;
293 else
294 {
295 /* Oops; that was actually the field width. */
296 width = argpos;
297 flags |= WIDTH;
298 argpos = 0;
299 goto got_width;
300 }
301 }
302
303 /* Check for the assignment-suppressant and the number grouping flag. */
304 while (*f == '*' || *f == '\'')
305 switch (*f++)
306 {
307 case '*':
308 flags |= SUPPRESS;
309 break;
310 case '\'':
311 flags |= GROUP;
312 break;
313 }
314
315 /* We have seen width. */
316 if (isdigit (*f))
317 flags |= WIDTH;
318
319 /* Find the maximum field width. */
320 width = 0;
321 while (isdigit (*f))
322 {
323 width *= 10;
324 width += *f++ - '0';
325 }
326 got_width:
327 if (width == 0)
328 width = -1;
329
330 /* Check for type modifiers. */
331 while (*f == 'h' || *f == 'l' || *f == 'L' || *f == 'a' || *f == 'q')
332 switch (*f++)
333 {
334 case 'h':
335 /* int's are short int's. */
336 if (flags & TYPEMOD)
337 /* Signal illegal format element. */
338 conv_error ();
339 flags |= SHORT;
340 break;
341 case 'l':
342 if (flags & (SHORT|LONGDBL))
343 conv_error ();
344 else if (flags & LONG)
345 {
346 /* A double `l' is equivalent to an `L'. */
347 flags &= ~LONG;
348 flags |= LONGDBL;
349 }
350 else
351 /* int's are long int's. */
352 flags |= LONG;
353 break;
354 case 'q':
355 case 'L':
356 /* double's are long double's, and int's are long long int's. */
357 if (flags & TYPEMOD)
358 /* Signal illegal format element. */
359 conv_error ();
360 flags |= LONGDBL;
361 break;
362 case 'a':
363 if (flags & TYPEMOD)
364 /* Signal illegal format element. */
365 conv_error ();
366 /* String conversions (%s, %[) take a `char **'
367 arg and fill it in with a malloc'd pointer. */
368 flags |= MALLOC;
369 break;
370 }
371
372 /* End of the format string? */
373 if (*f == '\0')
374 conv_error ();
375
376 /* Find the conversion specifier. */
377 fc = *f++;
378 if (skip_space || (fc != '[' && fc != 'c' && fc != 'n'))
379 {
380 /* Eat whitespace. */
381 while (isspace (c))
382 (void) inchar ();
383 skip_space = 0;
384 }
385
386 switch (fc)
387 {
388 case '%': /* Must match a literal '%'. */
389 if (c != fc)
390 conv_error ();
391 inchar ();
392 break;
393
394 case 'n': /* Answer number of assignments done. */
395 /* Corrigendum 1 to ISO C 1990 describes the allowed flags
396 with the 'n' conversion specifier. */
397 if (!(flags & SUPPRESS))
398 /* Don't count the read-ahead. */
399 if (flags & LONGDBL)
400 *ARG (long long int *) = read_in - 1;
401 else if (flags & LONG)
402 *ARG (long int *) = read_in - 1;
403 else if (flags & SHORT)
404 *ARG (short int *) = read_in - 1;
405 else
406 *ARG (int *) = read_in - 1;
407 break;
408
409 case 'c': /* Match characters. */
410 if (!(flags & SUPPRESS))
411 {
412 str = ARG (char *);
413 if (str == NULL)
414 conv_error ();
415 }
416
417 if (c == EOF)
418 input_error ();
419
420 if (width == -1)
421 width = 1;
422
423 if (!(flags & SUPPRESS))
424 {
425 do
426 *str++ = c;
427 while (inchar () != EOF && --width > 0);
428 }
429 else
430 while (inchar () != EOF && --width > 0);
431
432 if (!(flags & SUPPRESS))
433 ++done;
434
435 break;
436
437 case 's': /* Read a string. */
438 #define STRING_ARG \
439 if (!(flags & SUPPRESS)) \
440 { \
441 if (flags & MALLOC) \
442 { \
443 /* The string is to be stored in a malloc'd buffer. */ \
444 strptr = ARG (char **); \
445 if (strptr == NULL) \
446 conv_error (); \
447 /* Allocate an initial buffer. */ \
448 strsize = 100; \
449 *strptr = str = malloc (strsize); \
450 } \
451 else \
452 str = ARG (char *); \
453 if (str == NULL) \
454 conv_error (); \
455 }
456 STRING_ARG;
457
458 if (c == EOF)
459 input_error ();
460
461 do
462 {
463 if (isspace (c))
464 break;
465 #define STRING_ADD_CHAR(c) \
466 if (!(flags & SUPPRESS)) \
467 { \
468 *str++ = c; \
469 if ((flags & MALLOC) && str == *strptr + strsize) \
470 { \
471 /* Enlarge the buffer. */ \
472 str = realloc (*strptr, strsize * 2); \
473 if (str == NULL) \
474 { \
475 /* Can't allocate that much. Last-ditch effort. */\
476 str = realloc (*strptr, strsize + 1); \
477 if (str == NULL) \
478 { \
479 /* We lose. Oh well. \
480 Terminate the string and stop converting, \
481 so at least we don't skip any input. */ \
482 (*strptr)[strsize] = '\0'; \
483 ++done; \
484 conv_error (); \
485 } \
486 else \
487 { \
488 *strptr = str; \
489 str += strsize; \
490 ++strsize; \
491 } \
492 } \
493 else \
494 { \
495 *strptr = str; \
496 str += strsize; \
497 strsize *= 2; \
498 } \
499 } \
500 }
501 STRING_ADD_CHAR (c);
502 } while (inchar () != EOF && (width <= 0 || --width > 0));
503
504 if (!(flags & SUPPRESS))
505 {
506 *str = '\0';
507 ++done;
508 }
509 break;
510
511 case 'x': /* Hexadecimal integer. */
512 case 'X': /* Ditto. */
513 base = 16;
514 number_signed = 0;
515 goto number;
516
517 case 'o': /* Octal integer. */
518 base = 8;
519 number_signed = 0;
520 goto number;
521
522 case 'u': /* Unsigned decimal integer. */
523 base = 10;
524 number_signed = 0;
525 goto number;
526
527 case 'd': /* Signed decimal integer. */
528 base = 10;
529 number_signed = 1;
530 goto number;
531
532 case 'i': /* Generic number. */
533 base = 0;
534 number_signed = 1;
535
536 number:
537 if (c == EOF)
538 input_error ();
539
540 /* Check for a sign. */
541 if (c == '-' || c == '+')
542 {
543 ADDW (c);
544 if (width > 0)
545 --width;
546 (void) inchar ();
547 }
548
549 /* Look for a leading indication of base. */
550 if (width != 0 && c == '0')
551 {
552 if (width > 0)
553 --width;
554
555 ADDW (c);
556 (void) inchar ();
557
558 if (width != 0 && tolower (c) == 'x')
559 {
560 if (base == 0)
561 base = 16;
562 if (base == 16)
563 {
564 if (width > 0)
565 --width;
566 (void) inchar ();
567 }
568 }
569 else if (base == 0)
570 base = 8;
571 }
572
573 if (base == 0)
574 base = 10;
575
576 /* Read the number into workspace. */
577 while (c != EOF && width != 0)
578 {
579 if (base == 16 ? !isxdigit (c) :
580 ((!isdigit (c) || c - '0' >= base) &&
581 !((flags & GROUP) && base == 10 && c == thousands)))
582 break;
583 ADDW (c);
584 if (width > 0)
585 --width;
586
587 (void) inchar ();
588 }
589
590 if (wpsize == 0 ||
591 (wpsize == 1 && (wp[0] == '+' || wp[0] == '-')))
592 /* There was no number. */
593 conv_error ();
594
595 /* Convert the number. */
596 ADDW ('\0');
597 if (flags & LONGDBL)
598 {
599 if (number_signed)
600 num.q = __strtoq_internal (wp, &tw, base, flags & GROUP);
601 else
602 num.uq = __strtouq_internal (wp, &tw, base, flags & GROUP);
603 }
604 else
605 {
606 if (number_signed)
607 num.l = __strtol_internal (wp, &tw, base, flags & GROUP);
608 else
609 num.ul = __strtoul_internal (wp, &tw, base, flags & GROUP);
610 }
611 if (wp == tw)
612 conv_error ();
613
614 if (!(flags & SUPPRESS))
615 {
616 if (! number_signed)
617 {
618 if (flags & LONGDBL)
619 *ARG (unsigned LONGLONG int *) = num.uq;
620 else if (flags & LONG)
621 *ARG (unsigned long int *) = num.ul;
622 else if (flags & SHORT)
623 *ARG (unsigned short int *)
624 = (unsigned short int) num.ul;
625 else
626 *ARG (unsigned int *) = (unsigned int) num.ul;
627 }
628 else
629 {
630 if (flags & LONGDBL)
631 *ARG (LONGLONG int *) = num.q;
632 else if (flags & LONG)
633 *ARG (long int *) = num.l;
634 else if (flags & SHORT)
635 *ARG (short int *) = (short int) num.l;
636 else
637 *ARG (int *) = (int) num.l;
638 }
639 ++done;
640 }
641 break;
642
643 case 'e': /* Floating-point numbers. */
644 case 'E':
645 case 'f':
646 case 'g':
647 case 'G':
648 if (c == EOF)
649 input_error ();
650
651 /* Check for a sign. */
652 if (c == '-' || c == '+')
653 {
654 negative = c == '-';
655 if (inchar () == EOF)
656 /* EOF is only an input error before we read any chars. */
657 conv_error ();
658 if (width > 0)
659 --width;
660 }
661 else
662 negative = 0;
663
664 got_dot = got_e = 0;
665 do
666 {
667 if (isdigit (c))
668 ADDW (c);
669 else if (got_e && wp[wpsize - 1] == 'e'
670 && (c == '-' || c == '+'))
671 ADDW (c);
672 else if (wpsize > 0 && !got_e && tolower (c) == 'e')
673 {
674 ADDW ('e');
675 got_e = got_dot = 1;
676 }
677 else if (c == decimal && !got_dot)
678 {
679 ADDW (c);
680 got_dot = 1;
681 }
682 else if ((flags & GROUP) && c == thousands && !got_dot)
683 ADDW (c);
684 else
685 break;
686 if (width > 0)
687 --width;
688 }
689 while (inchar () != EOF && width != 0);
690
691 if (wpsize == 0)
692 conv_error ();
693
694 /* Convert the number. */
695 ADDW ('\0');
696 if (flags & LONGDBL)
697 {
698 long double d = __strtold_internal (wp, &tw, flags & GROUP);
699 if (!(flags & SUPPRESS) && tw != wp)
700 *ARG (long double *) = negative ? -d : d;
701 }
702 else if (flags & LONG)
703 {
704 double d = __strtod_internal (wp, &tw, flags & GROUP);
705 if (!(flags & SUPPRESS) && tw != wp)
706 *ARG (double *) = negative ? -d : d;
707 }
708 else
709 {
710 float d = __strtof_internal (wp, &tw, flags & GROUP);
711 if (!(flags & SUPPRESS) && tw != wp)
712 *ARG (float *) = negative ? -d : d;
713 }
714
715 if (tw == wp)
716 conv_error ();
717
718 if (!(flags & SUPPRESS))
719 ++done;
720 break;
721
722 case '[': /* Character class. */
723 STRING_ARG;
724
725 if (c == EOF)
726 input_error();
727
728 if (*f == '^')
729 {
730 ++f;
731 not_in = 1;
732 }
733 else
734 not_in = 0;
735
736 /* Fill WP with byte flags indexed by character.
737 We will use this flag map for matching input characters. */
738 if (wpmax < UCHAR_MAX)
739 {
740 wpmax = UCHAR_MAX;
741 wp = (char *) alloca (wpmax);
742 }
743 memset (wp, 0, UCHAR_MAX);
744
745 fc = *f;
746 if (fc == ']' || fc == '-')
747 {
748 /* If ] or - appears before any char in the set, it is not
749 the terminator or separator, but the first char in the
750 set. */
751 wp[fc] = 1;
752 ++f;
753 }
754
755 while ((fc = *f++) != '\0' && fc != ']')
756 {
757 if (fc == '-' && *f != '\0' && *f != ']' &&
758 (unsigned char) f[-2] <= (unsigned char) *f)
759 {
760 /* Add all characters from the one before the '-'
761 up to (but not including) the next format char. */
762 for (fc = f[-2]; fc < *f; ++fc)
763 wp[fc] = 1;
764 }
765 else
766 /* Add the character to the flag map. */
767 wp[fc] = 1;
768 }
769 if (fc == '\0')
770 conv_error();
771
772 num.ul = read_in;
773 do
774 {
775 if (wp[c] == not_in)
776 break;
777 STRING_ADD_CHAR (c);
778 if (width > 0)
779 --width;
780 }
781 while (inchar () != EOF && width != 0);
782 if (read_in == num.ul)
783 conv_error ();
784
785 if (!(flags & SUPPRESS))
786 {
787 *str = '\0';
788 ++done;
789 }
790 break;
791
792 case 'p': /* Generic pointer. */
793 base = 16;
794 /* A PTR must be the same size as a `long int'. */
795 flags &= ~(SHORT|LONGDBL);
796 flags |= LONG;
797 number_signed = 0;
798 goto number;
799 }
800 }
801
802 /* The last thing we saw int the format string was a white space.
803 Consume the last white spaces. */
804 if (skip_space)
805 while (isspace (c))
806 (void) inchar ();
807
808 /* Unlock stream. */
809 funlockfile (s);
810
811 return ((void) (c == EOF || ungetc (c, s)), done);
812 }
813
814 #ifdef USE_IN_LIBIO
815 int
816 __vfscanf (FILE *s, const char *format, va_list argptr)
817 {
818 return _IO_vfscanf (s, format, argptr, NULL);
819 }
820 #endif
821
822 weak_alias (__vfscanf, vfscanf)
Unaltered CVS history