gcc/c-lex.c

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