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