gcc/c-lex.c

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