home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / libg++-2.6.2.lha / libg++-2.6.2 / libio / iovfscanf.c < prev    next >
C/C++ Source or Header  |  1994-10-13  |  19KB  |  785 lines
  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. #define    WIDTH        0x40    /* width */
  78.  
  79. /*
  80.  * The following are used in numeric conversions only:
  81.  * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
  82.  * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
  83.  */
  84. #define    SIGNOK        0x40    /* +/- is (still) legal */
  85. #define    NDIGITS        0x80    /* no digits detected */
  86.  
  87. #define    DPTOK        0x100    /* (float) decimal point is still legal */
  88. #define    EXPOK        0x200    /* (float) exponent (e+3, etc) still legal */
  89.  
  90. #define    PFXOK        0x100    /* 0x prefix is (still) legal */
  91. #define    NZDIGITS    0x200    /* no zero digits detected */
  92.  
  93. /*
  94.  * Conversion types.
  95.  */
  96. #define    CT_CHAR        0    /* %c conversion */
  97. #define    CT_CCL        1    /* %[...] conversion */
  98. #define    CT_STRING    2    /* %s conversion */
  99. #define    CT_INT        3    /* integer, i.e., strtol or strtoul */
  100. #define    CT_FLOAT    4    /* floating, i.e., strtod */
  101.  
  102. #define u_char unsigned char
  103. #define u_long unsigned long
  104.  
  105. extern u_long strtoul __P((const char*, char**, int));
  106. extern long strtol __P((const char*, char**, int));
  107. static const u_char *__sccl __P((char *tab, const u_char *fmt));
  108. #ifndef _IO_USE_DTOA
  109. extern double atof();
  110. #endif
  111.  
  112. /* If errp != NULL, *errp|=1 if we see a premature EOF;
  113.    *errp|=2 if we an invalid character. */
  114.  
  115. int
  116. _IO_vfscanf(fp, fmt0, ap, errp)
  117.      register _IO_FILE *fp;
  118.      char const *fmt0;
  119.      _IO_va_list ap;
  120.      int *errp;
  121. {
  122.     register const u_char *fmt = (const u_char *)fmt0;
  123.     register int c;        /* character from format, or conversion */
  124.     register _IO_ssize_t width;    /* field width, or 0 */
  125.     register char *p;    /* points into all kinds of strings */
  126.     register int n;        /* handy integer */
  127.     register int flags = 0;    /* flags as defined above */
  128.     register char *p0;    /* saves original value of p when necessary */
  129.     int nassigned;        /* number of fields assigned */
  130.     int nread;        /* number of characters consumed from fp */
  131.     /* Assignments to base and ccfn are just to suppress warnings from gcc.*/
  132.     int base = 0;        /* base argument to strtol/strtoul */
  133.     typedef u_long (*strtoulfn) __P((const char*, char**, int));
  134.     strtoulfn ccfn = 0;
  135.     /* conversion function (strtol/strtoul) */
  136.     char ccltab[256];    /* character class table for %[...] */
  137.     char buf[BUF];        /* buffer for numeric conversions */
  138.     int seen_eof = 0;
  139.  
  140.     /* `basefix' is used to avoid `if' tests in the integer scanner */
  141.     static short basefix[17] =
  142.         { 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
  143.  
  144.     nassigned = 0;
  145.     nread = 0;
  146.     for (;;) {
  147.         c = *fmt++;
  148.         if (c == 0)
  149.             goto done;
  150.         if (isspace(c)) {
  151.             for (;;) {
  152.                     c = _IO_getc(fp);
  153.                 if (c == EOF) {
  154.                   seen_eof++;
  155.                   break;
  156.                 }
  157.                 if (!isspace(c)) {
  158.                     _IO_ungetc (c, fp);
  159.                     break;
  160.                 }
  161.                 nread++;
  162.             }
  163.             continue;
  164.         }
  165.         if (c != '%')
  166.             goto literal;
  167.         width = 0;
  168.         flags = 0;
  169.         /*
  170.          * switch on the format.  continue if done;
  171.          * break once format type is derived.
  172.          */
  173. again:        c = *fmt++;
  174.         switch (c) {
  175.         case '%':
  176. literal:
  177.                 n = _IO_getc(fp);
  178.             if (n == EOF)
  179.                 goto eof_failure;
  180.             if (n != c) {
  181.                 _IO_ungetc (n, fp);
  182.                 goto match_failure;
  183.             }
  184.             nread++;
  185.             continue;
  186.  
  187.         case '*':
  188.             if (flags) goto control_failure;
  189.             flags = SUPPRESS;
  190.             goto again;
  191.         case 'l':
  192.             if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
  193.             flags |= LONG;
  194.             goto again;
  195.         case 'L':
  196.             if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
  197.             flags |= LONGDBL;
  198.             goto again;
  199.         case 'h':
  200.             if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
  201.             flags |= SHORT;
  202.             goto again;
  203.  
  204.         case '0': case '1': case '2': case '3': case '4':
  205.         case '5': case '6': case '7': case '8': case '9':
  206.             if (flags & ~(SUPPRESS | WIDTH)) goto control_failure;
  207.             flags |= WIDTH;
  208.             width = width * 10 + c - '0';
  209.             goto again;
  210.  
  211.         /*
  212.          * Conversions.
  213.          * Those marked `compat' are for 4.[123]BSD compatibility.
  214.          *
  215.          * (According to ANSI, E and X formats are supposed
  216.          * to the same as e and x.  Sorry about that.)
  217.          */
  218.         case 'D':    /* compat */
  219.             flags |= LONG;
  220.             /* FALLTHROUGH */
  221.         case 'd':
  222.             c = CT_INT;
  223.             ccfn = (strtoulfn)strtol;
  224.             base = 10;
  225.             break;
  226.  
  227.         case 'i':
  228.             c = CT_INT;
  229.             ccfn = (strtoulfn)strtol;
  230.             base = 0;
  231.             break;
  232.  
  233.         case 'O':    /* compat */
  234.             flags |= LONG;
  235.             /* FALLTHROUGH */
  236.         case 'o':
  237.             c = CT_INT;
  238.             ccfn = strtoul;
  239.             base = 8;
  240.             break;
  241.  
  242.         case 'u':
  243.             c = CT_INT;
  244.             ccfn = strtoul;
  245.             base = 10;
  246.             break;
  247.  
  248.         case 'X':
  249.         case 'x':
  250.             flags |= PFXOK;    /* enable 0x prefixing */
  251.             c = CT_INT;
  252.             ccfn = strtoul;
  253.             base = 16;
  254.             break;
  255.  
  256. #ifdef FLOATING_POINT
  257.         case 'E': case 'F':
  258.         case 'e': case 'f': case 'g':
  259.             c = CT_FLOAT;
  260.             break;
  261. #endif
  262.  
  263.         case 's':
  264.             c = CT_STRING;
  265.             break;
  266.  
  267.         case '[':
  268.             fmt = __sccl(ccltab, fmt);
  269.             flags |= NOSKIP;
  270.             c = CT_CCL;
  271.             break;
  272.  
  273.         case 'c':
  274.             flags |= NOSKIP;
  275.             c = CT_CHAR;
  276.             break;
  277.  
  278.         case 'p':    /* pointer format is like hex */
  279.             flags |= POINTER | PFXOK;
  280.             c = CT_INT;
  281.             ccfn = strtoul;
  282.             base = 16;
  283.             break;
  284.  
  285.         case 'n':
  286.             if (flags & SUPPRESS)    /* ??? */
  287.                 continue;
  288.             if (flags & SHORT)
  289.                 *va_arg(ap, short *) = nread;
  290.             else if (flags & LONG)
  291.                 *va_arg(ap, long *) = nread;
  292.             else
  293.                 *va_arg(ap, int *) = nread;
  294.             continue;
  295.  
  296.         /*
  297.          * Disgusting backwards compatibility hacks.    XXX
  298.          */
  299.         case '\0':    /* compat */
  300.                 nassigned = EOF;
  301.             goto done;
  302.  
  303.         default:    /* compat */
  304.             if (isupper(c))
  305.                 flags |= LONG;
  306.             c = CT_INT;
  307.             ccfn = (strtoulfn)strtol;
  308.             base = 10;
  309.             break;
  310.         }
  311.  
  312.         /*
  313.          * We have a