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