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       pedwarn ("non-ANSI-standard escape sequence, `\\E'");
 910       return 033;
 911
 912     case '?':
 913       return c;
 914
 915       /* `\(', etc, are used at beginning of line to avoid confusing Emacs.  */
 916     case '(':
 917     case '{':
 918     case '[':
 919       if (pedantic)
 920         pedwarn ("non-ANSI escape sequence `\\%c'", c);
 921       return c;
 922     }
 923   if (c >= 040 && c < 0177)
 924     pedwarn ("unknown escape sequence `\\%c'", c);
 925   else
 926     pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
 927   return c;
 928 }
 929 \f
 930 void
 931 yyerror (string)
 932      char *string;
 933 {
 934   char buf[200];
 935
 936   strcpy (buf, string);
 937
 938   /* We can't print string and character constants well
 939      because the token_buffer contains the result of processing escapes.  */
 940   if (end_of_file)
 941     strcat (buf, " at end of input");
 942   else if (token_buffer[0] == 0)
 943     strcat (buf, " at null character");
 944   else if (token_buffer[0] == '"')
 945     strcat (buf, " before string constant");
 946   else if (token_buffer[0] == '\'')
 947     strcat (buf, " before character constant");
 948   else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
 949     sprintf (buf + strlen (buf), " before character 0%o",
 950              (unsigned char) token_buffer[0]);
 951   else
 952     strcat (buf, " before `%s'");
 953
 954   error (buf, token_buffer);
 955 }
 956
 957 #if 0
 958
 959 struct try_type
 960 {
 961   tree *node_var;
 962   char unsigned_flag;
 963   char long_flag;
 964   char long_long_flag;
 965 };
 966
 967 struct try_type type_sequence[] =
 968 {
 969   { &integer_type_node, 0, 0, 0},
 970   { &unsigned_type_node, 1, 0, 0},
 971   { &long_integer_type_node, 0, 1, 0},
 972   { &long_unsigned_type_node, 1, 1, 0},
 973   { &long_long_integer_type_node, 0, 1, 1},
 974   { &long_long_unsigned_type_node, 1, 1, 1}
 975 };
 976 #endif /* 0 */
 977 \f
 978 int
 979 yylex ()
 980 {
 981   register int c;
 982   register char *p;
 983   register int value;
 984   int wide_flag = 0;
 985
 986   if (nextchar >= 0)
 987     c = nextchar, nextchar = -1;
 988   else
 989     c = getc (finput);
 990
 991   /* Effectively do c = skip_white_space (c)
 992      but do it faster in the usual cases.  */
 993   while (1)
 994     switch (c)
 995       {
 996       case ' ':
 997       case '\t':
 998       case '\f':
 999       case '\v':
1000       case '\b':
1001         c = getc (finput);
1002         break;
1003
1004       case '\r':
1005         /* Call skip_white_space so we can warn if appropriate.  */
1006
1007       case '\n':
1008       case '/':
1009       case '\\':
1010         c = skip_white_space (c);
1011       default:
1012         goto found_nonwhite;
1013       }
1014  found_nonwhite:
1015
1016   token_buffer[0] = c;
1017   token_buffer[1] = 0;
1018
1019 /*  yylloc.first_line = lineno; */
1020
1021   switch (c)
1022     {
1023     case EOF:
1024       end_of_file = 1;
1025       token_buffer[0] = 0;
1026       value = ENDFILE;
1027       break;
1028
1029     case '$':
1030       if (dollars_in_ident)
1031         goto letter;
1032       return '$';
1033
1034     case 'L':
1035       /* Capital L may start a wide-string or wide-character constant.  */
1036       {
1037         register int c = getc (finput);
1038         if (c == '\'')
1039           {
1040             wide_flag = 1;
1041             goto char_constant;
1042           }
1043         if (c == '"')
1044           {
1045             wide_flag = 1;
1046             goto string_constant;
1047           }
1048         ungetc (c, finput);
1049       }
1050       goto letter;
1051
1052     case '@':
1053       if (!doing_objc_thang)
1054         {
1055           value = c;
1056           break;
1057         }
1058       p = token_buffer;
1059       *p++ = '@';
1060       c = getc (finput);
1061       while (isalnum (c) || c == '_')
1062         {
1063           if (p >= token_buffer + maxtoken)
1064             p = extend_token_buffer (p);
1065
1066           *p++ = c;
1067           c = getc (finput);
1068         }
1069
1070       *p = 0;
1071       nextchar = c;
1072       value = recognize_objc_keyword (token_buffer + 1);
1073       if (value != 0)
1074         break;
1075       error ("invalid Objective C keyword `%s'", token_buffer);
1076       /* Cause a syntax error--1 is not a valid token type.  */
1077       value = 1;
1078       break;
1079
1080     case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
1081     case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
1082     case 'K':             case 'M':  case 'N':  case 'O':
1083     case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
1084     case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
1085     case 'Z':
1086     case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
1087     case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
1088     case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
1089     case 'p':  case 'q':  case 'r':  case 's':  case 't':
1090     case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
1091     case 'z':
1092     case '_':
1093     letter:
1094       p = token_buffer;
1095       while (isalnum (c) || c == '_' || c == '$' || c == '@')
1096         {
1097           if (p >= token_buffer + maxtoken)
1098             p = extend_token_buffer (p);
1099           if (c == '$' && ! dollars_in_ident)
1100             break;
1101
1102           *p++ = c;
1103           c = getc (finput);
1104         }
1105
1106       *p = 0;
1107       nextchar = c;
1108
1109       value = IDENTIFIER;
1110       yylval.itype = 0;
1111
1112       /* Try to recognize a keyword.  Uses minimum-perfect hash function */
1113
1114       {
1115         register struct resword *ptr;
1116
1117         if (ptr = is_reserved_word (token_buffer, p - token_buffer))
1118           {
1119             if (ptr->rid)
1120               yylval.ttype = ridpointers[(int) ptr->rid];
1121             value = (int) ptr->token;
1122
1123             /* Even if we decided to recognize asm, still perhaps warn.  */
1124             if (pedantic
1125                 && (value == ASM_KEYWORD || value == TYPEOF
1126                     || ptr->rid == RID_INLINE)
1127                 && token_buffer[0] != '_')
1128               pedwarn ("ANSI does not permit the keyword `%s'",
1129                        token_buffer);
1130           }
1131       }
1132
1133       /* If we did not find a keyword, look for an identifier
1134          (or a typename).  */
1135
1136       if (value == IDENTIFIER)
1137         {
1138           yylval.ttype = get_identifier (token_buffer);
1139           lastiddecl = lookup_name (yylval.ttype);
1140
1141           if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL)
1142             value = TYPENAME;
1143           /* A user-invisible read-only initialized variable
1144              should be replaced by its value.
1145              We handle only strings since that's the only case used in C.  */
1146           else if (lastiddecl != 0 && TREE_CODE (lastiddecl) == VAR_DECL
1147                    && DECL_IGNORED_P (lastiddecl)
1148                    && TREE_READONLY (lastiddecl)
1149                    && DECL_INITIAL (lastiddecl) != 0
1150                    && TREE_CODE (DECL_INITIAL (lastiddecl)) == STRING_CST)
1151             {
1152               yylval.ttype = DECL_INITIAL (lastiddecl);
1153               value = STRING;
1154             }
1155           else if (doing_objc_thang)
1156             {
1157               tree objc_interface_decl = lookup_interface (yylval.ttype);
1158
1159               if (objc_interface_decl)
1160                 {
1161                   value = CLASSNAME;
1162                   yylval.ttype = objc_interface_decl;
1163                 }
1164             }
1165         }
1166
1167       break;
1168
1169     case '0':  case '1':  case '2':  case '3':  case '4':
1170     case '5':  case '6':  case '7':  case '8':  case '9':
1171     case '.':
1172       {
1173         int base = 10;
1174         int count = 0;
1175         int largest_digit = 0;
1176         int numdigits = 0;
1177         /* for multi-precision arithmetic,
1178            we actually store only HOST_BITS_PER_CHAR bits in each part.
1179            The number of parts is chosen so as to be sufficient to hold
1180            the enough bits to fit into the two HOST_WIDE_INTs that contain
1181            the integer value (this is always at least as many bits as are
1182            in a target `long long' value, but may be wider).  */
1183 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
1184         int parts[TOTAL_PARTS];
1185         int overflow = 0;
1186
1187         enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
1188           = NOT_FLOAT;
1189
1190         for (count = 0; count < TOTAL_PARTS; count++)
1191           parts[count] = 0;
1192
1193         p = token_buffer;
1194         *p++ = c;
1195
1196         if (c == '0')
1197           {
1198             *p++ = (c = getc (finput));
1199             if ((c == 'x') || (c == 'X'))
1200               {
1201                 base = 16;
1202                 *p++ = (c = getc (finput));
1203               }
1204             /* Leading 0 forces octal unless the 0 is the only digit.  */
1205             else if (c >= '0' && c <= '9')
1206               {
1207                 base = 8;
1208                 numdigits++;
1209               }
1210             else
1211               numdigits++;
1212           }
1213
1214         /* Read all the digits-and-decimal-points.  */
1215
1216         while (c == '.'
1217                || (isalnum (c) && (c != 'l') && (c != 'L')
1218                    && (c != 'u') && (c != 'U')
1219                    && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
1220           {
1221             if (c == '.')
1222               {
1223                 if (base == 16)
1224                   error ("floating constant may not be in radix 16");
1225                 if (floatflag == AFTER_POINT)
1226                   {
1227                     error ("malformed floating constant");
1228                     floatflag = TOO_MANY_POINTS;
1229                   }
1230                 else
1231                   floatflag = AFTER_POINT;
1232
1233                 base = 10;
1234                 *p++ = c = getc (finput);
1235                 /* Accept '.' as the start of a floating-point number
1236                    only when it is followed by a digit.
1237                    Otherwise, unread the following non-digit
1238                    and use the '.' as a structural token.  */
1239                 if (p == token_buffer + 2 && !isdigit (c))
1240                   {
1241                     if (c == '.')
1242                       {
1243                         c = getc (finput);
1244                         if (c == '.')
1245                           {
1246                             *p++ = c;
1247                             *p = 0;
1248                             return ELLIPSIS;
1249                           }
1250                         error ("parse error at `..'");
1251                       }
1252                     ungetc (c, finput);
1253                     token_buffer[1] = 0;
1254                     value = '.';
1255                     goto done;
1256                   }
1257               }
1258             else
1259               {
1260                 /* It is not a decimal point.
1261                    It should be a digit (perhaps a hex digit).  */
1262
1263                 if (isdigit (c))
1264                   {
1265                     c = c - '0';
1266                   }
1267                 else if (base <= 10)
1268                   {
1269                     if ((c&~040) == 'E')
1270                       {
1271                         base = 10;
1272                         floatflag = AFTER_POINT;
1273                         break;   /* start of exponent */
1274                       }
1275                     error ("nondigits in number and not hexadecimal");
1276                     c = 0;
1277                   }
1278                 else if (c >= 'a')
1279                   {
1280                     c = c - 'a' + 10;
1281                   }
1282                 else
1283                   {
1284                     c = c - 'A' + 10;
1285                   }
1286                 if (c >= largest_digit)
1287                   largest_digit = c;
1288                 numdigits++;
1289
1290                 for (count = 0; count < TOTAL_PARTS; count++)
1291                   {
1292                     parts[count] *= base;
1293                     if (count)
1294                       {
1295                         parts[count]
1296                           += (parts[count-1] >> HOST_BITS_PER_CHAR);
1297                         parts[count-1]
1298                           &= (1 << HOST_BITS_PER_CHAR) - 1;
1299                       }
1300                     else
1301                       parts[0] += c;
1302                   }
1303
1304                 /* If the extra highest-order part ever gets anything in it,
1305                    the number is certainly too big.  */
1306                 if (parts[TOTAL_PARTS - 1] != 0)
1307                   overflow = 1;
1308
1309                 if (p >= token_buffer + maxtoken - 3)
1310                   p = extend_token_buffer (p);
1311                 *p++ = (c = getc (finput));
1312               }
1313           }
1314
1315         if (numdigits == 0)
1316           error ("numeric constant with no digits");
1317
1318         if (largest_digit >= base)
1319           error ("numeric constant contains digits beyond the radix");
1320
1321         /* Remove terminating char from the token buffer and delimit the string */
1322         *--p = 0;
1323
1324         if (floatflag != NOT_FLOAT)
1325           {
1326             tree type = double_type_node;
1327             int garbage_chars = 0, exceeds_double = 0;
1328             REAL_VALUE_TYPE value;
1329             jmp_buf handler;
1330
1331             /* Read explicit exponent if any, and put it in tokenbuf.  */
1332
1333             if ((c == 'e') || (c == 'E'))
1334               {
1335                 if (p >= token_buffer + maxtoken - 3)
1336                   p = extend_token_buffer (p);
1337                 *p++ = c;
1338                 c = getc (finput);
1339                 if ((c == '+') || (c == '-'))
1340                   {
1341                     *p++ = c;
1342                     c = getc (finput);
1343                   }
1344                 if (! isdigit (c))
1345                   error ("floating constant exponent has no digits");
1346                 while (isdigit (c))
1347                   {
1348                     if (p >= token_buffer + maxtoken - 3)
1349                       p = extend_token_buffer (p);
1350                     *p++ = c;
1351                     c = getc (finput);
1352                   }
1353               }
1354
1355             *p = 0;
1356             errno = 0;
1357
1358             /* Convert string to a double, checking for overflow.  */
1359             if (setjmp (handler))
1360               {
1361                 error ("floating constant out of range");
1362                 value = dconst0;
1363               }
1364             else
1365               {
1366                 set_float_handler (handler);
1367                 value = REAL_VALUE_ATOF (token_buffer);
1368                 set_float_handler (NULL_PTR);
1369               }
1370 #ifdef ERANGE
1371             if (errno == ERANGE && !flag_traditional && pedantic)
1372               {
1373                 /* ERANGE is also reported for underflow,
1374                    so test the value to distinguish overflow from that.  */
1375                 if (REAL_VALUES_LESS (dconst1, value)
1376                     || REAL_VALUES_LESS (value, dconstm1))
1377                   {
1378                     pedwarn ("floating point number exceeds range of `double'");
1379                     exceeds_double = 1;
1380                   }
1381               }
1382 #endif
1383
1384             /* Read the suffixes to choose a data type.  */
1385             switch (c)
1386               {
1387               case 'f': case 'F':
1388                 type = float_type_node;
1389                 value = REAL_VALUE_TRUNCATE (TYPE_MODE (type), value);
1390                 if (REAL_VALUE_ISINF (value) && ! exceeds_double && pedantic)
1391                   pedwarn ("floating point number exceeds range of `float'");
1392                 garbage_chars = -1;
1393                 break;
1394
1395               case 'l': case 'L':
1396                 type = long_double_type_node;
1397                 garbage_chars = -1;
1398                 break;
1399               }
1400             /* Note: garbage_chars is -1 if first char is *not* garbage.  */
1401             while (isalnum (c))
1402               {
1403                 if (p >= token_buffer + maxtoken - 3)
1404                   p = extend_token_buffer (p);
1405                 *p++ = c;
1406                 c = getc (finput);
1407                 garbage_chars++;
1408               }
1409             if (garbage_chars > 0)
1410               error ("garbage at end of number");
1411
1412             /* Create a node with determined type and value.  */
1413             yylval.ttype = build_real (type, value);
1414
1415             ungetc (c, finput);
1416             *p = 0;
1417           }
1418         else
1419           {
1420             tree traditional_type, ansi_type, type;
1421             HOST_WIDE_INT high, low;
1422             int spec_unsigned = 0;
1423             int spec_long = 0;
1424             int spec_long_long = 0;
1425             int bytes, warn, i;
1426
1427             while (1)
1428               {
1429                 if (c == 'u' || c == 'U')
1430                   {
1431                     if (spec_unsigned)
1432                       error ("two `u's in integer constant");
1433                     spec_unsigned = 1;
1434                   }
1435                 else if (c == 'l' || c == 'L')
1436                   {
1437                     if (spec_long)
1438                       {
1439                         if (spec_long_long)
1440                           error ("three `l's in integer constant");
1441                         else if (pedantic)
1442                           pedwarn ("ANSI C forbids long long integer constants");
1443                         spec_long_long = 1;
1444                       }
1445                     spec_long = 1;
1446                   }
1447                 else
1448                   {
1449                     if (isalnum (c))
1450                       {
1451                         error ("garbage at end of number");
1452                         while (isalnum (c))
1453                           {
1454                             if (p >= token_buffer + maxtoken - 3)
1455                               p = extend_token_buffer (p);
1456                             *p++ = c;
1457                             c = getc (finput);
1458                           }
1459                       }
1460                     break;
1461                   }
1462                 if (p >= token_buffer + maxtoken - 3)
1463                   p = extend_token_buffer (p);
1464                 *p++ = c;
1465                 c = getc (finput);
1466               }
1467
1468             ungetc (c, finput);
1469
1470             /* If the constant is not long long and it won't fit in an
1471                unsigned long, or if the constant is long long and won't fit
1472                in an unsigned long long, then warn that the constant is out
1473                of range.  */
1474
1475             /* ??? This assumes that long long and long integer types are
1476                a multiple of 8 bits.  This better than the original code
1477                though which assumed that long was exactly 32 bits and long
1478                long was exactly 64 bits.  */
1479
1480             if (spec_long_long)
1481               bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1482             else
1483               bytes = TYPE_PRECISION (long_integer_type_node) / 8;
1484
1485             warn = overflow;
1486             for (i = bytes; i < TOTAL_PARTS; i++)
1487               if (parts[i])
1488                 warn = 1;
1489             if (warn)
1490               pedwarn ("integer constant out of range");
1491
1492             /* This is simplified by the fact that our constant
1493                is always positive.  */
1494
1495             high = low = 0;
1496
1497             for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1498               {
1499                 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1500                                                     / HOST_BITS_PER_CHAR)]
1501                          << (i * HOST_BITS_PER_CHAR));
1502                 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1503               }
1504
1505             yylval.ttype = build_int_2 (low, high);
1506             TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1507
1508             /* If warn_traditional, calculate both the ANSI type and the
1509                traditional type, then see if they disagree.
1510                Otherwise, calculate only the type for the dialect in use.  */
1511             if (warn_traditional || flag_traditional)
1512               {
1513                 /* Calculate the traditional type.  */
1514                 /* Traditionally, any constant is signed;
1515                    but if unsigned is specified explicitly, obey that.
1516                    Use the smallest size with the right number of bits,
1517                    except for one special case with decimal constants.  */
1518                 if (! spec_long && base != 10
1519                     && int_fits_type_p (yylval.ttype, unsigned_type_node))
1520                   traditional_type = (spec_unsigned ? unsigned_type_node
1521                                       : integer_type_node);
1522                 /* A decimal constant must be long
1523                    if it does not fit in type int.
1524                    I think this is independent of whether
1525                    the constant is signed.  */
1526                 else if (! spec_long && base == 10
1527                          && int_fits_type_p (yylval.ttype, integer_type_node))
1528                   traditional_type = (spec_unsigned ? unsigned_type_node
1529                                       : integer_type_node);
1530                 else if (! spec_long_long)
1531                   traditional_type = (spec_unsigned ? long_unsigned_type_node
1532                                       : long_integer_type_node);
1533                 else
1534                   traditional_type = (spec_unsigned
1535                                       ? long_long_unsigned_type_node
1536                                       : long_long_integer_type_node);
1537               }
1538             if (warn_traditional || ! flag_traditional)
1539               {
1540                 /* Calculate the ANSI type.  */
1541                 if (! spec_long && ! spec_unsigned
1542                     && int_fits_type_p (yylval.ttype, integer_type_node))
1543                   ansi_type = integer_type_node;
1544                 else if (! spec_long && (base != 10 || spec_unsigned)
1545                          && int_fits_type_p (yylval.ttype, unsigned_type_node))
1546                   ansi_type = unsigned_type_node;
1547                 else if (! spec_unsigned && !spec_long_long
1548                          && int_fits_type_p (yylval.ttype, long_integer_type_node))
1549                   ansi_type = long_integer_type_node;
1550                 else if (! spec_long_long)
1551                   ansi_type = long_unsigned_type_node;
1552                 else if (! spec_unsigned
1553                          /* Verify value does not overflow into sign bit.  */
1554                          && TREE_INT_CST_HIGH (yylval.ttype) >= 0
1555                          && int_fits_type_p (yylval.ttype,
1556                                              long_long_integer_type_node))
1557                   ansi_type = long_long_integer_type_node;
1558                 else
1559                   ansi_type = long_long_unsigned_type_node;
1560               }
1561
1562             type = flag_traditional ? traditional_type : ansi_type;
1563
1564             if (warn_traditional && traditional_type != ansi_type)
1565               {
1566                 if (TYPE_PRECISION (traditional_type)
1567                     != TYPE_PRECISION (ansi_type))
1568                   warning ("width of integer constant changes with -traditional");
1569                 else if (TREE_UNSIGNED (traditional_type)
1570                          != TREE_UNSIGNED (ansi_type))
1571                   warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1572                 else
1573                   warning ("width of integer constant may change on other systems with -traditional");
1574               }
1575
1576             if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
1577                 && !warn)
1578               pedwarn ("integer constant out of range");
1579
1580             if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1581               warning ("integer constant is so large that it is unsigned");
1582
1583             if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1584               /* The traditional constant 0x80000000 is signed
1585                  but doesn't fit in the range of int.
1586                  This will change it to -0x80000000, which does fit.  */
1587               {
1588                 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1589                 yylval.ttype = convert (type, yylval.ttype);
1590               }
1591             else
1592               TREE_TYPE (yylval.ttype) = type;
1593
1594             *p = 0;
1595           }
1596
1597         value = CONSTANT; break;
1598       }
1599
1600     case '\'':
1601     char_constant:
1602       {
1603         register int result = 0;
1604         register int num_chars = 0;
1605         unsigned width = TYPE_PRECISION (char_type_node);
1606         int max_chars;
1607
1608         if (wide_flag)
1609           {
1610             width = WCHAR_TYPE_SIZE;
1611 #ifdef MULTIBYTE_CHARS
1612             max_chars = MB_CUR_MAX;
1613 #else
1614             max_chars = 1;
1615 #endif
1616           }
1617         else
1618           max_chars = TYPE_PRECISION (integer_type_node) / width;
1619
1620         while (1)
1621           {
1622           tryagain:
1623
1624             c = getc (finput);
1625
1626             if (c == '\'' || c == EOF)
1627               break;
1628
1629             if (c == '\\')
1630               {
1631                 int ignore = 0;
1632                 c = readescape (&ignore);
1633                 if (ignore)
1634                   goto tryagain;
1635                 if (width < HOST_BITS_PER_INT
1636                     && (unsigned) c >= (1 << width))
1637                   pedwarn ("escape sequence out of range for character");
1638               }
1639             else if (c == '\n')
1640               {
1641                 if (pedantic)
1642                   pedwarn ("ANSI C forbids newline in character constant");
1643                 lineno++;
1644               }
1645
1646             num_chars++;
1647             if (num_chars > maxtoken - 4)
1648               extend_token_buffer (token_buffer);
1649
1650             token_buffer[num_chars] = c;
1651
1652             /* Merge character into result; ignore excess chars.  */
1653             if (num_chars < max_chars + 1)
1654               {
1655                 if (width < HOST_BITS_PER_INT)
1656                   result = (result << width) | (c & ((1 << width) - 1));
1657                 else
1658                   result = c;
1659               }
1660           }
1661
1662         token_buffer[num_chars + 1] = '\'';
1663         token_buffer[num_chars + 2] = 0;
1664
1665         if (c != '\'')
1666           error ("malformatted character constant");
1667         else if (num_chars == 0)
1668           error ("empty character constant");
1669         else if (num_chars > max_chars)
1670           {
1671             num_chars = max_chars;
1672             error ("character constant too long");
1673           }
1674         else if (num_chars != 1 && ! flag_traditional)
1675           warning ("multi-character character constant");
1676
1677         /* If char type is signed, sign-extend the constant.  */
1678         if (! wide_flag)
1679           {
1680             int num_bits = num_chars * width;
1681             if (TREE_UNSIGNED (char_type_node)
1682                 || ((result >> (num_bits - 1)) & 1) == 0)
1683               yylval.ttype
1684                 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
1685                                          >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1686                                0);
1687             else
1688               yylval.ttype
1689                 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
1690                                           >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1691                                -1);
1692           }
1693         else
1694           {
1695 #ifdef MULTIBYTE_CHARS
1696             /* Set the initial shift state and convert the next sequence.  */
1697             result = 0;
1698             /* In all locales L'\0' is zero and mbtowc will return zero,
1699                so don't use it.  */
1700             if (num_chars > 1
1701                 || (num_chars == 1 && token_buffer[1] != '\0'))
1702               {
1703                 wchar_t wc;
1704                 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1705                 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1706                   result = wc;
1707                 else
1708                   warning ("Ignoring invalid multibyte character");
1709               }
1710 #endif
1711             yylval.ttype = build_int_2 (result, 0);
1712           }
1713
1714         TREE_TYPE (yylval.ttype) = integer_type_node;
1715         value = CONSTANT;
1716         break;
1717       }
1718
1719     case '"':
1720     string_constant:
1721       {
1722         c = getc (finput);
1723         p = token_buffer + 1;
1724
1725         while (c != '"' && c >= 0)
1726           {
1727             /* ignore_escape_flag is set for reading the filename in #line.  */
1728             if (!ignore_escape_flag && c == '\\')
1729               {
1730                 int ignore = 0;
1731                 c = readescape (&ignore);
1732                 if (ignore)
1733                   goto skipnewline;
1734                 if (!wide_flag
1735                     && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
1736                     && c >= (1 << TYPE_PRECISION (char_type_node)))
1737                   pedwarn ("escape sequence out of range for character");
1738               }
1739             else if (c == '\n')
1740               {
1741                 if (pedantic)
1742                   pedwarn ("ANSI C forbids newline in string constant");
1743                 lineno++;
1744               }
1745
1746             if (p == token_buffer + maxtoken)
1747               p = extend_token_buffer (p);
1748             *p++ = c;
1749
1750           skipnewline:
1751             c = getc (finput);
1752           }
1753         *p = 0;
1754
1755         /* We have read the entire constant.
1756            Construct a STRING_CST for the result.  */
1757
1758         if (wide_flag)
1759           {
1760             /* If this is a L"..." wide-string, convert the multibyte string
1761                to a wide character string.  */
1762             char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
1763             int len;
1764
1765 #ifdef MULTIBYTE_CHARS
1766             len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
1767             if ((unsigned) len >= (p - token_buffer))
1768               {
1769                 warning ("Ignoring invalid multibyte string");
1770                 len = 0;
1771               }
1772             bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
1773 #else
1774             {
1775               union { long l; char c[sizeof (long)]; } u;
1776               int big_endian;
1777               char *wp, *cp;
1778
1779               /* Determine whether host is little or big endian.  */
1780               u.l = 1;
1781               big_endian = u.c[sizeof (long) - 1];
1782               wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
1783
1784               bzero (widep, (p - token_buffer) * WCHAR_BYTES);
1785               for (cp = token_buffer + 1; cp < p; cp++)
1786                 *wp = *cp, wp += WCHAR_BYTES;
1787               len = p - token_buffer - 1;
1788             }
1789 #endif
1790             yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
1791             TREE_TYPE (yylval.ttype) = wchar_array_type_node;
1792           }
1793         else
1794           {
1795             yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
1796             TREE_TYPE (yylval.ttype) = char_array_type_node;
1797           }
1798
1799         *p++ = '"';
1800         *p = 0;
1801
1802         value = STRING; break;
1803       }
1804
1805     case '+':
1806     case '-':
1807     case '&':
1808     case '|':
1809     case '<':
1810     case '>':
1811     case '*':
1812     case '/':
1813     case '%':
1814     case '^':
1815     case '!':
1816     case '=':
1817       {
1818         register int c1;
1819
1820       combine:
1821
1822         switch (c)
1823           {
1824           case '+':
1825             yylval.code = PLUS_EXPR; break;
1826           case '-':
1827             yylval.code = MINUS_EXPR; break;
1828           case '&':
1829             yylval.code = BIT_AND_EXPR; break;
1830           case '|':
1831             yylval.code = BIT_IOR_EXPR; break;
1832           case '*':
1833             yylval.code = MULT_EXPR; break;
1834           case '/':
1835             yylval.code = TRUNC_DIV_EXPR; break;
1836           case '%':
1837             yylval.code = TRUNC_MOD_EXPR; break;
1838           case '^':
1839             yylval.code = BIT_XOR_EXPR; break;
1840           case LSHIFT:
1841             yylval.code = LSHIFT_EXPR; break;
1842           case RSHIFT:
1843             yylval.code = RSHIFT_EXPR; break;
1844           case '<':
1845             yylval.code = LT_EXPR; break;
1846           case '>':
1847             yylval.code = GT_EXPR; break;
1848           }
1849
1850         token_buffer[1] = c1 = getc (finput);
1851         token_buffer[2] = 0;
1852
1853         if (c1 == '=')
1854           {
1855             switch (c)
1856               {
1857               case '<':
1858                 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
1859               case '>':
1860                 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
1861               case '!':
1862                 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
1863               case '=':
1864                 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
1865               }
1866             value = ASSIGN; goto done;
1867           }
1868         else if (c == c1)
1869           switch (c)
1870             {
1871             case '+':
1872               value = PLUSPLUS; goto done;
1873             case '-':
1874               value = MINUSMINUS; goto done;
1875             case '&':
1876               value = ANDAND; goto done;
1877             case '|':
1878               value = OROR; goto done;
1879             case '<':
1880               c = LSHIFT;
1881               goto combine;
1882             case '>':
1883               c = RSHIFT;
1884               goto combine;
1885             }
1886         else if ((c == '-') && (c1 == '>'))
1887           { value = POINTSAT; goto done; }
1888         ungetc (c1, finput);
1889         token_buffer[1] = 0;
1890
1891         if ((c == '<') || (c == '>'))
1892           value = ARITHCOMPARE;
1893         else value = c;
1894         goto done;
1895       }
1896
1897     case 0:
1898       /* Don't make yyparse think this is eof.  */
1899       value = 1;
1900       break;
1901
1902     default:
1903       value = c;
1904     }
1905
1906 done:
1907 /*  yylloc.last_line = lineno; */
1908
1909   return value;
1910 }
1911
1912 /* Sets the value of the 'yydebug' variable to VALUE.
1913    This is a function so we don't have to have YYDEBUG defined
1914    in order to build the compiler.  */
1915
1916 void
1917 set_yydebug (value)
1918      int value;
1919 {
1920 #if YYDEBUG != 0
1921   yydebug = value;
1922 #else
1923   warning ("YYDEBUG not defined.");
1924 #endif
1925 }