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 == 'e' || c == '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) || c == '.' || c == '_'
1415                    || (!flag_traditional && (c == '+' || c == '-')
1416                        && (p[-1] == 'e' || p[-1] == 'E')))
1417               {
1418                 if (p >= token_buffer + maxtoken - 3)
1419                   p = extend_token_buffer (p);
1420                 *p++ = c;
1421                 c = getc (finput);
1422                 garbage_chars++;
1423               }
1424             if (garbage_chars > 0)
1425               error ("garbage at end of number");
1426
1427             /* Create a node with determined type and value.  */
1428             yylval.ttype = build_real (type, value);
1429
1430             ungetc (c, finput);
1431             *p = 0;
1432           }
1433         else
1434           {
1435             tree traditional_type, ansi_type, type;
1436             HOST_WIDE_INT high, low;
1437             int spec_unsigned = 0;
1438             int spec_long = 0;
1439             int spec_long_long = 0;
1440             int bytes, warn, i;
1441
1442             while (1)
1443               {
1444                 if (c == 'u' || c == 'U')
1445                   {
1446                     if (spec_unsigned)
1447                       error ("two `u's in integer constant");
1448                     spec_unsigned = 1;
1449                   }
1450                 else if (c == 'l' || c == 'L')
1451                   {
1452                     if (spec_long)
1453                       {
1454                         if (spec_long_long)
1455                           error ("three `l's in integer constant");
1456                         else if (pedantic)
1457                           pedwarn ("ANSI C forbids long long integer constants");
1458                         spec_long_long = 1;
1459                       }
1460                     spec_long = 1;
1461                   }
1462                 else
1463                   {
1464                     if (isalnum (c) || c == '.' || c == '_'
1465                         || (!flag_traditional && (c == '+' || c == '-')
1466                             && (p[-1] == 'e' || p[-1] == 'E')))
1467                       {
1468                         error ("garbage at end of number");
1469                         while (isalnum (c) || c == '.' || c == '_'
1470                                || (!flag_traditional && (c == '+' || c == '-')
1471                                    && (p[-1] == 'e' || p[-1] == 'E')))
1472                           {
1473                             if (p >= token_buffer + maxtoken - 3)
1474                               p = extend_token_buffer (p);
1475                             *p++ = c;
1476                             c = getc (finput);
1477                           }
1478                       }
1479                     break;
1480                   }
1481                 if (p >= token_buffer + maxtoken - 3)
1482                   p = extend_token_buffer (p);
1483                 *p++ = c;
1484                 c = getc (finput);
1485               }
1486
1487             ungetc (c, finput);
1488
1489             /* If the constant is not long long and it won't fit in an
1490                unsigned long, or if the constant is long long and won't fit
1491                in an unsigned long long, then warn that the constant is out
1492                of range.  */
1493
1494             /* ??? This assumes that long long and long integer types are
1495                a multiple of 8 bits.  This better than the original code
1496                though which assumed that long was exactly 32 bits and long
1497                long was exactly 64 bits.  */
1498
1499             if (spec_long_long)
1500               bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
1501             else
1502               bytes = TYPE_PRECISION (long_integer_type_node) / 8;
1503
1504             warn = overflow;
1505             for (i = bytes; i < TOTAL_PARTS; i++)
1506               if (parts[i])
1507                 warn = 1;
1508             if (warn)
1509               pedwarn ("integer constant out of range");
1510
1511             /* This is simplified by the fact that our constant
1512                is always positive.  */
1513
1514             high = low = 0;
1515
1516             for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
1517               {
1518                 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
1519                                                     / HOST_BITS_PER_CHAR)]
1520                          << (i * HOST_BITS_PER_CHAR));
1521                 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
1522               }
1523
1524             yylval.ttype = build_int_2 (low, high);
1525             TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
1526
1527             /* If warn_traditional, calculate both the ANSI type and the
1528                traditional type, then see if they disagree.
1529                Otherwise, calculate only the type for the dialect in use.  */
1530             if (warn_traditional || flag_traditional)
1531               {
1532                 /* Calculate the traditional type.  */
1533                 /* Traditionally, any constant is signed;
1534                    but if unsigned is specified explicitly, obey that.
1535                    Use the smallest size with the right number of bits,
1536                    except for one special case with decimal constants.  */
1537                 if (! spec_long && base != 10
1538                     && int_fits_type_p (yylval.ttype, unsigned_type_node))
1539                   traditional_type = (spec_unsigned ? unsigned_type_node
1540                                       : integer_type_node);
1541                 /* A decimal constant must be long
1542                    if it does not fit in type int.
1543                    I think this is independent of whether
1544                    the constant is signed.  */
1545                 else if (! spec_long && base == 10
1546                          && int_fits_type_p (yylval.ttype, integer_type_node))
1547                   traditional_type = (spec_unsigned ? unsigned_type_node
1548                                       : integer_type_node);
1549                 else if (! spec_long_long)
1550                   traditional_type = (spec_unsigned ? long_unsigned_type_node
1551                                       : long_integer_type_node);
1552                 else
1553                   traditional_type = (spec_unsigned
1554                                       ? long_long_unsigned_type_node
1555                                       : long_long_integer_type_node);
1556               }
1557             if (warn_traditional || ! flag_traditional)
1558               {
1559                 /* Calculate the ANSI type.  */
1560                 if (! spec_long && ! spec_unsigned
1561                     && int_fits_type_p (yylval.ttype, integer_type_node))
1562                   ansi_type = integer_type_node;
1563                 else if (! spec_long && (base != 10 || spec_unsigned)
1564                          && int_fits_type_p (yylval.ttype, unsigned_type_node))
1565                   ansi_type = unsigned_type_node;
1566                 else if (! spec_unsigned && !spec_long_long
1567                          && int_fits_type_p (yylval.ttype, long_integer_type_node))
1568                   ansi_type = long_integer_type_node;
1569                 else if (! spec_long_long)
1570                   ansi_type = long_unsigned_type_node;
1571                 else if (! spec_unsigned
1572                          /* Verify value does not overflow into sign bit.  */
1573                          && TREE_INT_CST_HIGH (yylval.ttype) >= 0
1574                          && int_fits_type_p (yylval.ttype,
1575                                              long_long_integer_type_node))
1576                   ansi_type = long_long_integer_type_node;
1577                 else
1578                   ansi_type = long_long_unsigned_type_node;
1579               }
1580
1581             type = flag_traditional ? traditional_type : ansi_type;
1582
1583             if (warn_traditional && traditional_type != ansi_type)
1584               {
1585                 if (TYPE_PRECISION (traditional_type)
1586                     != TYPE_PRECISION (ansi_type))
1587                   warning ("width of integer constant changes with -traditional");
1588                 else if (TREE_UNSIGNED (traditional_type)
1589                          != TREE_UNSIGNED (ansi_type))
1590                   warning ("integer constant is unsigned in ANSI C, signed with -traditional");
1591                 else
1592                   warning ("width of integer constant may change on other systems with -traditional");
1593               }
1594
1595             if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
1596                 && !warn)
1597               pedwarn ("integer constant out of range");
1598
1599             if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
1600               warning ("decimal constant is so large that it is unsigned");
1601
1602             if (flag_traditional && !int_fits_type_p (yylval.ttype, type))
1603               /* The traditional constant 0x80000000 is signed
1604                  but doesn't fit in the range of int.
1605                  This will change it to -0x80000000, which does fit.  */
1606               {
1607                 TREE_TYPE (yylval.ttype) = unsigned_type (type);
1608                 yylval.ttype = convert (type, yylval.ttype);
1609               }
1610             else
1611               TREE_TYPE (yylval.ttype) = type;
1612
1613             *p = 0;
1614           }
1615
1616         value = CONSTANT; break;
1617       }
1618
1619     case '\'':
1620     char_constant:
1621       {
1622         register int result = 0;
1623         register int num_chars = 0;
1624         unsigned width = TYPE_PRECISION (char_type_node);
1625         int max_chars;
1626
1627         if (wide_flag)
1628           {
1629             width = WCHAR_TYPE_SIZE;
1630 #ifdef MULTIBYTE_CHARS
1631             max_chars = MB_CUR_MAX;
1632 #else
1633             max_chars = 1;
1634 #endif
1635           }
1636         else
1637           max_chars = TYPE_PRECISION (integer_type_node) / width;
1638
1639         while (1)
1640           {
1641           tryagain:
1642
1643             c = getc (finput);
1644
1645             if (c == '\'' || c == EOF)
1646               break;
1647
1648             if (c == '\\')
1649               {
1650                 int ignore = 0;
1651                 c = readescape (&ignore);
1652                 if (ignore)
1653                   goto tryagain;
1654                 if (width < HOST_BITS_PER_INT
1655                     && (unsigned) c >= (1 << width))
1656                   pedwarn ("escape sequence out of range for character");
1657               }
1658             else if (c == '\n')
1659               {
1660                 if (pedantic)
1661                   pedwarn ("ANSI C forbids newline in character constant");
1662                 lineno++;
1663               }
1664
1665             num_chars++;
1666             if (num_chars > maxtoken - 4)
1667               extend_token_buffer (token_buffer);
1668
1669             token_buffer[num_chars] = c;
1670
1671             /* Merge character into result; ignore excess chars.  */
1672             if (num_chars < max_chars + 1)
1673               {
1674                 if (width < HOST_BITS_PER_INT)
1675                   result = (result << width) | (c & ((1 << width) - 1));
1676                 else
1677                   result = c;
1678               }
1679           }
1680
1681         token_buffer[num_chars + 1] = '\'';
1682         token_buffer[num_chars + 2] = 0;
1683
1684         if (c != '\'')
1685           error ("malformatted character constant");
1686         else if (num_chars == 0)
1687           error ("empty character constant");
1688         else if (num_chars > max_chars)
1689           {
1690             num_chars = max_chars;
1691             error ("character constant too long");
1692           }
1693         else if (num_chars != 1 && ! flag_traditional)
1694           warning ("multi-character character constant");
1695
1696         /* If char type is signed, sign-extend the constant.  */
1697         if (! wide_flag)
1698           {
1699             int num_bits = num_chars * width;
1700             if (TREE_UNSIGNED (char_type_node)
1701                 || ((result >> (num_bits - 1)) & 1) == 0)
1702               yylval.ttype
1703                 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
1704                                          >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1705                                0);
1706             else
1707               yylval.ttype
1708                 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
1709                                           >> (HOST_BITS_PER_WIDE_INT - num_bits)),
1710                                -1);
1711             TREE_TYPE (yylval.ttype) = integer_type_node;
1712           }
1713         else
1714           {
1715 #ifdef MULTIBYTE_CHARS
1716             /* Set the initial shift state and convert the next sequence.  */
1717             result = 0;
1718             /* In all locales L'\0' is zero and mbtowc will return zero,
1719                so don't use it.  */
1720             if (num_chars > 1
1721                 || (num_chars == 1 && token_buffer[1] != '\0'))
1722               {
1723                 wchar_t wc;
1724                 (void) mbtowc (NULL_PTR, NULL_PTR, 0);
1725                 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
1726                   result = wc;
1727                 else
1728                   warning ("Ignoring invalid multibyte character");
1729               }
1730 #endif
1731             yylval.ttype = build_int_2 (result, 0);
1732             TREE_TYPE (yylval.ttype) = wchar_type_node;
1733           }
1734
1735         value = CONSTANT;
1736         break;
1737       }
1738
1739     case '"':
1740     string_constant:
1741       {
1742         c = getc (finput);
1743         p = token_buffer + 1;
1744
1745         while (c != '"' && c >= 0)
1746           {
1747             /* ignore_escape_flag is set for reading the filename in #line.  */
1748             if (!ignore_escape_flag && c == '\\')
1749               {
1750                 int ignore = 0;
1751                 c = readescape (&ignore);
1752                 if (ignore)
1753                   goto skipnewline;
1754                 if (!wide_flag
1755                     && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
1756                     && c >= (1 << TYPE_PRECISION (char_type_node)))
1757                   pedwarn ("escape sequence out of range for character");
1758               }
1759             else if (c == '\n')
1760               {
1761                 if (pedantic)
1762                   pedwarn ("ANSI C forbids newline in string constant");
1763                 lineno++;
1764               }
1765
1766             if (p == token_buffer + maxtoken)
1767               p = extend_token_buffer (p);
1768             *p++ = c;
1769
1770           skipnewline:
1771             c = getc (finput);
1772           }
1773         *p = 0;
1774
1775         /* We have read the entire constant.
1776            Construct a STRING_CST for the result.  */
1777
1778         if (wide_flag)
1779           {
1780             /* If this is a L"..." wide-string, convert the multibyte string
1781                to a wide character string.  */
1782             char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
1783             int len;
1784
1785 #ifdef MULTIBYTE_CHARS
1786             len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
1787             if ((unsigned) len >= (p - token_buffer))
1788               {
1789                 warning ("Ignoring invalid multibyte string");
1790                 len = 0;
1791               }
1792             bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
1793 #else
1794             {
1795               union { long l; char c[sizeof (long)]; } u;
1796               int big_endian;
1797               char *wp, *cp;
1798
1799               /* Determine whether host is little or big endian.  */
1800               u.l = 1;
1801               big_endian = u.c[sizeof (long) - 1];
1802               wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
1803
1804               bzero (widep, (p - token_buffer) * WCHAR_BYTES);
1805               for (cp = token_buffer + 1; cp < p; cp++)
1806                 *wp = *cp, wp += WCHAR_BYTES;
1807               len = p - token_buffer - 1;
1808             }
1809 #endif
1810             yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
1811             TREE_TYPE (yylval.ttype) = wchar_array_type_node;
1812           }
1813         else
1814           {
1815             yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
1816             TREE_TYPE (yylval.ttype) = char_array_type_node;
1817           }
1818
1819         *p++ = '"';
1820         *p = 0;
1821
1822         value = STRING; break;
1823       }
1824
1825     case '+':
1826     case '-':
1827     case '&':
1828     case '|':
1829     case '<':
1830     case '>':
1831     case '*':
1832     case '/':
1833     case '%':
1834     case '^':
1835     case '!':
1836     case '=':
1837       {
1838         register int c1;
1839
1840       combine:
1841
1842         switch (c)
1843           {
1844           case '+':
1845             yylval.code = PLUS_EXPR; break;
1846           case '-':
1847             yylval.code = MINUS_EXPR; break;
1848           case '&':
1849             yylval.code = BIT_AND_EXPR; break;
1850           case '|':
1851             yylval.code = BIT_IOR_EXPR; break;
1852           case '*':
1853             yylval.code = MULT_EXPR; break;
1854           case '/':
1855             yylval.code = TRUNC_DIV_EXPR; break;
1856           case '%':
1857             yylval.code = TRUNC_MOD_EXPR; break;
1858           case '^':
1859             yylval.code = BIT_XOR_EXPR; break;
1860           case LSHIFT:
1861             yylval.code = LSHIFT_EXPR; break;
1862           case RSHIFT:
1863             yylval.code = RSHIFT_EXPR; break;
1864           case '<':
1865             yylval.code = LT_EXPR; break;
1866           case '>':
1867             yylval.code = GT_EXPR; break;
1868           }
1869
1870         token_buffer[1] = c1 = getc (finput);
1871         token_buffer[2] = 0;
1872
1873         if (c1 == '=')
1874           {
1875             switch (c)
1876               {
1877               case '<':
1878                 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
1879               case '>':
1880                 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
1881               case '!':
1882                 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
1883               case '=':
1884                 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
1885               }
1886             value = ASSIGN; goto done;
1887           }
1888         else if (c == c1)
1889           switch (c)
1890             {
1891             case '+':
1892               value = PLUSPLUS; goto done;
1893             case '-':
1894               value = MINUSMINUS; goto done;
1895             case '&':
1896               value = ANDAND; goto done;
1897             case '|':
1898               value = OROR; goto done;
1899             case '<':
1900               c = LSHIFT;
1901               goto combine;
1902             case '>':
1903               c = RSHIFT;
1904               goto combine;
1905             }
1906         else if ((c == '-') && (c1 == '>'))
1907           { value = POINTSAT; goto done; }
1908         ungetc (c1, finput);
1909         token_buffer[1] = 0;
1910
1911         if ((c == '<') || (c == '>'))
1912           value = ARITHCOMPARE;
1913         else value = c;
1914         goto done;
1915       }
1916
1917     case 0:
1918       /* Don't make yyparse think this is eof.  */
1919       value = 1;
1920       break;
1921
1922     default:
1923       value = c;
1924     }
1925
1926 done:
1927 /*  yylloc.last_line = lineno; */
1928
1929   return value;
1930 }
1931
1932 /* Sets the value of the 'yydebug' variable to VALUE.
1933    This is a function so we don't have to have YYDEBUG defined
1934    in order to build the compiler.  */
1935
1936 void
1937 set_yydebug (value)
1938      int value;
1939 {
1940 #if YYDEBUG != 0
1941   yydebug = value;
1942 #else
1943   warning ("YYDEBUG not defined.");
1944 #endif
1945 }