compiler/clib/__vcscan.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Function to scan a string like scanf().
   6 */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <stdarg.h>
  11 #ifndef AROS_NO_LIMITS_H
  12 #   include <limits.h>
  13 #else
  14 #   define ULONG_MAX    4294967295UL
  15 #endif
  16 #include <ctype.h>
  17 #include <math.h>
  18
  19 #ifndef AROSC_ROM
  20 #define FULL_SPECIFIERS
  21 #endif
  22
  23 /* some macros to cut this short
  24  * NEXT(c);         read next character
  25  * PREV(c);         ungetc a character
  26  * VAL(a)           leads to 1 if a is true and valid
  27  */
  28 #define NEXT(c) ((c)=(*get_char)(data),size++,incount++)
  29 #define PREV(c) do{if((c)!=EOF)(*unget_char)((c),data);size--;incount--;}while(0)
  30 #define VAL(a)    ((a)&&size<=width)
  31
  32 extern unsigned char *__decimalpoint;
  33
  34 #ifdef FULL_SPECIFIERS
  35 const static unsigned char undef[3][sizeof(double)]= /* Undefined numeric values, IEEE */
  36 {
  37     { 0x7f,0xf0,0x00,0x00,0x00,0x00,0x00,0x00 }, /* +inf */
  38     { 0xff,0xf0,0x00,0x00,0x00,0x00,0x00,0x00 }, /* -inf */
  39     { 0x7f,0xf1,0x00,0x00,0x00,0x00,0x00,0x00 }  /* NaN */
  40 };
  41 #endif
  42
  43
  44 /*****************************************************************************
  45
  46         NAME */
  47
  48     int __vcscan (
  49
  50 /*    SYNOPSIS */
  51     void         * data,
  52     int        (* get_char)(void *),
  53     int        (* unget_char)(int,void *),
  54     const char * format,
  55     va_list            args)
  56
  57 /*  FUNCTION
  58         Scan an input stream as specified in format. The result of
  59         the scan will be placed in args.
  60
  61     INPUTS
  62         data - This is passed to the usercallback getc and ungetc
  63         get_char - This function gets called when the routine wants to
  64             read the next character. It whould return EOF when
  65             no more characters are available.
  66         unget_char - This function gets called when the routine wants to
  67             put a read character back into the stream. The next
  68             call to get_char() should return this character. It is possible
  69             that this function is called more than once before the
  70             next get_char().
  71         format - A scanf() format string.
  72         args - A list of arguments in which the result of the scan should
  73             be placed.
  74
  75     RESULT
  76         The number of arguments converted.
  77
  78     NOTES
  79
  80     EXAMPLE
  81
  82     BUGS
  83
  84     SEE ALSO
  85
  86     INTERNALS
  87
  88 ******************************************************************************/
  89 {
  90     size_t blocks=0,incount=0;
  91     int c=0;
  92
  93     while(*format)
  94     {
  95         size_t size=0;
  96
  97         if(*format=='%')
  98         {
  99             size_t width=ULONG_MAX;
 100             char type,subtype='i',ignore=0;
 101             const unsigned char *ptr=format+1;
 102             size_t i;
 103
 104             if(isdigit(*ptr))
 105             {
 106                 width=0;
 107                 while(isdigit(*ptr))
 108                     width=width*10+(*ptr++-'0');
 109             }
 110
 111             while(*ptr=='h'||*ptr=='l'||*ptr=='L'||*ptr=='*')
 112             {
 113                 if(*ptr=='*')
 114                     ignore=1;
 115                 else
 116                     subtype=*ptr;
 117                 ptr++;
 118             }
 119
 120             type=*ptr++;
 121
 122             if(type&&type!='%'&&type!='c'&&type!='n'&&type!='[')
 123             {
 124                 do /* ignore leading whitespace characters */
 125                 NEXT(c);
 126                 while(isspace(c));
 127                 size=1;
 128             } /* The first non-whitespace character is already read */
 129
 130             switch(type)
 131             {
 132             case 'c':
 133             {
 134                 unsigned char *bp;
 135
 136                 if(width==ULONG_MAX) /* Default */
 137                     width=1;
 138
 139                 if(!ignore)
 140                     bp=va_arg(args,char *);
 141                 else
 142                     bp=NULL; /* Just to get the compiler happy */
 143
 144                 NEXT(c); /* 'c' did not skip whitespace */
 145                 while(VAL(c!=EOF))
 146                 {
 147                     if(!ignore)
 148                         *bp++=c;
 149                     NEXT(c);
 150                 }
 151                 PREV(c);
 152
 153                 if(!ignore&&size)
 154                     blocks++;
 155                 break;
 156             }
 157             case '[':
 158             {
 159                 unsigned char *bp;
 160                 unsigned char tab[32],a,b;
 161                 char circflag=0;
 162
 163                 if(*ptr=='^')
 164                 {
 165                     circflag=1;
 166                     ptr++;
 167                 }
 168                 for(i=0;i<sizeof(tab);i++)
 169                     tab[i]=circflag?255:0;
 170
 171                 for(;;)
 172                 {
 173                     if(!*ptr)
 174                         break;
 175                     a=b=*ptr++;
 176                     if(*ptr=='-'&&ptr[1]&&ptr[1]!=']')
 177                     {
 178                         ptr++;
 179                         b=*ptr++;
 180                     }
 181                     for(i=a;i<=b;i++)
 182                         if(circflag)
 183                             tab[i/8]&=~(1<<(i&7));
 184                         else
 185                             tab[i/8]|=1<<(i&7);
 186                     if(*ptr==']')
 187                     {
 188                         ptr++;
 189                         break;
 190                     }
 191                 }
 192
 193                 if(!ignore)
 194                     bp=va_arg(args,char *);
 195                 else
 196                     bp=NULL; /* Just to get the compiler happy */
 197
 198                 NEXT(c);
 199                 while(VAL(c!=EOF&&tab[c/8]&(1<<(c&7))))
 200                 {
 201                     if(!ignore)
 202                         *bp++=c;
 203                     NEXT(c);
 204                 }
 205                 PREV(c);
 206
 207                 if(!ignore&&size)
 208                 {
 209                     *bp++='\0';
 210                     blocks++;
 211                 }
 212                 break;
 213             }
 214             case 's':
 215             {
 216                 unsigned char *bp;
 217
 218                 if(!ignore)
 219                     bp=va_arg(args,char *);
 220                 else
 221                     bp=NULL; /* Just to get the compiler happy */
 222
 223                 while(VAL(c!=EOF&&!isspace(c)))
 224                 {
 225                     if(!ignore)
 226                         *bp++=c;
 227                     NEXT(c);
 228                 }
 229                 PREV(c);
 230
 231                 if(!ignore&&size)
 232                 {
 233                     *bp++='\0';
 234                     blocks++;
 235                 }
 236                 break;
 237             }
 238 #ifdef FULL_SPECIFIERS
 239             case 'e':
 240             case 'f':
 241             case 'g':
 242             {
 243                 double v;
 244                 int ex=0;
 245                 int min=0,mine=0; /* This is a workaround for gcc 2.3.3: should be char */
 246
 247                 do /* This is there just to be able to break out */
 248                 {
 249                     if(VAL(c=='-'||c=='+'))
 250                     {
 251                         min=c;
 252                         NEXT(c);
 253                     }
 254
 255                     if(VAL(tolower(c)=='i')) /* +- inf */
 256                     {
 257                         int d;
 258                         NEXT(d);
 259                         if(VAL(tolower(d)=='n'))
 260                         {
 261                             int e;
 262                             NEXT(e);
 263                             if(VAL(tolower(e)=='f'))
 264                             {
 265                                 v=*(double *)&undef[min=='-'];
 266                                 break;
 267                             } /* break out */
 268                             PREV(e);
 269                         }
 270                         PREV(d);
 271                     }
 272                     else if(VAL(toupper(c)=='N')) /* NaN */
 273                     {
 274                         int d;
 275                         NEXT(d);
 276                         if(VAL(tolower(d)=='a'))
 277                         {
 278                             int e;
 279                             NEXT(e);
 280                             if(VAL(toupper(e)=='N'))
 281                             {
 282                                 v=*(double *)&undef[2];
 283                                 break;
 284                             }
 285                             PREV(e);
 286                         }
 287                         PREV(d);
 288                     }
 289
 290                     v=0.0;
 291                     while(VAL(isdigit(c)))
 292                     {
 293                         v=v*10.0+(c-'0');
 294                         NEXT(c);
 295                     }
 296
 297                     if(VAL(c==__decimalpoint[0]))
 298                     {
 299                         double dp=0.1;
 300                         NEXT(c);
 301                         while(VAL(isdigit(c)))
 302                         {
 303                             v=v+dp*(c-'0');
 304                             dp=dp/10.0;
 305                             NEXT(c);
 306                         }
 307                         if(size==2+(min!=0)) /* No number read till now -> malformatted */
 308                         {
 309                             PREV(c);
 310                             c=__decimalpoint[0];
 311                         }
 312                     }
 313
 314                     if(min&&size==2) /* No number read till now -> malformatted */
 315                     {
 316                         PREV(c);
 317                         c=min;
 318                     }
 319                     if(size==1) {
 320                         PREV(c);
 321                         break;
 322                     }
 323
 324                     if(VAL(tolower(c)=='e'))
 325                     {
 326                         int d;
 327                         NEXT(d);
 328                         if(VAL(d=='-'||d=='+'))
 329                         {
 330                             mine=d;
 331                             NEXT(d);
 332                         }
 333
 334                         if(VAL(isdigit(d)))
 335                         {
 336                             do
 337                             {
 338                                 ex=ex*10+(d-'0');
 339                                 NEXT(d);
 340                             }while(VAL(isdigit(d)&&ex<100));
 341                             c=d;
 342                         }
 343                         else
 344                         {
 345                             PREV(d);
 346                             if(mine)
 347                                 PREV(mine);
 348                         }
 349                     }
 350                     PREV(c);
 351
 352                     if(mine=='-')
 353                         v=v/pow(10.0,ex);
 354                     else
 355                         v=v*pow(10.0,ex);
 356
 357                     if(min=='-')
 358                         v=-v;
 359
 360                 }while(0);
 361
 362                 if(!ignore&&size)
 363                 {
 364                     switch(subtype)
 365                     {
 366                     case 'l':
 367                     case 'L':
 368                         *va_arg(args,double *)=v;
 369                         break;
 370                     case 'i':
 371                         *va_arg(args,float *)=v;
 372                         break;
 373                     }
 374                     blocks++;
 375                 }
 376                 break;
 377             }
 378 #endif
 379             case '%':
 380                 NEXT(c);
 381                 if(c!='%')
 382                     PREV(c); /* unget non-'%' character */
 383                 break;
 384             case 'n':
 385                 if(!ignore)
 386                     *va_arg(args,int *)=incount;
 387                 size=1; /* fake a valid argument */
 388                 break;
 389             default:
 390             {
 391                 unsigned long v=0;
 392                 int base;
 393                 int min=0;
 394
 395                 if(!type)
 396                     ptr--; /* unparse NUL character */
 397
 398                 if(type=='p')
 399                 {
 400                     subtype='l'; /* This is the same as %lx */
 401                     type='x';
 402                 }
 403
 404                 if(VAL((c=='-'&&type!='u')||c=='+'))
 405                 {
 406                     min=c;
 407                     NEXT(c);
 408                 }
 409
 410                 if(type=='i') /* which one to use ? */
 411                 {
 412                     if(VAL(c=='0')) /* Could be octal or sedecimal */
 413                     {
 414                         int d;
 415                         NEXT(d); /* Get a look at next character */
 416                         if(VAL(tolower(d)=='x'))
 417                         {
 418                             int e;
 419                             NEXT(e); /* And the next */
 420                             if(VAL(isxdigit(c)))
 421                                 type='x'; /* Is a valid x number with '0x?' */
 422                             PREV(e);
 423                         }
 424                         else
 425                             type='o';
 426                         PREV(d);
 427                     }
 428                     /*  deadwood: Below code is wrong and left for reference.
 429                         Algoritm cannot assume that string starting with A-F is
 430                         a hexadecimal integer. There must be '0x' sequence -
 431                         validated via test/clib/sscanf.c */
 432                     //else
 433                     //    if(VAL(!isdigit(c)&&isxdigit(c)))
 434                     //        type='x'; /* Is a valid x number without '0x' */
 435                 }
 436
 437                 while(type=='x'&&VAL(c=='0')) /* sedecimal */
 438                 {
 439                     int d;
 440                     NEXT(d);
 441                     if(VAL(tolower(d)=='x'))
 442                     {
 443                         int e;
 444                         NEXT(e);
 445                         if(VAL(isxdigit(e)))
 446                         {
 447                             c=e;
 448                             break;
 449                         } /* Used while just to do this ;-) */
 450                         PREV(e);
 451                     }
 452                     PREV(d);
 453                     break; /* Need no loop */
 454                 }
 455
 456                 base=type=='x'||type=='X'?16:(type=='o'?8:10);
 457                 while(VAL(isxdigit(c)&&(base!=10||isdigit(c))&&(base!=8||c<='7')))
 458                 {
 459                     v=v*base+(isdigit(c)?c-'0':0)+(isupper(c)?c-'A'+10:0)+(islower(c)?c-'a'+10:0);
 460                     NEXT(c);
 461                 }
 462
 463                 if(min&&size==2) /* If there is no valid character after sign, unget last */
 464                 {
 465                     PREV(c);
 466                     c=min;
 467                 }
 468
 469                 PREV(c);
 470
 471                 if(ignore||!size)
 472                     break;
 473
 474                 if(type=='u')
 475                 {
 476                     switch(subtype)
 477                     {
 478                         case 'l':
 479                         case 'L':
 480                             *va_arg(args,unsigned long *)=v;
 481                             break;
 482                         case 'i':
 483                             *va_arg(args,unsigned int *)=v;
 484                             break;
 485                         case 'h':
 486                             *va_arg(args,unsigned short *)=v;
 487                             break;
 488                     }
 489                 }
 490                 else
 491                 {
 492                     signed long v2;
 493                     if(min=='-')
 494                         v2=-v;
 495                     else
 496                         v2=v;
 497                     switch(subtype)
 498                     {
 499                         case 'l':
 500                         case 'L':
 501                             *va_arg(args,signed long *)=v2;
 502                             break;
 503                         case 'i':
 504                             *va_arg(args,signed int *)=v2;
 505                             break;
 506                         case 'h':
 507                             *va_arg(args,signed short *)=v2;
 508                             break;
 509                     }
 510                 }
 511                 blocks++;
 512                 break;
 513             }
 514             }
 515             format=ptr;
 516         }
 517         else
 518         {
 519             if(isspace(*format))
 520             {
 521                 do
 522                 NEXT(c);
 523                 while(isspace(c));
 524                 PREV(c);
 525                 size=1;
 526             }
 527             else
 528             {
 529                 NEXT(c);
 530                 if(c!=*format)
 531                 PREV(c);
 532             }
 533
 534             format++;
 535         }
 536         if(!size)
 537             break;
 538     }
 539
 540     if(c==EOF&&!blocks)
 541         return c;
 542     else
 543         return blocks;
 544 }