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