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 -1 if it is backslash-newline.  */
 798
 799 static int
 800 readescape ()
 801 {
 802   register int c = getc (finput);
 803   register int code;
 804   register unsigned count;
 805   unsigned firstdig;
 806   int nonnull;
 807
 808   switch (c)
 809     {
 810     case 'x':
 811       if (warn_traditional)
 812         warning ("the meaning of `\\x' varies with -traditional");
 813
 814       if (flag_traditional)
 815         return c;
 816
 817       code = 0;
 818       count = 0;
 819       nonnull = 0;
 820       while (1)
 821         {
 822           c = getc (finput);
 823           if (!(c >= 'a' && c <= 'f')
 824               && !(c >= 'A' && c <= 'F')
 825               && !(c >= '0' && c <= '9'))
 826             {
 827               ungetc (c, finput);
 828               break;
 829             }
 830           code *= 16;
 831           if (c >= 'a' && c <= 'f')
 832             code += c - 'a' + 10;
 833           if (c >= 'A' && c <= 'F')
 834             code += c - 'A' + 10;
 835           if (c >= '0' && c <= '9')
 836             code += c - '0';
 837           if (code != 0 || count != 0)
 838             {
 839               if (count == 0)
 840                 firstdig = code;
 841               count++;
 842             }
 843           nonnull = 1;
 844         }
 845       if (! nonnull)
 846         error ("\\x used with no following hex digits");
 847       else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
 848                || (count > 1
 849                    && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
 850                        <= firstdig)))
 851         pedwarn ("hex escape out of range");
 852       return code;
 853
 854     case '0':  case '1':  case '2':  case '3':  case '4':
 855     case '5':  case '6':  case '7':
 856       code = 0;
 857       count = 0;
 858       while ((c <= '7') && (c >= '0') && (count++ < 3))
 859         {
 860           code = (code * 8) + (c - '0');
 861           c = getc (finput);
 862         }
 863       ungetc (c, finput);
 864       return code;
 865
 866     case '\\': case '\'': case '"':
 867       return c;
 868
 869     case '\n':
 870       lineno++;
 871       return -1;
 872
 873     case 'n':
 874       return TARGET_NEWLINE;
 875
 876     case 't':
 877       return TARGET_TAB;
 878
 879     case 'r':
 880       return TARGET_CR;
 881
 882     case 'f':
 883       return TARGET_FF;
 884
 885     case 'b':
 886       return TARGET_BS;
 887
 888     case 'a':
 889       if (warn_traditional)
 890         warning ("the meaning of `\\a' varies with -traditional");
 891
 892       if (flag_traditional)
 893         return c;
 894       return TARGET_BELL;
 895
 896     case 'v':
 897 #if 0 /* Vertical tab is present in common usage compilers.  */
 898       if (flag_traditional)
 899         return c;
 900 #endif
 901       return TARGET_VT;
 902
 903     case 'E':
 904       pedwarn ("non-ANSI-standard escape sequence, `\\E'");
 905       return 033;
 906
 907     case '?':
 908       return c;
 909
 910       /* `\(', etc, are used at beginning of line to avoid confusing Emacs.  */
 911     case '(':
 912     case '{':
 913     case '[':
 914       if (pedantic)
 915         pedwarn ("non-ANSI escape sequence `\\%c'", c);
 916       return c;
 917     }
 918   if (c >= 040 && c < 0177)
 919     pedwarn ("unknown escape sequence `\\%c'", c);
 920   else
 921     pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
 922   return c;
 923 }
 924 \f
 925 void
 926 yyerror (string)
 927      char *string;
 928 {
 929   char buf[200];
 930
 931   strcpy (buf, string);
 932
 933   /* We can't print string and character constants well
 934      because the token_buffer contains the result of processing escapes.  */
 935   if (end_of_file)
 936     strcat (buf, " at end of input");
 937   else if (token_buffer[0] == 0)
 938     strcat (buf, " at null character");
 939   else if (token_buffer[0] == '"')
 940     strcat (buf, " before string constant");
 941   else if (token_buffer[0] == '\'')
 942     strcat (buf, " before character constant");
 943   else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
 944     sprintf (buf + strlen (buf), " before character 0%o",
 945              (unsigned char) token_buffer[0]);
 946   else
 947     strcat (buf, " before `%s'");
 948
 949   error (buf, token_buffer);
 950 }
 951
 952 #if 0
 953
 954 struct try_type
 955 {
 956   tree *node_var;
 957   char unsigned_flag;
 958   char long_flag;
 959   char long_long_flag;
 960 };
 961
 962 struct try_type type_sequence[] =
 963 {
 964   { &integer_type_node, 0, 0, 0},
 965   { &unsigned_type_node, 1, 0, 0},
 966   { &long_integer_type_node, 0, 1, 0},
 967   { &long_unsigned_type_node, 1, 1, 0},
 968   { &long_long_integer_type_node, 0, 1, 1},
 969   { &long_long_unsigned_type_node, 1, 1, 1}
 970 };
 971 #endif /* 0 */
 972 \f
 973 int
 974 yylex ()
 975 {
 976   register int c;
 977   register char *p;
 978   register int value;
 979   int wide_flag = 0;
 980
 981   if (nextchar >= 0)
 982     c = nextchar, nextchar = -1;
 983   else
 984     c = getc (finput);
 985
 986   /* Effectively do c = skip_white_space (c)
 987      but do it faster in the usual cases.  */
 988   while (1)
 989     switch (c)
 990       {
 991       case ' ':
 992       case '\t':
 993       case '\f':
 994       case '\v':
 995       case '\b':
 996         c = getc (finput);
 997         break;
 998
 999       case '\r':
1000         /* Call skip_white_space so we can warn if appropriate.  */
1001
1002       case '\n':
1003       case '/':
1004       case '\\':
1005         c = skip_white_space (c);
1006       default:
1007         goto found_nonwhite;
1008       }
1009  found_nonwhite:
1010
1011   token_buffer[0] = c;
1012   token_buffer[1] = 0;
1013
1014 /*  yylloc.first_line = lineno; */
1015
1016   switch (c)
1017     {
1018     case EOF:
1019       end_of_file = 1;
1020       token_buffer[0] = 0;
1021       value = ENDFILE;
1022       break;
1023
1024     case '$':
1025       if (dollars_in_ident)
1026         goto letter;
1027       return '$';
1028
1029     case 'L':
1030       /* Capital L may start a wide-string or wide-character constant.  */
1031       {
1032         register int c = getc (finput);
1033         if (c == '\'')
1034           {
1035             wide_flag = 1;
1036             goto char_constant;
1037           }
1038         if (c == '"')
1039           {
1040             wide_flag = 1;
1041             goto string_constant;
1042           }
1043         ungetc (c, finput);
1044       }
1045       goto letter;
1046
1047     case '@':
1048       if (!doing_objc_thang)
1049         {
1050           value = c;
1051           break;
1052         }
1053       p = token_buffer;
1054       *p++ = '@';
1055       c = getc (finput);
1056       while (isalnum (c) || c == '_')
1057         {
1058           if (p >= token_buffer + maxtoken)
1059             p = extend_token_buffer (p);
1060
1061           *p++ = c;
1062           c = getc (finput);
1063         }
1064
1065       *p = 0;
1066       nextchar = c;
1067       value = recognize_objc_keyword (token_buffer + 1);
1068       if (value != 0)
1069         break;
1070       error ("invalid Objective C keyword `%s'", token_buffer);
1071       /* Cause a syntax error--1 is not a valid token type.  */
1072       value = 1;
1073       break;
1074
1075     case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
1076     case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
1077     case 'K':             case 'M':  case 'N':  case 'O':
1078     case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
1079     case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
1080     case 'Z':
1081     case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
1082     case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
1083     case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
1084     case 'p':  case 'q':  case 'r':  case 's':  case 't':
1085     case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
1086     case 'z':
1087     case '_':
1088     letter:
1089       p = token_buffer;
1090       while (isalnum (c) || c == '_' || c == '$' || c == '@')
1091         {
1092           if (p >= token_buffer + maxtoken)
1093             p = extend_token_buffer (p);
1094           if (c == '$' && ! dollars_in_ident)
1095             break;
1096
1097           *p++ = c;
1098           c = getc (finput);
1099         }
1100
1101       *p = 0;
1102       nextchar = c;
1103
1104       value = IDENTIFIER;
1105       yylval.itype = 0;
1106
1107       /* Try to recognize a keyword.  Uses minimum-perfect hash function */
1108
1109       {
1110         register struct resword *ptr;
1111
1112         if (ptr = is_reserved_word (token_buffer, p - token_buffer))
1113           {
1114             if (ptr->rid)
1115               yylval.ttype = ridpointers[(int) ptr->rid];
1116             value = (int) ptr->token;
1117
1118             /* Even if we decided to recognize asm, still perhaps warn.  */
1119             if (pedantic
1120                 && (value == ASM_KEYWORD || value == TYPEOF
1121                     || ptr->rid == RID_INLINE)
1122                 && token_buffer[0] != '_')
1123               pedwarn ("ANSI does not permit the keyword `%s'",
1124                        token_buffer);
1125           }
1126       }
1127
1128       /* If we did not find a keyword, look for an identifier
1129          (or a typename).  */
1130
1131       if (value == IDENTIFIER)
1132         {
1133           yylval.ttype = get_identifier (token_buffer);
1134           lastiddecl = lookup_name (yylval.ttype);
1135
1136           if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1137             value = TYPENAME;
1138           /* A user-invisible read-only initialized variable
1139              should be replaced by its value.
1140              We handle only strings since that's the only case used in C.  */
1141           else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
1142                    && DECL_IGNORED_P (lastiddecl)
1143                    && TREE_READONLY (lastiddecl)
1144                    && DECL_INITIAL (lastiddecl) != 0
1145                    && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
1146             {
1147               yylval.ttype = DECL_INITIAL (lastiddecl);
1148               value = STRING;
1149             }
1150           else if (doing_objc_thang)
1151             {
1152               tree objc_interface_decl = lookup_interface (yylval.ttype);
1153
1154               if (objc_interface_decl)
1155                 {
1156                   value = CLASSNAME;
1157                   yylval.ttype = objc_interface_decl;
1158                 }
1159             }
1160         }
1161
1162       break;
1163
1164     case '0':  case '1':  case '2':  case '3':  case '4':
1165     case '5':  case '6':  case '7':  case '8':  case '9':
1166     case '.':
1167       {
1168         int base = 10;
1169         int count = 0;
1170         int largest_digit = 0;
1171         int numdigits = 0;
1172         /* for multi-precision arithmetic,
1173            we actually store only HOST_BITS_PER_CHAR bits in each part.
1174            The number of parts is chosen so as to be sufficient to hold
1175            the enough bits to fit into the two HOST_WIDE_INTs that contain
1176            the integer value (this is always at least as many bits as are
1177            in a target `long long' value, but may be wider).  */
1178 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1179         int parts[TOTAL_PARTS];
1180         int overflow = 0;
1181
1182         enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
1183           = NOT_FLOAT;
1184
1185         for (count = 0; count < TOTAL_PARTS; count++)
1186           parts[count] = 0;
1187
1188         p = token_buffer;
1189         *p++ = c;
1190
1191         if (c == '0')
1192           {
1193             *p++ = (c = getc (finput));
1194             if ((c == 'x') || (c == 'X'))
1195               {
1196                 base = 16;
1197                 *p++ = (c = getc (finput));
1198               }
1199             /* Leading 0 forces octal unless the 0 is the only digit.  */
1200             else if (c >= '0' && c <= '9')
1201               {
1202                 base = 8;
1203                 numdigits++;
1204               }
1205             else
1206               numdigits++;
1207           }
1208
1209         /* Read all the digits-and-decimal-points.  */
1210
1211         while (c == '.'
1212                || (isalnum (c) && (c != 'l') && (c != 'L')
1213                    && (c != 'u') && (c != 'U')
1214                    && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
1215           {
1216             if (c == '.')
1217               {
1218                 if (base == 16)
1219                   error ("floating constant may not be in radix 16");
1220                 if (floatflag == AFTER_POINT)
1221                   {
1222                     error ("malformed floating constant");
1223                     floatflag = TOO_MANY_POINTS;
1224                   }
1225                 else
1226                   floatflag = AFTER_POINT;
1227
1228                 base = 10;
1229                 *p++ = c = getc (finput);
1230                 /* Accept '.' as the start of a floating-point number
1231                    only when it is followed by a digit.
1232                    Otherwise, unread the following non-digit
1233                    and use the '.' as a structural token.  */
1234                 if (p == token_buffer + 2 && !isdigit (c))
1235                   {
1236                     if (c == '.')
1237                       {
1238                         c = getc (finput);
1239                         if (c == '.')
1240                           {
1241                             *p++ = c;
1242                             *p = 0;
1243                             return ELLIPSIS;
1244                           }
1245                         error ("parse error at `..'");
1246                       }
1247                     ungetc (c, finput);
1248                     token_buffer[1] = 0;
1249                     value = '.';
1250                     goto done;
1251                   }
1252               }
1253             else
1254               {
1255                 /* It is not a decimal point.
1256                    It should be a digit (perhaps a hex digit).  */
1257
1258                 if (isdigit (c))
1259                   {
1260                     c = c - '0';
1261                   }
1262                 else if (base <= 10)
1263                   {
1264                     if ((c&~040) == 'E')
1265                       {
1266                         base = 10;
1267                         floatflag = AFTER_POINT;
1268                         break;   /* start of exponent */
1269                       }
1270                     error ("nondigits in number and not hexadecimal");
1271                     c = 0;
1272                   }
1273                 else if (c >= 'a')
1274                   {
1275                     c = c - 'a' + 10;
1276                   }
1277                 else
1278                   {
1279                     c = c - 'A' + 10;
1280                   }
1281                 if (c >= largest_digit)
1282                   largest_digit = c;
1283                 numdigits++;
1284
1285                 for (count = 0; count < TOTAL_PARTS; count++)
1286                   {
1287                     parts[count] *= base;
1288                     if (count)
1289                       {
1290                         parts[count]
1291                           += (parts[count-1] >> HOST_BITS_PER_CHAR);
1292                         parts[count-1]
1293                           &= (1 << HOST_BITS_PER_CHAR) - 1;
1294                       }
1295                     else
1296                       parts[0] += c;
1297                   }
1298
1299                 /* If the extra highest-order part ever gets anything in it,
1300                    the number is certainly too big.  */
1301                 if (parts[TOTAL_PARTS - 1] != 0)
1302                   overflow = 1;
1303
1304                 if (p >= token_buffer + maxtoken - 3)
1305                   p = extend_token_buffer (p);
1306                 *p++ = (c = getc (finput));
1307               }
1308           }
1309
1310         if (numdigits == 0)
1311           error ("numeric constant with no digits");
1312
1313         if (largest_digit >= base)
1314           error ("numeric constant contains digits beyond the radix");
1315
1316         /* Remove terminating char from the token buffer and delimit the string */
1317         *--p = 0;
1318
1319         if (floatflag != NOT_FLOAT)
1320           {
1321             tree type = double_type_node;
1322             int garbage_chars = 0, exceeds_double = 0;
1323             REAL_VALUE_TYPE value;
1324             jmp_buf handler;
1325
1326             /* Read explicit exponent if any, and put it in tokenbuf.  */
1327
1328             if ((c == 'e') || (c == 'E'))
1329               {
1330                 if (p >= token_buffer + maxtoken - 3)
1331                   p = extend_token_buffer (p);
1332                 *p++ = c;
1333                 c = getc (finput);
1334                 if ((c == '+') || (c == '-'))
1335                   {
1336                     *p++ = c;
1337                     c = getc (finput);
1338                   }
1339                 if (! isdigit (c))
1340                   error ("floating constant exponent has no digits");
1341                 while (isdigit (c))
1342                   {
1343                     if (p >= token_buffer + maxtoken - 3)
1344                       p = extend_token_buffer (p);
1345                     *p++ = c;
1346                     c = getc (finput);
1347                   }
1348               }
1349
1350             *p = 0;
1351             errno = 0;
1352
1353             /* Convert string to a double, checking for overflow.  */
1354             if (setjmp (handler))
1355               {
1356                 error ("floating constant out of range");
1357                 value = dconst0;
1358               }
1359             else
1360               {
1361                 set_float_handler (handler);
1362                 value = REAL_VALUE_ATOF (token_buffer);
1363                 set_float_handler (NULL_PTR);
1364               }
1365 #ifdef ERANGE
1366             if (errno == ERANGE && !flag_traditional && pedantic)
1367               {
1368                 char *p1 = token_buffer;
1369                 /* Check for "0.0" and variants;
1370                    SunOS 4 spuriously returns ERANGE for them.  */
1371                 while (*p1 == '0') p1++;
1372                 if (*p1 == '.')
1373                   {
1374                     p1++;
1375                     while (*p1 == '0') p1++;
1376                   }
1377                 if (*p1 == 'e' || *p1 == 'E')
1378                   {
1379                     /* with significand==0, ignore the exponent */
1380                     p1++;
1381                     while (*p1 != 0) p1++;
1382                   }
1383                 /* ERANGE is also reported for underflow,
1384                    so test the value to distinguish overflow from that.  */
1385                 if (*p1 != 0 && (value > 1.0 || value < -1.0))
1386                   {
1387                     pedwarn ("floating point number exceeds range of `double'");
1388                     exceeds_double = 1;
1389                   }
1390               }
1391 #endif
1392
1393             /* Read the suffixes to choose a data type.  */
1394             switch (c)
1395               {
1396               case 'f': case 'F':
1397                 type = float_type_node;
1398                 value = REAL_VALUE_TRUNCATE (TYPE_MODE (type), value);
1399                 if (REAL_VALUE_ISINF (value) && ! exceeds_double && pedantic)
1400                   pedwarn ("floating point number exceeds range of `float'");
1401                 garbage_chars = -1;
1402                 break;
1403
1404               case 'l': case 'L':
1405                 type = long_double_type_node;
1406                 garbage_chars = -1;
1407                 break;
1408               }
1409             /* Note: garbage_chars is -1 if first char is *not* garbage.  */
1410             while (isalnum (c))
1411               {
1412                 if (p >= token_buffer + maxtoken - 3)
1413                   p = extend_token_buffer (p);
1414                 *p++ = c;
1415                 c = getc (finput);
1416                 garbage_chars++;
1417               }
1418             if (garbage_chars > 0)
1419               error ("garbage at end of number");
1420
1421             /* Create a node with determined type and value.  */
1422             yylval.ttype = build_real (type, value);
1423
1424             ungetc (c, finput);
1425             *p = 0;
1426           }
1427         else
1428           {
1429             tree traditional_type, ansi_type, type;
1430             HOST_WIDE_INT high, low;
1431             int spec_unsigned = 0;
1432             int spec_long = 0;
1433             int spec_long_long = 0;
1434             int bytes, warn, i;
1435
1436             while (1)
1437               {
1438                 if (c == 'u' || c == 'U')
1439                   {
1440                     if (spec_unsigned)
1441                       error ("two `u's in integer constant");
1442                     spec_unsigned = 1;
1443                   }
1444                 else if (c == 'l' || c == 'L')
1445                   {
1446                     if (spec_long)
1447                       {
1448                         if (spec_long_long)
1449                           error ("three `l's in integer constant");
1450                         else if (pedantic)
1451                           pedwarn ("ANSI C forbids long long integer constants");
1452                         spec_long_long = 1;
1453                       }
1454                     spec_long = 1;
1455                   }
1456                 else
1457                   {
1458                     if (isalnum (c))
1459                       {
1460                         error ("garbage at end of number");
1461                         while (isalnum (c))
1462                           {
1463                             if (p >= token_buffer + maxtoken - 3)
1464                               p = extend_token_buffer (p);
1465                             *p++ = c;
1466                             c = getc (finput);
1467                           }
1468                       }
1469                     break;
1470                   }
1471                 if (p >= token_buffer + maxtoken - 3)
1472                   p = extend_token_buffer (p);
1473                 *p++ = c;
1474                 c = getc (finput);
1475               }
1476
1477             ungetc (c, finput);
1478
1479             /* If the constant is not long long and it won't fit in an
1480                unsigned long, or if the constant is long long and won't fit
1481                in an unsigned long long, then warn that the constant is out
1482                of range.  */
1483
1484             /* ??? This assumes that long long and long integer types are
1485                a multiple of 8 bits.  This better than the original code
1486                though which assumed that long was exactly 32 bits and long
1487                long was exactly 64 bits.  */
1488
1489             if (spec_long_long)
1490               bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1491             else
1492               bytes = TYPE_PRECISION (long_integer_type_node) / 8;
1493
1494             warn = overflow;
1495             for (i = bytes; i < TOTAL_PARTS; i++)
1496               if (parts[i])
1497                 warn = 1;
1498             if (warn)
1499               pedwarn ("integer constant out of range");
1500
1501             /* This is simplified by the fact that our constant
1502                is always positive.  */
1503
1504             high = low = 0;
1505
1506             for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1507               {
1508                 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1509                                                     / HOST_BITS_PER_CHAR)]
1510                          << (i * HOST_BITS_PER_CHAR));
1511                 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1512               }
1513
1514             yylval.ttype = build_int_2 (low, high);
1515
1516             /* If warn_traditional, calculate both the ANSI type and the
1517                traditional type, then see if they disagree.
1518                Otherwise, calculate only the type for the dialect in use.  */
1519             if (warn_traditional || flag_traditional)
1520               {
1521                 /* Calculate the traditional type.  */
1522                 /* Traditionally, any constant is signed;
1523                    but if unsigned is specified explicitly, obey that.
1524                    Use the smallest size with the right number of bits,
1525                    except for one special case with decimal constants.  */
1526                 if (! spec_long && base != 10
1527                     && int_fits_type_p (yylval.ttype, unsigned_type_node))
1528                   traditional_type = (spec_unsigned ? unsigned_type_node
1529                                       : integer_type_node);
1530                 /* A decimal constant must be long
1531                    if it does not fit in type int.
1532                    I think this is independent of whether
1533                    the constant is signed.  */
1534                 else if (! spec_long && base == 10
1535                          && int_fits_type_p (yylval.ttype, integer_type_node))
1536                   traditional_type = (spec_unsigned ? unsigned_type_node
1537                                       : integer_type_node);
1538                 else if (! spec_long_long)
1539                   traditional_type = (spec_unsigned ? long_unsigned_type_node
1540                                       : long_integer_type_node);
1541                 else
1542                   traditional_type = (spec_unsigned
1543                                       ? long_long_unsigned_type_node
1544                                       : long_long_integer_type_node);
1545               }
1546             if (warn_traditional || ! flag_traditional)
1547               {
1548                 /* Calculate the ANSI type.  */
1549                 if (! spec_long && ! spec_unsigned
1550                     && int_fits_type_p (yylval.ttype, integer_type_node))
1551                   ansi_type = integer_type_node;
1552                 else if (! spec_long && (base != 10 || spec_unsigned)
1553                          && int_fits_type_p (yylval.ttype, unsigned_type_node))
1554                   ansi_type = unsigned_type_node;
1555                 else if (! spec_unsigned && !spec_long_long
1556                          && int_fits_type_p (yylval.ttype, long_integer_type_node))
1557                   ansi_type = long_integer_type_node;
1558                 else if (! spec_long_long)
1559                   ansi_type = long_unsigned_type_node;
1560                 else if (! spec_unsigned
1561                          /* Verify value does not overflow into sign bit.  */
1562                          && TREE_INT_CST_HIGH (yylval.ttype) >= 0
1563                          && int_fits_type_p (yylval.ttype,
1564                                              long_long_integer_type_node))
1565                   ansi_type = long_long_integer_type_node;
1566                 else
1567                   ansi_type = long_long_unsigned_type_node;
1568               }
1569
1570             type = flag_traditional ? traditional_type : ansi_type;
1571
1572             if (warn_traditional && traditional_type != ansi_type)
1573               {
1574                 if (TYPE_PRECISION (traditional_type)
1575                     != TYPE_PRECISION (ansi_type))
1576                   warning ("width of integer constant changes with -traditional");
1577                 else if (TREE_UNSIGNED (traditional_type)
1578                          != TREE_UNSIGNED (ansi_type))
1579                   warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1580                 else
1581                   warning ("width of integer constant may change on other systems with -traditional");
1582               }
1583
1584             if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
1585                 && !warn)
1586               pedwarn ("integer constant out of range");
1587
1588             if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1589               warning ("integer constant is so large that it is unsigned");
1590
1591             if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1592               /* The traditional constant 0x80000000 is signed
1593                  but doesn't fit in the range of int.
1594                  This will change it to -0x80000000, which does fit.  */
1595               {
1596                 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1597                 yylval.ttype = convert (type, yylval.ttype);
1598               }
1599             else
1600               TREE_TYPE (yylval.ttype) = type;
1601
1602             *p = 0;
1603           }
1604
1605         value = CONSTANT; break;
1606       }
1607
1608     case '\'':
1609     char_constant:
1610       {
1611         register int result = 0;
1612         register int num_chars = 0;
1613         unsigned width = TYPE_PRECISION (char_type_node);
1614         int max_chars;
1615
1616         if (wide_flag)
1617           {
1618             width = WCHAR_TYPE_SIZE;
1619 #ifdef MULTIBYTE_CHARS
1620             max_chars = MB_CUR_MAX;
1621 #else
1622             max_chars = 1;
1623 #endif
1624           }
1625         else
1626           max_chars = TYPE_PRECISION (integer_type_node) / width;
1627
1628         while (1)
1629           {
1630           tryagain:
1631
1632             c = getc (finput);
1633
1634             if (c == '\'' || c == EOF)
1635               break;
1636
1637             if (c == '\\')
1638               {
1639                 c = readescape ();
1640                 if (c < 0)
1641                   goto tryagain;
1642                 if (width < HOST_BITS_PER_INT
1643                     && (unsigned) c >= (1 << width))
1644                   pedwarn ("escape sequence out of range for character");
1645               }
1646             else if (c == '\n')
1647               {
1648                 if (pedantic)
1649                   pedwarn ("ANSI C forbids newline in character constant");
1650                 lineno++;
1651               }
1652
1653             num_chars++;
1654             if (num_chars > maxtoken - 4)
1655               extend_token_buffer (token_buffer);
1656
1657             token_buffer[num_chars] = c;
1658
1659             /* Merge character into result; ignore excess chars.  */
1660             if (num_chars < max_chars + 1)
1661               {
1662                 if (width < HOST_BITS_PER_INT)
1663                   result = (result << width) | (c & ((1 << width) - 1));
1664                 else
1665                   result = c;
1666               }
1667           }
1668
1669         token_buffer[num_chars + 1] = '\'';
1670         token_buffer[num_chars + 2] = 0;
1671
1672         if (c != '\'')
1673           error ("malformatted character constant");
1674         else if (num_chars == 0)
1675           error ("empty character constant");
1676         else if (num_chars > max_chars)
1677           {
1678             num_chars = max_chars;
1679             error ("character constant too long");
1680           }
1681         else if (num_chars != 1 && ! flag_traditional)
1682           warning ("multi-character character constant");
1683
1684         /* If char type is signed, sign-extend the constant.  */
1685         if (! wide_flag)
1686           {
1687             int num_bits = num_chars * width;
1688             if (TREE_UNSIGNED (char_type_node)
1689                 || ((result >> (num_bits - 1)) & 1) == 0)
1690               yylval.ttype
1691                 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
1692                                          >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1693                                0);
1694             else
1695               yylval.ttype
1696                 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
1697                                           >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1698                                -1);
1699           }
1700         else
1701           {
1702 #ifdef MULTIBYTE_CHARS
1703             /* Set the initial shift state and convert the next sequence.  */
1704             result = 0;
1705             /* In all locales L'\0' is zero and mbtowc will return zero,
1706                so don't use it.  */
1707             if (num_chars > 1
1708                 || (num_chars == 1 && token_buffer[1] != '\0'))
1709               {
1710                 wchar_t wc;
1711                 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1712                 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1713                   result = wc;
1714                 else
1715                   warning ("Ignoring invalid multibyte character");
1716               }
1717 #endif
1718             yylval.ttype = build_int_2 (result, 0);
1719           }
1720
1721         TREE_TYPE (yylval.ttype) = integer_type_node;
1722         value = CONSTANT;
1723         break;
1724       }
1725
1726     case '"':
1727     string_constant:
1728       {
1729         c = getc (finput);
1730         p = token_buffer + 1;
1731
1732         while (c != '"' && c >= 0)
1733           {
1734             /* ignore_escape_flag is set for reading the filename in #line.  */
1735             if (!ignore_escape_flag && c == '\\')
1736               {
1737                 c = readescape ();
1738                 if (c < 0)
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 }