gcc/c-lex.c

   1 /* Lexical analyzer for C and Objective C.
   2    Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <stdio.h>
  22 #include <errno.h>
  23 #include <setjmp.h>
  24
  25 #include "config.h"
  26 #include "rtl.h"
  27 #include "tree.h"
  28 #include "input.h"
  29 #include "c-lex.h"
  30 #include "c-tree.h"
  31 #include "flags.h"
  32 #include "c-parse.h"
  33
  34 #ifdef MULTIBYTE_CHARS
  35 #include <stdlib.h>
  36 #include <locale.h>
  37 #endif
  38
  39 #ifndef errno
  40 extern int errno;
  41 #endif
  42
  43 /* The elements of `ridpointers' are identifier nodes
  44    for the reserved type names and storage classes.
  45    It is indexed by a RID_... value.  */
  46 tree ridpointers[(int) RID_MAX];
  47
  48 /* Cause the `yydebug' variable to be defined.  */
  49 #define YYDEBUG 1
  50
  51 /* the declaration found for the last IDENTIFIER token read in.
  52    yylex must look this up to detect typedefs, which get token type TYPENAME,
  53    so it is left around in case the identifier is not a typedef but is
  54    used in a context which makes it a reference to a variable.  */
  55 tree lastiddecl;
  56
  57 /* Nonzero enables objc features.  */
  58
  59 int doing_objc_thang;
  60
  61 extern tree lookup_interface ();
  62
  63 extern int yydebug;
  64
  65 /* File used for outputting assembler code.  */
  66 extern FILE *asm_out_file;
  67
  68 #ifndef WCHAR_TYPE_SIZE
  69 #ifdef INT_TYPE_SIZE
  70 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  71 #else
  72 #define WCHAR_TYPE_SIZE BITS_PER_WORD
  73 #endif
  74 #endif
  75
  76 /* Number of bytes in a wide character.  */
  77 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
  78
  79 static int maxtoken;            /* Current nominal length of token buffer.  */
  80 char *token_buffer;     /* Pointer to token buffer.
  81                            Actual allocated length is maxtoken + 2.
  82                            This is not static because objc-parse.y uses it.  */
  83
  84 /* Nonzero if end-of-file has been seen on input.  */
  85 static int end_of_file;
  86
  87 /* Buffered-back input character; faster than using ungetc.  */
  88 static int nextchar = -1;
  89
  90 int check_newline ();
  91
  92 /* Nonzero tells yylex to ignore \ in string constants.  */
  93 static int ignore_escape_flag = 0;
  94 \f
  95 /* C code produced by gperf version 2.5 (GNU C++ version) */
  96 /* Command-line: gperf -p -j1 -i 1 -g -o -t -N is_reserved_word -k1,3,$ c-parse.gperf  */
  97 struct resword { char *name; short token; enum rid rid; };
  98
  99 #define TOTAL_KEYWORDS 53
 100 #define MIN_WORD_LENGTH 2
 101 #define MAX_WORD_LENGTH 13
 102 #define MIN_HASH_VALUE 7
 103 #define MAX_HASH_VALUE 102
 104 /* maximum key range = 96, duplicates = 0 */
 105
 106 #ifdef __GNUC__
 107 __inline
 108 #endif
 109 static unsigned int
 110 hash (str, len)
 111      register char *str;
 112      register int unsigned len;
 113 {
 114   static unsigned char asso_values[] =
 115     {
 116      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 117      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 118      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 119      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 120      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 121      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 122      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 123      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 124      103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
 125      103, 103, 103, 103, 103,   1, 103,   2,   1,  24,
 126        1,   5,  19,  39,  16,  13, 103,   1,  25,   1,
 127       34,  34,  24, 103,  13,  12,   1,  45,  24,   7,
 128      103, 103,   2, 103, 103, 103, 103, 103,
 129     };
 130   register int hval = len;
 131
 132   switch (hval)
 133     {
 134       default:
 135       case 3:
 136         hval += asso_values[str[2]];
 137       case 2:
 138       case 1:
 139         hval += asso_values[str[0]];
 140     }
 141   return hval + asso_values[str[len - 1]];
 142 }
 143
 144 #ifdef __GNUC__
 145 __inline
 146 #endif
 147 struct resword *
 148 is_reserved_word (str, len)
 149      register char *str;
 150      register unsigned int len;
 151 {
 152   static struct resword wordlist[] =
 153     {
 154       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
 155       {"asm",  ASM_KEYWORD, NORID},
 156       {"",},
 157       {"__asm",  ASM_KEYWORD, NORID},
 158       {"",},
 159       {"__asm__",  ASM_KEYWORD, NORID},
 160       {"break",  BREAK, NORID},
 161       {"__typeof__",  TYPEOF, NORID},
 162       {"",},
 163       {"__alignof__",  ALIGNOF, NORID},
 164       {"",},
 165       {"__attribute__",  ATTRIBUTE, NORID},
 166       {"int",  TYPESPEC, RID_INT},
 167       {"__attribute",  ATTRIBUTE, NORID},
 168       {"__extension__",  EXTENSION, NORID},
 169       {"",},
 170       {"__signed",  TYPESPEC, RID_SIGNED},
 171       {"",},
 172       {"__signed__",  TYPESPEC, RID_SIGNED},
 173       {"__inline__",  SCSPEC, RID_INLINE},
 174       {"else",  ELSE, NORID},
 175       {"__inline",  SCSPEC, RID_INLINE},
 176       {"default",  DEFAULT, NORID},
 177       {"__typeof",  TYPEOF, NORID},
 178       {"while",  WHILE, NORID},
 179       {"__alignof",  ALIGNOF, NORID},
 180       {"struct",  STRUCT, NORID},
 181       {"__const",  TYPE_QUAL, RID_CONST},
 182       {"if",  IF, NORID},
 183       {"__const__",  TYPE_QUAL, RID_CONST},
 184       {"__label__",  LABEL, NORID},
 185       {"do",  DO, NORID},
 186       {"__volatile__",  TYPE_QUAL, RID_VOLATILE},
 187       {"sizeof",  SIZEOF, NORID},
 188       {"__volatile",  TYPE_QUAL, RID_VOLATILE},
 189       {"auto",  SCSPEC, RID_AUTO},
 190       {"void",  TYPESPEC, RID_VOID},
 191       {"char",  TYPESPEC, RID_CHAR},
 192       {"static",  SCSPEC, RID_STATIC},
 193       {"case",  CASE, NORID},
 194       {"extern",  SCSPEC, RID_EXTERN},
 195       {"switch",  SWITCH, NORID},
 196       {"for",  FOR, NORID},
 197       {"inline",  SCSPEC, RID_INLINE},
 198       {"typeof",  TYPEOF, NORID},
 199       {"typedef",  SCSPEC, RID_TYPEDEF},
 200       {"short",  TYPESPEC, RID_SHORT},
 201       {"",},
 202       {"return",  RETURN, NORID},
 203       {"enum",  ENUM, NORID},
 204       {"",},
 205       {"double",  TYPESPEC, RID_DOUBLE},
 206       {"signed",  TYPESPEC, RID_SIGNED},
 207       {"float",  TYPESPEC, RID_FLOAT},
 208       {"",}, {"",},
 209       {"volatile",  TYPE_QUAL, RID_VOLATILE},
 210       {"",},
 211       {"const",  TYPE_QUAL, RID_CONST},
 212       {"",},
 213       {"unsigned",  TYPESPEC, RID_UNSIGNED},
 214       {"",}, {"",}, {"",}, {"",},
 215       {"continue",  CONTINUE, NORID},
 216       {"",},
 217       {"register",  SCSPEC, RID_REGISTER},
 218       {"",}, {"",}, {"",}, {"",},
 219       {"goto",  GOTO, NORID},
 220       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
 221       {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
 222
 223       {"union",  UNION, NORID},
 224       {"",}, {"",}, {"",}, {"",},
 225       {"long",  TYPESPEC, RID_LONG},
 226     };
 227
 228   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
 229     {
 230       register int key = hash (str, len);
 231
 232       if (key <= MAX_HASH_VALUE && key >= 0)
 233         {
 234           register char *s = wordlist[key].name;
 235
 236           if (*s == *str && !strcmp (str + 1, s + 1))
 237             return &wordlist[key];
 238         }
 239     }
 240   return 0;
 241 }
 242 \f
 243 /* Return something to represent absolute declarators containing a *.
 244    TARGET is the absolute declarator that the * contains.
 245    TYPE_QUALS is a list of modifiers such as const or volatile
 246    to apply to the pointer type, represented as identifiers.
 247
 248    We return an INDIRECT_REF whose "contents" are TARGET
 249    and whose type is the modifier list.  */
 250
 251 tree
 252 make_pointer_declarator (type_quals, target)
 253      tree type_quals, target;
 254 {
 255   return build1 (INDIRECT_REF, type_quals, target);
 256 }
 257 \f
 258 void
 259 init_lex ()
 260 {
 261   /* Make identifier nodes long enough for the language-specific slots.  */
 262   set_identifier_size (sizeof (struct lang_identifier));
 263
 264   /* Start it at 0, because check_newline is called at the very beginning
 265      and will increment it to 1.  */
 266   lineno = 0;
 267
 268 #ifdef MULTIBYTE_CHARS
 269   /* Change to the native locale for multibyte conversions.  */
 270   setlocale (LC_CTYPE, "");
 271 #endif
 272
 273   maxtoken = 40;
 274   token_buffer = (char *) xmalloc (maxtoken + 2);
 275
 276   ridpointers[(int) RID_INT] = get_identifier ("int");
 277   ridpointers[(int) RID_CHAR] = get_identifier ("char");
 278   ridpointers[(int) RID_VOID] = get_identifier ("void");
 279   ridpointers[(int) RID_FLOAT] = get_identifier ("float");
 280   ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
 281   ridpointers[(int) RID_SHORT] = get_identifier ("short");
 282   ridpointers[(int) RID_LONG] = get_identifier ("long");
 283   ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
 284   ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
 285   ridpointers[(int) RID_INLINE] = get_identifier ("inline");
 286   ridpointers[(int) RID_CONST] = get_identifier ("const");
 287   ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
 288   ridpointers[(int) RID_AUTO] = get_identifier ("auto");
 289   ridpointers[(int) RID_STATIC] = get_identifier ("static");
 290   ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
 291   ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
 292   ridpointers[(int) RID_REGISTER] = get_identifier ("register");
 293
 294   /* Some options inhibit certain reserved words.
 295      Clear those words out of the hash table so they won't be recognized.  */
 296 #define UNSET_RESERVED_WORD(STRING) \
 297   do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
 298        if (s) s->name = ""; } while (0)
 299
 300   if (flag_traditional)
 301     {
 302       UNSET_RESERVED_WORD ("const");
 303       UNSET_RESERVED_WORD ("volatile");
 304       UNSET_RESERVED_WORD ("typeof");
 305       UNSET_RESERVED_WORD ("signed");
 306       UNSET_RESERVED_WORD ("inline");
 307     }
 308   if (flag_no_asm)
 309     {
 310       UNSET_RESERVED_WORD ("asm");
 311       UNSET_RESERVED_WORD ("typeof");
 312       UNSET_RESERVED_WORD ("inline");
 313     }
 314 }
 315
 316 void
 317 reinit_parse_for_function ()
 318 {
 319 }
 320 \f
 321 /* Function used when yydebug is set, to print a token in more detail.  */
 322
 323 void
 324 yyprint (file, yychar, yylval)
 325      FILE *file;
 326      int yychar;
 327      YYSTYPE yylval;
 328 {
 329   tree t;
 330   switch (yychar)
 331     {
 332     case IDENTIFIER:
 333     case TYPENAME:
 334       t = yylval.ttype;
 335       if (IDENTIFIER_POINTER (t))
 336         fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
 337       break;
 338
 339     case CONSTANT:
 340       t = yylval.ttype;
 341       if (TREE_CODE (t) == INTEGER_CST)
 342         fprintf (file,
 343 #if HOST_BITS_PER_WIDE_INT == 64
 344 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
 345                  " 0x%lx%016lx",
 346 #else
 347                  " 0x%x%016x",
 348 #endif
 349 #else
 350 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
 351                  " 0x%lx%08lx",
 352 #else
 353                  " 0x%x%08x",
 354 #endif
 355 #endif
 356                  TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
 357       break;
 358     }
 359 }
 360
 361 \f
 362 /* If C is not whitespace, return C.
 363    Otherwise skip whitespace and return first nonwhite char read.  */
 364
 365 static int
 366 skip_white_space (c)
 367      register int c;
 368 {
 369   static int newline_warning = 0;
 370
 371   for (;;)
 372     {
 373       switch (c)
 374         {
 375           /* We don't recognize comments here, because
 376              cpp output can include / and * consecutively as operators.
 377              Also, there's no need, since cpp removes all comments.  */
 378
 379         case '\n':
 380           c = check_newline ();
 381           break;
 382
 383         case ' ':
 384         case '\t':
 385         case '\f':
 386         case '\v':
 387         case '\b':
 388           c = getc (finput);
 389           break;
 390
 391         case '\r':
 392           /* ANSI C says the effects of a carriage return in a source file
 393              are undefined.  */
 394           if (pedantic && !newline_warning)
 395             {
 396               warning ("carriage return in source file");
 397               warning ("(we only warn about the first carriage return)");
 398               newline_warning = 1;
 399             }
 400           c = getc (finput);
 401           break;
 402
 403         case '\\':
 404           c = getc (finput);
 405           if (c == '\n')
 406             lineno++;
 407           else
 408             error ("stray '\\' in program");
 409           c = getc (finput);
 410           break;
 411
 412         default:
 413           return (c);
 414         }
 415     }
 416 }
 417
 418 /* Skips all of the white space at the current location in the input file.
 419    Must use and reset nextchar if it has the next character.  */
 420
 421 void
 422 position_after_white_space ()
 423 {
 424   register int c;
 425
 426   if (nextchar != -1)
 427     c = nextchar, nextchar = -1;
 428   else
 429     c = getc (finput);
 430
 431   ungetc (skip_white_space (c), finput);
 432 }
 433
 434 /* Make the token buffer longer, preserving the data in it.
 435    P should point to just beyond the last valid character in the old buffer.
 436    The value we return is a pointer to the new buffer
 437    at a place corresponding to P.  */
 438
 439 static char *
 440 extend_token_buffer (p)
 441      char *p;
 442 {
 443   int offset = p - token_buffer;
 444
 445   maxtoken = maxtoken * 2 + 10;
 446   token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
 447
 448   return token_buffer + offset;
 449 }
 450 \f
 451 /* At the beginning of a line, increment the line number
 452    and process any #-directive on this line.
 453    If the line is a #-directive, read the entire line and return a newline.
 454    Otherwise, return the line's first non-whitespace character.  */
 455
 456 int
 457 check_newline ()
 458 {
 459   register int c;
 460   register int token;
 461
 462   lineno++;
 463
 464   /* Read first nonwhite char on the line.  */
 465
 466   c = getc (finput);
 467   while (c == ' ' || c == '\t')
 468     c = getc (finput);
 469
 470   if (c != '#')
 471     {
 472       /* If not #, return it so caller will use it.  */
 473       return c;
 474     }
 475
 476   /* Read first nonwhite char after the `#'.  */
 477
 478   c = getc (finput);
 479   while (c == ' ' || c == '\t')
 480     c = getc (finput);
 481
 482   /* If a letter follows, then if the word here is `line', skip
 483      it and ignore it; otherwise, ignore the line, with an error
 484      if the word isn't `pragma', `ident', `define', or `undef'.  */
 485
 486   if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
 487     {
 488       if (c == 'p')
 489         {
 490           if (getc (finput) == 'r'
 491               && getc (finput) == 'a'
 492               && getc (finput) == 'g'
 493               && getc (finput) == 'm'
 494               && getc (finput) == 'a'
 495               && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
 496             {
 497 #ifdef HANDLE_SYSV_PRAGMA
 498               return handle_sysv_pragma (finput, c);
 499 #endif /* HANDLE_SYSV_PRAGMA */
 500 #ifdef HANDLE_PRAGMA
 501               HANDLE_PRAGMA (finput);
 502 #endif /* HANDLE_PRAGMA */
 503               goto skipline;
 504             }
 505         }
 506
 507       else if (c == 'd')
 508         {
 509           if (getc (finput) == 'e'
 510               && getc (finput) == 'f'
 511               && getc (finput) == 'i'
 512               && getc (finput) == 'n'
 513               && getc (finput) == 'e'
 514               && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
 515             {
 516 #ifdef DWARF_DEBUGGING_INFO
 517               if ((debug_info_level == DINFO_LEVEL_VERBOSE)
 518                   && (write_symbols == DWARF_DEBUG))
 519                 dwarfout_define (lineno, get_directive_line (finput));
 520 #endif /* DWARF_DEBUGGING_INFO */
 521               goto skipline;
 522             }
 523         }
 524       else if (c == 'u')
 525         {
 526           if (getc (finput) == 'n'
 527               && getc (finput) == 'd'
 528               && getc (finput) == 'e'
 529               && getc (finput) == 'f'
 530               && ((c = getc (finput)) == ' ' || c == '\t' || c == '\n'))
 531             {
 532 #ifdef DWARF_DEBUGGING_INFO
 533               if ((debug_info_level == DINFO_LEVEL_VERBOSE)
 534                   && (write_symbols == DWARF_DEBUG))
 535                 dwarfout_undef (lineno, get_directive_line (finput));
 536 #endif /* DWARF_DEBUGGING_INFO */
 537               goto skipline;
 538             }
 539         }
 540       else if (c == 'l')
 541         {
 542           if (getc (finput) == 'i'
 543               && getc (finput) == 'n'
 544               && getc (finput) == 'e'
 545               && ((c = getc (finput)) == ' ' || c == '\t'))
 546             goto linenum;
 547         }
 548       else if (c == 'i')
 549         {
 550           if (getc (finput) == 'd'
 551               && getc (finput) == 'e'
 552               && getc (finput) == 'n'
 553               && getc (finput) == 't'
 554               && ((c = getc (finput)) == ' ' || c == '\t'))
 555             {
 556               /* #ident.  The pedantic warning is now in cccp.c.  */
 557
 558               /* Here we have just seen `#ident '.
 559                  A string constant should follow.  */
 560
 561               while (c == ' ' || c == '\t')
 562                 c = getc (finput);
 563
 564               /* If no argument, ignore the line.  */
 565               if (c == '\n')
 566                 return c;
 567
 568               ungetc (c, finput);
 569               token = yylex ();
 570               if (token != STRING
 571                   || TREE_CODE (yylval.ttype) != STRING_CST)
 572                 {
 573                   error ("invalid #ident");
 574                   goto skipline;
 575                 }
 576
 577               if (!flag_no_ident)
 578                 {
 579 #ifdef ASM_OUTPUT_IDENT
 580                   ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype));
 581 #endif
 582                 }
 583
 584               /* Skip the rest of this line.  */
 585               goto skipline;
 586             }
 587         }
 588
 589       error ("undefined or invalid # directive");
 590       goto skipline;
 591     }
 592
 593 linenum:
 594   /* Here we have either `#line' or `# <nonletter>'.
 595      In either case, it should be a line number; a digit should follow.  */
 596
 597   while (c == ' ' || c == '\t')
 598     c = getc (finput);
 599
 600   /* If the # is the only nonwhite char on the line,
 601      just ignore it.  Check the new newline.  */
 602   if (c == '\n')
 603     return c;
 604
 605   /* Something follows the #; read a token.  */
 606
 607   ungetc (c, finput);
 608   token = yylex ();
 609
 610   if (token == CONSTANT
 611       && TREE_CODE (yylval.ttype) == INTEGER_CST)
 612     {
 613       int old_lineno = lineno;
 614       int used_up = 0;
 615       /* subtract one, because it is the following line that
 616          gets the specified number */
 617
 618       int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
 619
 620       /* Is this the last nonwhite stuff on the line?  */
 621       c = getc (finput);
 622       while (c == ' ' || c == '\t')
 623         c = getc (finput);
 624       if (c == '\n')
 625         {
 626           /* No more: store the line number and check following line.  */
 627           lineno = l;
 628           return c;
 629         }
 630       ungetc (c, finput);
 631
 632       /* More follows: it must be a string constant (filename).  */
 633
 634       /* Read the string constant, but don't treat \ as special.  */
 635       ignore_escape_flag = 1;
 636       token = yylex ();
 637       ignore_escape_flag = 0;
 638
 639       if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
 640         {
 641           error ("invalid #line");
 642           goto skipline;
 643         }
 644
 645       input_filename
 646         = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
 647       strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
 648       lineno = l;
 649
 650       /* Each change of file name
 651          reinitializes whether we are now in a system header.  */
 652       in_system_header = 0;
 653
 654       if (main_input_filename == 0)
 655         main_input_filename = input_filename;
 656
 657       /* Is this the last nonwhite stuff on the line?  */
 658       c = getc (finput);
 659       while (c == ' ' || c == '\t')
 660         c = getc (finput);
 661       if (c == '\n')
 662         return c;
 663       ungetc (c, finput);
 664
 665       token = yylex ();
 666       used_up = 0;
 667
 668       /* `1' after file name means entering new file.
 669          `2' after file name means just left a file.  */
 670
 671       if (token == CONSTANT
 672           && TREE_CODE (yylval.ttype) == INTEGER_CST)
 673         {
 674           if (TREE_INT_CST_LOW (yylval.ttype) == 1)
 675             {
 676               /* Pushing to a new file.  */
 677               struct file_stack *p
 678                 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
 679               input_file_stack->line = old_lineno;
 680               p->next = input_file_stack;
 681               p->name = input_filename;
 682               input_file_stack = p;
 683               input_file_stack_tick++;
 684 #ifdef DWARF_DEBUGGING_INFO
 685               if (debug_info_level == DINFO_LEVEL_VERBOSE
 686                   && write_symbols == DWARF_DEBUG)
 687                 dwarfout_start_new_source_file (input_filename);
 688 #endif /* DWARF_DEBUGGING_INFO */
 689
 690               used_up = 1;
 691             }
 692           else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
 693             {
 694               /* Popping out of a file.  */
 695               if (input_file_stack->next)
 696                 {
 697                   struct file_stack *p = input_file_stack;
 698                   input_file_stack = p->next;
 699                   free (p);
 700                   input_file_stack_tick++;
 701 #ifdef DWARF_DEBUGGING_INFO
 702                   if (debug_info_level == DINFO_LEVEL_VERBOSE
 703                       && write_symbols == DWARF_DEBUG)
 704                     dwarfout_resume_previous_source_file (input_file_stack->line);
 705 #endif /* DWARF_DEBUGGING_INFO */
 706                 }
 707               else
 708                 error ("#-lines for entering and leaving files don't match");
 709
 710               used_up = 1;
 711             }
 712         }
 713
 714       /* If we have handled a `1' or a `2',
 715          see if there is another number to read.  */
 716       if (used_up)
 717         {
 718           /* Is this the last nonwhite stuff on the line?  */
 719           c = getc (finput);
 720           while (c == ' ' || c == '\t')
 721             c = getc (finput);
 722           if (c == '\n')
 723             return c;
 724           ungetc (c, finput);
 725
 726           token = yylex ();
 727           used_up = 0;
 728         }
 729
 730       /* `3' after file name means this is a system header file.  */
 731
 732       if (token == CONSTANT
 733           && TREE_CODE (yylval.ttype) == INTEGER_CST
 734           && TREE_INT_CST_LOW (yylval.ttype) == 3)
 735         in_system_header = 1;
 736     }
 737   else
 738     error ("invalid #-line");
 739
 740   /* skip the rest of this line.  */
 741  skipline:
 742   if (c == '\n')
 743     return c;
 744   while ((c = getc (finput)) != EOF && c != '\n');
 745   return c;
 746 }
 747 \f
 748 #ifdef HANDLE_SYSV_PRAGMA
 749
 750 /* Handle a #pragma directive.  INPUT is the current input stream,
 751    and C is a character to reread.  Processes the entire input line
 752    and returns a character for the caller to reread: either \n or EOF.  */
 753
 754 /* This function has to be in this file, in order to get at
 755    the token types.  */
 756
 757 int
 758 handle_sysv_pragma (input, c)
 759      FILE *input;
 760      int c;
 761 {
 762   for (;;)
 763     {
 764       while (c == ' ' || c == '\t')
 765         c = getc (input);
 766       if (c == '\n' || c == EOF)
 767         {
 768           handle_pragma_token (0, 0);
 769           return c;
 770         }
 771       ungetc (c, input);
 772       switch (yylex ())
 773         {
 774         case IDENTIFIER:
 775         case TYPENAME:
 776         case STRING:
 777         case CONSTANT:
 778           handle_pragma_token (token_buffer, yylval.ttype);
 779           break;
 780         default:
 781           handle_pragma_token (token_buffer, 0);
 782         }
 783       if (nextchar >= 0)
 784         c = nextchar, nextchar = -1;
 785       else
 786         c = getc (input);
 787     }
 788 }
 789
 790 #endif /* HANDLE_SYSV_PRAGMA */
 791 \f
 792 #define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9'))
 793 #define isdigit(char) (char >= '0' && char <= '9')
 794 #define ENDFILE -1  /* token that represents end-of-file */
 795
 796 /* Read an escape sequence, returning its equivalent as a character,
 797    or store 1 in *ignore_ptr if it is backslash-newline.  */
 798
 799 static int
 800 readescape (ignore_ptr)
 801      int *ignore_ptr;
 802 {
 803   register int c = getc (finput);
 804   register int code;
 805   register unsigned count;
 806   unsigned firstdig;
 807   int nonnull;
 808
 809   switch (c)
 810     {
 811     case 'x':
 812       if (warn_traditional)
 813         warning ("the meaning of `\\x' varies with -traditional");
 814
 815       if (flag_traditional)
 816         return c;
 817
 818       code = 0;
 819       count = 0;
 820       nonnull = 0;
 821       while (1)
 822         {
 823           c = getc (finput);
 824           if (!(c >= 'a' && c <= 'f')
 825               && !(c >= 'A' && c <= 'F')
 826               && !(c >= '0' && c <= '9'))
 827             {
 828               ungetc (c, finput);
 829               break;
 830             }
 831           code *= 16;
 832           if (c >= 'a' && c <= 'f')
 833             code += c - 'a' + 10;
 834           if (c >= 'A' && c <= 'F')
 835             code += c - 'A' + 10;
 836           if (c >= '0' && c <= '9')
 837             code += c - '0';
 838           if (code != 0 || count != 0)
 839             {
 840               if (count == 0)
 841                 firstdig = code;
 842               count++;
 843             }
 844           nonnull = 1;
 845         }
 846       if (! nonnull)
 847         error ("\\x used with no following hex digits");
 848       else if (count == 0)
 849         /* Digits are all 0's.  Ok.  */
 850         ;
 851       else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
 852                || (count > 1
 853                    && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
 854                        <= firstdig)))
 855         pedwarn ("hex escape out of range");
 856       return code;
 857
 858     case '0':  case '1':  case '2':  case '3':  case '4':
 859     case '5':  case '6':  case '7':
 860       code = 0;
 861       count = 0;
 862       while ((c <= '7') && (c >= '0') && (count++ < 3))
 863         {
 864           code = (code * 8) + (c - '0');
 865           c = getc (finput);
 866         }
 867       ungetc (c, finput);
 868       return code;
 869
 870     case '\\': case '\'': case '"':
 871       return c;
 872
 873     case '\n':
 874       lineno++;
 875       *ignore_ptr = 1;
 876       return 0;
 877
 878     case 'n':
 879       return TARGET_NEWLINE;
 880
 881     case 't':
 882       return TARGET_TAB;
 883
 884     case 'r':
 885       return TARGET_CR;
 886
 887     case 'f':
 888       return TARGET_FF;
 889
 890     case 'b':
 891       return TARGET_BS;
 892
 893     case 'a':
 894       if (warn_traditional)
 895         warning ("the meaning of `\\a' varies with -traditional");
 896
 897       if (flag_traditional)
 898         return c;
 899       return TARGET_BELL;
 900
 901     case 'v':
 902 #if 0 /* Vertical tab is present in common usage compilers.  */
 903       if (flag_traditional)
 904         return c;
 905 #endif
 906       return TARGET_VT;
 907
 908     case 'e':
 909     case 'E':
 910       if (pedantic)
 911         pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
 912       return 033;
 913
 914     case '?':
 915       return c;
 916
 917       /* `\(', etc, are used at beginning of line to avoid confusing Emacs.  */
 918     case '(':
 919     case '{':
 920     case '[':
 921       if (pedantic)
 922         pedwarn ("non-ANSI escape sequence `\\%c'", c);
 923       return c;
 924     }
 925   if (c >= 040 && c < 0177)
 926     pedwarn ("unknown escape sequence `\\%c'", c);
 927   else
 928     pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
 929   return c;
 930 }
 931 \f
 932 void
 933 yyerror (string)
 934      char *string;
 935 {
 936   char buf[200];
 937
 938   strcpy (buf, string);
 939
 940   /* We can't print string and character constants well
 941      because the token_buffer contains the result of processing escapes.  */
 942   if (end_of_file)
 943     strcat (buf, " at end of input");
 944   else if (token_buffer[0] == 0)
 945     strcat (buf, " at null character");
 946   else if (token_buffer[0] == '"')
 947     strcat (buf, " before string constant");
 948   else if (token_buffer[0] == '\'')
 949     strcat (buf, " before character constant");
 950   else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
 951     sprintf (buf + strlen (buf), " before character 0%o",
 952              (unsigned char) token_buffer[0]);
 953   else
 954     strcat (buf, " before `%s'");
 955
 956   error (buf, token_buffer);
 957 }
 958
 959 #if 0
 960
 961 struct try_type
 962 {
 963   tree *node_var;
 964   char unsigned_flag;
 965   char long_flag;
 966   char long_long_flag;
 967 };
 968
 969 struct try_type type_sequence[] =
 970 {
 971   { &integer_type_node, 0, 0, 0},
 972   { &unsigned_type_node, 1, 0, 0},
 973   { &long_integer_type_node, 0, 1, 0},
 974   { &long_unsigned_type_node, 1, 1, 0},
 975   { &long_long_integer_type_node, 0, 1, 1},
 976   { &long_long_unsigned_type_node, 1, 1, 1}
 977 };
 978 #endif /* 0 */
 979 \f
 980 int
 981 yylex ()
 982 {
 983   register int c;
 984   register char *p;
 985   register int value;
 986   int wide_flag = 0;
 987
 988   if (nextchar >= 0)
 989     c = nextchar, nextchar = -1;
 990   else
 991     c = getc (finput);
 992
 993   /* Effectively do c = skip_white_space (c)
 994      but do it faster in the usual cases.  */
 995   while (1)
 996     switch (c)
 997       {
 998       case ' ':
 999       case '\t':
1000       case '\f':
1001       case '\v':
1002       case '\b':
1003         c = getc (finput);
1004         break;
1005
1006       case '\r':
1007         /* Call skip_white_space so we can warn if appropriate.  */
1008
1009       case '\n':
1010       case '/':
1011       case '\\':
1012         c = skip_white_space (c);
1013       default:
1014         goto found_nonwhite;
1015       }
1016  found_nonwhite:
1017
1018   token_buffer[0] = c;
1019   token_buffer[1] = 0;
1020
1021 /*  yylloc.first_line = lineno; */
1022
1023   switch (c)
1024     {
1025     case EOF:
1026       end_of_file = 1;
1027       token_buffer[0] = 0;
1028       value = ENDFILE;
1029       break;
1030
1031     case '$':
1032       if (dollars_in_ident)
1033         goto letter;
1034       return '$';
1035
1036     case 'L':
1037       /* Capital L may start a wide-string or wide-character constant.  */
1038       {
1039         register int c = getc (finput);
1040         if (c == '\'')
1041           {
1042             wide_flag = 1;
1043             goto char_constant;
1044           }
1045         if (c == '"')
1046           {
1047             wide_flag = 1;
1048             goto string_constant;
1049           }
1050         ungetc (c, finput);
1051       }
1052       goto letter;
1053
1054     case '@':
1055       if (!doing_objc_thang)
1056         {
1057           value = c;
1058           break;
1059         }
1060       p = token_buffer;
1061       *p++ = '@';
1062       c = getc (finput);
1063       while (isalnum (c) || c == '_')
1064         {
1065           if (p >= token_buffer + maxtoken)
1066             p = extend_token_buffer (p);
1067
1068           *p++ = c;
1069           c = getc (finput);
1070         }
1071
1072       *p = 0;
1073       nextchar = c;
1074       value = recognize_objc_keyword (token_buffer + 1);
1075       if (value != 0)
1076         break;
1077       error ("invalid Objective C keyword `%s'", token_buffer);
1078       /* Cause a syntax error--1 is not a valid token type.  */
1079       value = 1;
1080       break;
1081
1082     case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
1083     case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
1084     case 'K':             case 'M':  case 'N':  case 'O':
1085     case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
1086     case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
1087     case 'Z':
1088     case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
1089     case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
1090     case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
1091     case 'p':  case 'q':  case 'r':  case 's':  case 't':
1092     case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
1093     case 'z':
1094     case '_':
1095     letter:
1096       p = token_buffer;
1097       while (isalnum (c) || c == '_' || c == '$' || c == '@')
1098         {
1099           /* Make sure this char really belongs in an identifier.  */
1100           if (c == '@' && ! doing_objc_thang)
1101             break;
1102           if (c == '$' && ! dollars_in_ident)
1103             break;
1104
1105           if (p >= token_buffer + maxtoken)
1106             p = extend_token_buffer (p);
1107
1108           *p++ = c;
1109           c = getc (finput);
1110         }
1111
1112       *p = 0;
1113       nextchar = c;
1114
1115       value = IDENTIFIER;
1116       yylval.itype = 0;
1117
1118       /* Try to recognize a keyword.  Uses minimum-perfect hash function */
1119
1120       {
1121         register struct resword *ptr;
1122
1123         if (ptr = is_reserved_word (token_buffer, p - token_buffer))
1124           {
1125             if (ptr->rid)
1126               yylval.ttype = ridpointers[(int) ptr->rid];
1127             value = (int) ptr->token;
1128
1129             /* Even if we decided to recognize asm, still perhaps warn.  */
1130             if (pedantic
1131                 && (value == ASM_KEYWORD || value == TYPEOF
1132                     || ptr->rid == RID_INLINE)
1133                 && token_buffer[0] != '_')
1134               pedwarn ("ANSI does not permit the keyword `%s'",
1135                        token_buffer);
1136           }
1137       }
1138
1139       /* If we did not find a keyword, look for an identifier
1140          (or a typename).  */
1141
1142       if (value == IDENTIFIER)
1143         {
1144           yylval.ttype = get_identifier (token_buffer);
1145           lastiddecl = lookup_name (yylval.ttype);
1146
1147           if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1148             value = TYPENAME;
1149           /* A user-invisible read-only initialized variable
1150              should be replaced by its value.
1151              We handle only strings since that's the only case used in C.  */
1152           else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
1153                    && DECL_IGNORED_P (lastiddecl)
1154                    && TREE_READONLY (lastiddecl)
1155                    && DECL_INITIAL (lastiddecl) != 0
1156                    && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
1157             {
1158               yylval.ttype = DECL_INITIAL (lastiddecl);
1159               value = STRING;
1160             }
1161           else if (doing_objc_thang)
1162             {
1163               tree objc_interface_decl = lookup_interface (yylval.ttype);
1164
1165               if (objc_interface_decl)
1166                 {
1167                   value = CLASSNAME;
1168                   yylval.ttype = objc_interface_decl;
1169                 }
1170             }
1171         }
1172
1173       break;
1174
1175     case '0':  case '1':  case '2':  case '3':  case '4':
1176     case '5':  case '6':  case '7':  case '8':  case '9':
1177     case '.':
1178       {
1179         int base = 10;
1180         int count = 0;
1181         int largest_digit = 0;
1182         int numdigits = 0;
1183         /* for multi-precision arithmetic,
1184            we actually store only HOST_BITS_PER_CHAR bits in each part.
1185            The number of parts is chosen so as to be sufficient to hold
1186            the enough bits to fit into the two HOST_WIDE_INTs that contain
1187            the integer value (this is always at least as many bits as are
1188            in a target `long long' value, but may be wider).  */
1189 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1190         int parts[TOTAL_PARTS];
1191         int overflow = 0;
1192
1193         enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
1194           = NOT_FLOAT;
1195
1196         for (count = 0; count < TOTAL_PARTS; count++)
1197           parts[count] = 0;
1198
1199         p = token_buffer;
1200         *p++ = c;
1201
1202         if (c == '0')
1203           {
1204             *p++ = (c = getc (finput));
1205             if ((c == 'x') || (c == 'X'))
1206               {
1207                 base = 16;
1208                 *p++ = (c = getc (finput));
1209               }
1210             /* Leading 0 forces octal unless the 0 is the only digit.  */
1211             else if (c >= '0' && c <= '9')
1212               {
1213                 base = 8;
1214                 numdigits++;
1215               }
1216             else
1217               numdigits++;
1218           }
1219
1220         /* Read all the digits-and-decimal-points.  */
1221
1222         while (c == '.'
1223                || (isalnum (c) && (c != 'l') && (c != 'L')
1224                    && (c != 'u') && (c != 'U')
1225                    && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
1226           {
1227             if (c == '.')
1228               {
1229                 if (base == 16)
1230                   error ("floating constant may not be in radix 16");
1231                 if (floatflag == AFTER_POINT)
1232                   {
1233                     error ("malformed floating constant");
1234                     floatflag = TOO_MANY_POINTS;
1235                   }
1236                 else
1237                   floatflag = AFTER_POINT;
1238
1239                 base = 10;
1240                 *p++ = c = getc (finput);
1241                 /* Accept '.' as the start of a floating-point number
1242                    only when it is followed by a digit.
1243                    Otherwise, unread the following non-digit
1244                    and use the '.' as a structural token.  */
1245                 if (p == token_buffer + 2 && !isdigit (c))
1246                   {
1247                     if (c == '.')
1248                       {
1249                         c = getc (finput);
1250                         if (c == '.')
1251                           {
1252                             *p++ = c;
1253                             *p = 0;
1254                             return ELLIPSIS;
1255                           }
1256                         error ("parse error at `..'");
1257                       }
1258                     ungetc (c, finput);
1259                     token_buffer[1] = 0;
1260                     value = '.';
1261                     goto done;
1262                   }
1263               }
1264             else
1265               {
1266                 /* It is not a decimal point.
1267                    It should be a digit (perhaps a hex digit).  */
1268
1269                 if (isdigit (c))
1270                   {
1271                     c = c - '0';
1272                   }
1273                 else if (base <= 10)
1274                   {
1275                     if ((c&~040) == 'E')
1276                       {
1277                         base = 10;
1278                         floatflag = AFTER_POINT;
1279                         break;   /* start of exponent */
1280                       }
1281                     error ("nondigits in number and not hexadecimal");
1282                     c = 0;
1283                   }
1284                 else if (c >= 'a')
1285                   {
1286                     c = c - 'a' + 10;
1287                   }
1288                 else
1289                   {
1290                     c = c - 'A' + 10;
1291                   }
1292                 if (c >= largest_digit)
1293                   largest_digit = c;
1294                 numdigits++;
1295
1296                 for (count = 0; count < TOTAL_PARTS; count++)
1297                   {
1298                     parts[count] *= base;
1299                     if (count)
1300                       {
1301                         parts[count]
1302                           += (parts[count-1] >> HOST_BITS_PER_CHAR);
1303                         parts[count-1]
1304                           &= (1 << HOST_BITS_PER_CHAR) - 1;
1305                       }
1306                     else
1307                       parts[0] += c;
1308                   }
1309
1310                 /* If the extra highest-order part ever gets anything in it,
1311                    the number is certainly too big.  */
1312                 if (parts[TOTAL_PARTS - 1] != 0)
1313                   overflow = 1;
1314
1315                 if (p >= token_buffer + maxtoken - 3)
1316                   p = extend_token_buffer (p);
1317                 *p++ = (c = getc (finput));
1318               }
1319           }
1320
1321         if (numdigits == 0)
1322           error ("numeric constant with no digits");
1323
1324         if (largest_digit >= base)
1325           error ("numeric constant contains digits beyond the radix");
1326
1327         /* Remove terminating char from the token buffer and delimit the string */
1328         *--p = 0;
1329
1330         if (floatflag != NOT_FLOAT)
1331           {
1332             tree type = double_type_node;
1333             int garbage_chars = 0, exceeds_double = 0;
1334             REAL_VALUE_TYPE value;
1335             jmp_buf handler;
1336
1337             /* Read explicit exponent if any, and put it in tokenbuf.  */
1338
1339             if ((c == 'e') || (c == 'E'))
1340               {
1341                 if (p >= token_buffer + maxtoken - 3)
1342                   p = extend_token_buffer (p);
1343                 *p++ = c;
1344                 c = getc (finput);
1345                 if ((c == '+') || (c == '-'))
1346                   {
1347                     *p++ = c;
1348                     c = getc (finput);
1349                   }
1350                 if (! isdigit (c))
1351                   error ("floating constant exponent has no digits");
1352                 while (isdigit (c))
1353                   {
1354                     if (p >= token_buffer + maxtoken - 3)
1355                       p = extend_token_buffer (p);
1356                     *p++ = c;
1357                     c = getc (finput);
1358                   }
1359               }
1360
1361             *p = 0;
1362             errno = 0;
1363
1364             /* Convert string to a double, checking for overflow.  */
1365             if (setjmp (handler))
1366               {
1367                 error ("floating constant out of range");
1368                 value = dconst0;
1369               }
1370             else
1371               {
1372                 set_float_handler (handler);
1373                 value = REAL_VALUE_ATOF (token_buffer);
1374                 set_float_handler (NULL_PTR);
1375               }
1376 #ifdef ERANGE
1377             if (errno == ERANGE && !flag_traditional && pedantic)
1378               {
1379                 /* ERANGE is also reported for underflow,
1380                    so test the value to distinguish overflow from that.  */
1381                 if (REAL_VALUES_LESS (dconst1, value)
1382                     || REAL_VALUES_LESS (value, dconstm1))
1383                   {
1384                     pedwarn ("floating point number exceeds range of `double'");
1385                     exceeds_double = 1;
1386                   }
1387               }
1388 #endif
1389
1390             /* Read the suffixes to choose a data type.  */
1391             switch (c)
1392               {
1393               case 'f': case 'F':
1394                 type = float_type_node;
1395                 value = REAL_VALUE_TRUNCATE (TYPE_MODE (type), value);
1396                 if (REAL_VALUE_ISINF (value) && ! exceeds_double && pedantic)
1397                   pedwarn ("floating point number exceeds range of `float'");
1398                 garbage_chars = -1;
1399                 break;
1400
1401               case 'l': case 'L':
1402                 type = long_double_type_node;
1403                 garbage_chars = -1;
1404                 break;
1405               }
1406             /* Note: garbage_chars is -1 if first char is *not* garbage.  */
1407             while (isalnum (c))
1408               {
1409                 if (p >= token_buffer + maxtoken - 3)
1410                   p = extend_token_buffer (p);
1411                 *p++ = c;
1412                 c = getc (finput);
1413                 garbage_chars++;
1414               }
1415             if (garbage_chars > 0)
1416               error ("garbage at end of number");
1417
1418             /* Create a node with determined type and value.  */
1419             yylval.ttype = build_real (type, value);
1420
1421             ungetc (c, finput);
1422             *p = 0;
1423           }
1424         else
1425           {
1426             tree traditional_type, ansi_type, type;
1427             HOST_WIDE_INT high, low;
1428             int spec_unsigned = 0;
1429             int spec_long = 0;
1430             int spec_long_long = 0;
1431             int bytes, warn, i;
1432
1433             while (1)
1434               {
1435                 if (c == 'u' || c == 'U')
1436                   {
1437                     if (spec_unsigned)
1438                       error ("two `u's in integer constant");
1439                     spec_unsigned = 1;
1440                   }
1441                 else if (c == 'l' || c == 'L')
1442                   {
1443                     if (spec_long)
1444                       {
1445                         if (spec_long_long)
1446                           error ("three `l's in integer constant");
1447                         else if (pedantic)
1448                           pedwarn ("ANSI C forbids long long integer constants");
1449                         spec_long_long = 1;
1450                       }
1451                     spec_long = 1;
1452                   }
1453                 else
1454                   {
1455                     if (isalnum (c))
1456                       {
1457                         error ("garbage at end of number");
1458                         while (isalnum (c))
1459                           {
1460                             if (p >= token_buffer + maxtoken - 3)
1461                               p = extend_token_buffer (p);
1462                             *p++ = c;
1463                             c = getc (finput);
1464                           }
1465                       }
1466                     break;
1467                   }
1468                 if (p >= token_buffer + maxtoken - 3)
1469                   p = extend_token_buffer (p);
1470                 *p++ = c;
1471                 c = getc (finput);
1472               }
1473
1474             ungetc (c, finput);
1475
1476             /* If the constant is not long long and it won't fit in an
1477                unsigned long, or if the constant is long long and won't fit
1478                in an unsigned long long, then warn that the constant is out
1479                of range.  */
1480
1481             /* ??? This assumes that long long and long integer types are
1482                a multiple of 8 bits.  This better than the original code
1483                though which assumed that long was exactly 32 bits and long
1484                long was exactly 64 bits.  */
1485
1486             if (spec_long_long)
1487               bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1488             else
1489               bytes = TYPE_PRECISION (long_integer_type_node) / 8;
1490
1491             warn = overflow;
1492             for (i = bytes; i < TOTAL_PARTS; i++)
1493               if (parts[i])
1494                 warn = 1;
1495             if (warn)
1496               pedwarn ("integer constant out of range");
1497
1498             /* This is simplified by the fact that our constant
1499                is always positive.  */
1500
1501             high = low = 0;
1502
1503             for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1504               {
1505                 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1506                                                     / HOST_BITS_PER_CHAR)]
1507                          << (i * HOST_BITS_PER_CHAR));
1508                 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1509               }
1510
1511             yylval.ttype = build_int_2 (low, high);
1512             TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1513
1514             /* If warn_traditional, calculate both the ANSI type and the
1515                traditional type, then see if they disagree.
1516                Otherwise, calculate only the type for the dialect in use.  */
1517             if (warn_traditional || flag_traditional)
1518               {
1519                 /* Calculate the traditional type.  */
1520                 /* Traditionally, any constant is signed;
1521                    but if unsigned is specified explicitly, obey that.
1522                    Use the smallest size with the right number of bits,
1523                    except for one special case with decimal constants.  */
1524                 if (! spec_long && base != 10
1525                     && int_fits_type_p (yylval.ttype, unsigned_type_node))
1526                   traditional_type = (spec_unsigned ? unsigned_type_node
1527                                       : integer_type_node);
1528                 /* A decimal constant must be long
1529                    if it does not fit in type int.
1530                    I think this is independent of whether
1531                    the constant is signed.  */
1532                 else if (! spec_long && base == 10
1533                          && int_fits_type_p (yylval.ttype, integer_type_node))
1534                   traditional_type = (spec_unsigned ? unsigned_type_node
1535                                       : integer_type_node);
1536                 else if (! spec_long_long)
1537                   traditional_type = (spec_unsigned ? long_unsigned_type_node
1538                                       : long_integer_type_node);
1539                 else
1540                   traditional_type = (spec_unsigned
1541                                       ? long_long_unsigned_type_node
1542                                       : long_long_integer_type_node);
1543               }
1544             if (warn_traditional || ! flag_traditional)
1545               {
1546                 /* Calculate the ANSI type.  */
1547                 if (! spec_long && ! spec_unsigned
1548                     && int_fits_type_p (yylval.ttype, integer_type_node))
1549                   ansi_type = integer_type_node;
1550                 else if (! spec_long && (base != 10 || spec_unsigned)
1551                          && int_fits_type_p (yylval.ttype, unsigned_type_node))
1552                   ansi_type = unsigned_type_node;
1553                 else if (! spec_unsigned && !spec_long_long
1554                          && int_fits_type_p (yylval.ttype, long_integer_type_node))
1555                   ansi_type = long_integer_type_node;
1556                 else if (! spec_long_long)
1557                   ansi_type = long_unsigned_type_node;
1558                 else if (! spec_unsigned
1559                          /* Verify value does not overflow into sign bit.  */
1560                          && TREE_INT_CST_HIGH (yylval.ttype) >= 0
1561                          && int_fits_type_p (yylval.ttype,
1562                                              long_long_integer_type_node))
1563                   ansi_type = long_long_integer_type_node;
1564                 else
1565                   ansi_type = long_long_unsigned_type_node;
1566               }
1567
1568             type = flag_traditional ? traditional_type : ansi_type;
1569
1570             if (warn_traditional && traditional_type != ansi_type)
1571               {
1572                 if (TYPE_PRECISION (traditional_type)
1573                     != TYPE_PRECISION (ansi_type))
1574                   warning ("width of integer constant changes with -traditional");
1575                 else if (TREE_UNSIGNED (traditional_type)
1576                          != TREE_UNSIGNED (ansi_type))
1577                   warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1578                 else
1579                   warning ("width of integer constant may change on other systems with -traditional");
1580               }
1581
1582             if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
1583                 && !warn)
1584               pedwarn ("integer constant out of range");
1585
1586             if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1587               warning ("integer constant is so large that it is unsigned");
1588
1589             if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1590               /* The traditional constant 0x80000000 is signed
1591                  but doesn't fit in the range of int.
1592                  This will change it to -0x80000000, which does fit.  */
1593               {
1594                 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1595                 yylval.ttype = convert (type, yylval.ttype);
1596               }
1597             else
1598               TREE_TYPE (yylval.ttype) = type;
1599
1600             *p = 0;
1601           }
1602
1603         value = CONSTANT; break;
1604       }
1605
1606     case '\'':
1607     char_constant:
1608       {
1609         register int result = 0;
1610         register int num_chars = 0;
1611         unsigned width = TYPE_PRECISION (char_type_node);
1612         int max_chars;
1613
1614         if (wide_flag)
1615           {
1616             width = WCHAR_TYPE_SIZE;
1617 #ifdef MULTIBYTE_CHARS
1618             max_chars = MB_CUR_MAX;
1619 #else
1620             max_chars = 1;
1621 #endif
1622           }
1623         else
1624           max_chars = TYPE_PRECISION (integer_type_node) / width;
1625
1626         while (1)
1627           {
1628           tryagain:
1629
1630             c = getc (finput);
1631
1632             if (c == '\'' || c == EOF)
1633               break;
1634
1635             if (c == '\\')
1636               {
1637                 int ignore = 0;
1638                 c = readescape (&ignore);
1639                 if (ignore)
1640                   goto tryagain;
1641                 if (width < HOST_BITS_PER_INT
1642                     && (unsigned) c >= (1 << width))
1643                   pedwarn ("escape sequence out of range for character");
1644               }
1645             else if (c == '\n')
1646               {
1647                 if (pedantic)
1648                   pedwarn ("ANSI C forbids newline in character constant");
1649                 lineno++;
1650               }
1651
1652             num_chars++;
1653             if (num_chars > maxtoken - 4)
1654               extend_token_buffer (token_buffer);
1655
1656             token_buffer[num_chars] = c;
1657
1658             /* Merge character into result; ignore excess chars.  */
1659             if (num_chars < max_chars + 1)
1660               {
1661                 if (width < HOST_BITS_PER_INT)
1662                   result = (result << width) | (c & ((1 << width) - 1));
1663                 else
1664                   result = c;
1665               }
1666           }
1667
1668         token_buffer[num_chars + 1] = '\'';
1669         token_buffer[num_chars + 2] = 0;
1670
1671         if (c != '\'')
1672           error ("malformatted character constant");
1673         else if (num_chars == 0)
1674           error ("empty character constant");
1675         else if (num_chars > max_chars)
1676           {
1677             num_chars = max_chars;
1678             error ("character constant too long");
1679           }
1680         else if (num_chars != 1 && ! flag_traditional)
1681           warning ("multi-character character constant");
1682
1683         /* If char type is signed, sign-extend the constant.  */
1684         if (! wide_flag)
1685           {
1686             int num_bits = num_chars * width;
1687             if (TREE_UNSIGNED (char_type_node)
1688                 || ((result >> (num_bits - 1)) & 1) == 0)
1689               yylval.ttype
1690                 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
1691                                          >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1692                                0);
1693             else
1694               yylval.ttype
1695                 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
1696                                           >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1697                                -1);
1698           }
1699         else
1700           {
1701 #ifdef MULTIBYTE_CHARS
1702             /* Set the initial shift state and convert the next sequence.  */
1703             result = 0;
1704             /* In all locales L'\0' is zero and mbtowc will return zero,
1705                so don't use it.  */
1706             if (num_chars > 1
1707                 || (num_chars == 1 && token_buffer[1] != '\0'))
1708               {
1709                 wchar_t wc;
1710                 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1711                 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1712                   result = wc;
1713                 else
1714                   warning ("Ignoring invalid multibyte character");
1715               }
1716 #endif
1717             yylval.ttype = build_int_2 (result, 0);
1718           }
1719
1720         TREE_TYPE (yylval.ttype) = integer_type_node;
1721         value = CONSTANT;
1722         break;
1723       }
1724
1725     case '"':
1726     string_constant:
1727       {
1728         c = getc (finput);
1729         p = token_buffer + 1;
1730
1731         while (c != '"' && c >= 0)
1732           {
1733             /* ignore_escape_flag is set for reading the filename in #line.  */
1734             if (!ignore_escape_flag && c == '\\')
1735               {
1736                 int ignore = 0;
1737                 c = readescape (&ignore);
1738                 if (ignore)
1739                   goto skipnewline;
1740                 if (!wide_flag
1741                     && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
1742                     && c >= (1 << TYPE_PRECISION (char_type_node)))
1743                   pedwarn ("escape sequence out of range for character");
1744               }
1745             else if (c == '\n')
1746               {
1747                 if (pedantic)
1748                   pedwarn ("ANSI C forbids newline in string constant");
1749                 lineno++;
1750               }
1751
1752             if (p == token_buffer + maxtoken)
1753               p = extend_token_buffer (p);
1754             *p++ = c;
1755
1756           skipnewline:
1757             c = getc (finput);
1758           }
1759         *p = 0;
1760
1761         /* We have read the entire constant.
1762            Construct a STRING_CST for the result.  */
1763
1764         if (wide_flag)
1765           {
1766             /* If this is a L"..." wide-string, convert the multibyte string
1767                to a wide character string.  */
1768             char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
1769             int len;
1770
1771 #ifdef MULTIBYTE_CHARS
1772             len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
1773             if ((unsigned) len >= (p - token_buffer))
1774               {
1775                 warning ("Ignoring invalid multibyte string");
1776                 len = 0;
1777               }
1778             bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
1779 #else
1780             {
1781               union { long l; char c[sizeof (long)]; } u;
1782               int big_endian;
1783               char *wp, *cp;
1784
1785               /* Determine whether host is little or big endian.  */
1786               u.l = 1;
1787               big_endian = u.c[sizeof (long) - 1];
1788               wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
1789
1790               bzero (widep, (p - token_buffer) * WCHAR_BYTES);
1791               for (cp = token_buffer + 1; cp < p; cp++)
1792                 *wp = *cp, wp += WCHAR_BYTES;
1793               len = p - token_buffer - 1;
1794             }
1795 #endif
1796             yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
1797             TREE_TYPE (yylval.ttype) = wchar_array_type_node;
1798           }
1799         else
1800           {
1801             yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
1802             TREE_TYPE (yylval.ttype) = char_array_type_node;
1803           }
1804
1805         *p++ = '"';
1806         *p = 0;
1807
1808         value = STRING; break;
1809       }
1810
1811     case '+':
1812     case '-':
1813     case '&':
1814     case '|':
1815     case '<':
1816     case '>':
1817     case '*':
1818     case '/':
1819     case '%':
1820     case '^':
1821     case '!':
1822     case '=':
1823       {
1824         register int c1;
1825
1826       combine:
1827
1828         switch (c)
1829           {
1830           case '+':
1831             yylval.code = PLUS_EXPR; break;
1832           case '-':
1833             yylval.code = MINUS_EXPR; break;
1834           case '&':
1835             yylval.code = BIT_AND_EXPR; break;
1836           case '|':
1837             yylval.code = BIT_IOR_EXPR; break;
1838           case '*':
1839             yylval.code = MULT_EXPR; break;
1840           case '/':
1841             yylval.code = TRUNC_DIV_EXPR; break;
1842           case '%':
1843             yylval.code = TRUNC_MOD_EXPR; break;
1844           case '^':
1845             yylval.code = BIT_XOR_EXPR; break;
1846           case LSHIFT:
1847             yylval.code = LSHIFT_EXPR; break;
1848           case RSHIFT:
1849             yylval.code = RSHIFT_EXPR; break;
1850           case '<':
1851             yylval.code = LT_EXPR; break;
1852           case '>':
1853             yylval.code = GT_EXPR; break;
1854           }
1855
1856         token_buffer[1] = c1 = getc (finput);
1857         token_buffer[2] = 0;
1858
1859         if (c1 == '=')
1860           {
1861             switch (c)
1862               {
1863               case '<':
1864                 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
1865               case '>':
1866                 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
1867               case '!':
1868                 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
1869               case '=':
1870                 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
1871               }
1872             value = ASSIGN; goto done;
1873           }
1874         else if (c == c1)
1875           switch (c)
1876             {
1877             case '+':
1878               value = PLUSPLUS; goto done;
1879             case '-':
1880               value = MINUSMINUS; goto done;
1881             case '&':
1882               value = ANDAND; goto done;
1883             case '|':
1884               value = OROR; goto done;
1885             case '<':
1886               c = LSHIFT;
1887               goto combine;
1888             case '>':
1889               c = RSHIFT;
1890               goto combine;
1891             }
1892         else if ((c == '-') && (c1 == '>'))
1893           { value = POINTSAT; goto done; }
1894         ungetc (c1, finput);
1895         token_buffer[1] = 0;
1896
1897         if ((c == '<') || (c == '>'))
1898           value = ARITHCOMPARE;
1899         else value = c;
1900         goto done;
1901       }
1902
1903     case 0:
1904       /* Don't make yyparse think this is eof.  */
1905       value = 1;
1906       break;
1907
1908     default:
1909       value = c;
1910     }
1911
1912 done:
1913 /*  yylloc.last_line = lineno; */
1914
1915   return value;
1916 }
1917
1918 /* Sets the value of the 'yydebug' variable to VALUE.
1919    This is a function so we don't have to have YYDEBUG defined
1920    in order to build the compiler.  */
1921
1922 void
1923 set_yydebug (value)
1924      int value;
1925 {
1926 #if YYDEBUG != 0
1927   yydebug = value;
1928 #else
1929   warning ("YYDEBUG not defined.");
1930 #endif
1931 }