![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-lex.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Separate lexical analyzer for GNU C++.
2: Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
3: Hacked by Michael Tiemann ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: /* This file is the lexical analyzer for GNU C++. */
23:
24: #if defined(GATHER_STATISTICS) || defined(SPEW_DEBUG)
25: #undef YYDEBUG
26: #define YYDEBUG 1
27: #endif
28:
29: #include <sys/types.h>
30: #include <stdio.h>
31: #include <errno.h>
32: #include <setjmp.h>
33: #include "config.h"
34: #include "input.h"
35: #include "tree.h"
36: #include "cp-lex.h"
37: #ifdef OBJCPLUS
38: #include "obcp-parse.h"
39: #else
40: #include "cp-parse.h"
41: #endif
42: #include "cp-tree.h"
43: #include "flags.h"
44: #include "obstack.h"
45:
46: #ifdef MULTIBYTE_CHARS
47: #include <stdlib.h>
48: #include <locale.h>
49: #endif
50:
51: #ifndef errno
52: extern int errno; /* needed for VAX. */
53: #endif
54: extern jmp_buf toplevel;
55:
56: #define obstack_chunk_alloc xmalloc
57: #define obstack_chunk_free free
58:
59: extern struct obstack *expression_obstack, permanent_obstack;
60: extern struct obstack *current_obstack, *saveable_obstack;
61:
62: extern double atof ();
63:
64: extern char *get_directive_line (); /* In c-common.c */
65:
66: /* Given a file name X, return the nondirectory portion.
67: Keep in mind that X can be computed more than once. */
68: #ifndef FILE_NAME_NONDIRECTORY
69: #define FILE_NAME_NONDIRECTORY(X) \
70: (rindex (X, '/') != 0 ? rindex (X, '/') + 1 : X)
71: #endif
72:
73: extern char *index ();
74: extern char *rindex ();
75:
76: void extract_interface_info ();
77: void yyerror ();
78:
79: /* This obstack is needed to hold text. It is not safe to use
80: TOKEN_BUFFER because `check_newline' calls `yylex'. */
81: struct obstack inline_text_obstack;
82: static char *inline_text_firstobj;
83:
84: int end_of_file;
85:
86: /* Wrap the current header file in extern "C". */
87: int in_c_header = 0;
88:
89: extern int first_token;
90: extern struct obstack token_obstack;
91:
92: /* ??? Don't really know where this goes yet. */
93: #if 1
94: #include "cp-input.c"
95: #else
96: extern void put_back (/* int */);
97: extern int input_redirected ();
98: extern void feed_input (/* char *, int, struct obstack * */);
99: #endif
100:
101: /* Holds translations from TREE_CODEs to operator name strings,
102: i.e., opname_tab[PLUS_EXPR] == "+". */
103: char **opname_tab;
104: char **assignop_tab;
105:
106: extern int yychar; /* the lookahead symbol */
107: extern YYSTYPE yylval; /* the semantic value of the */
108: /* lookahead symbol */
109:
110: #if 0
111: YYLTYPE yylloc; /* location data for the lookahead */
112: /* symbol */
113: #endif
114:
115:
116: #ifdef OBJCPLUS
117:
118: /* Objective-C specific information (from obcp-parse.c) */
119:
120: #include "objc-act.h"
121: extern tree objc_method_context;
122: extern tree objc_ivar_chain;
123: extern int objc_receiver_context;
124: extern int objc_declarator_context;
125: extern int objc_msg_context;
126: extern tree current_objc_implementation_context (void);
127:
128: #endif
129:
130: /* the declaration found for the last IDENTIFIER token read in.
131: yylex must look this up to detect typedefs, which get token type TYPENAME,
132: so it is left around in case the identifier is not a typedef but is
133: used in a context which makes it a reference to a variable. */
134: tree lastiddecl;
135:
136: /* The elements of `ridpointers' are identifier nodes
137: for the reserved type names and storage classes.
138: It is indexed by a RID_... value. */
139: tree ridpointers[(int) RID_MAX];
140:
141: /* We may keep statistics about how long which files took to compile. */
142: static int header_time, body_time;
143: static tree get_time_identifier ();
144: static tree filename_times;
145: static tree this_filename_time;
146:
147: /* For implementing #pragma unit. */
148: tree current_unit_name;
149: tree current_unit_language;
150:
151: /* Array for holding counts of the numbers of tokens seen. */
152: extern int *token_count;
153:
154: /* Textual definition used for default functions. */
155: static void default_copy_constructor_body ();
156:
157: /* Return something to represent absolute declarators containing a *.
158: TARGET is the absolute declarator that the * contains.
159: TYPE_QUALS is a list of modifiers such as const or volatile
160: to apply to the pointer type, represented as identifiers.
161:
162: We return an INDIRECT_REF whose "contents" are TARGET
163: and whose type is the modifier list. */
164:
165: tree
166: make_pointer_declarator (type_quals, target)
167: tree type_quals, target;
168: {
169: if (target && TREE_CODE (target) == IDENTIFIER_NODE
170: && ANON_AGGRNAME_P (target))
171: error ("type name expected before `*'");
172: #ifdef OBJCPLUS
173: target = build_nt (INDIRECT_REF, target);
174: #else
175: target = build_parse_node (INDIRECT_REF, target);
176: #endif
177: TREE_TYPE (target) = type_quals;
178: return target;
179: }
180:
181: /* Return something to represent absolute declarators containing a &.
182: TARGET is the absolute declarator that the & contains.
183: TYPE_QUALS is a list of modifiers such as const or volatile
184: to apply to the reference type, represented as identifiers.
185:
186: We return an ADDR_EXPR whose "contents" are TARGET
187: and whose type is the modifier list. */
188:
189: tree
190: make_reference_declarator (type_quals, target)
191: tree type_quals, target;
192: {
193: if (target)
194: {
195: if (TREE_CODE (target) == ADDR_EXPR)
196: {
197: error ("cannot declare references to references");
198: return target;
199: }
200: if (TREE_CODE (target) == INDIRECT_REF)
201: {
202: error ("cannot declare pointers to references");
203: return target;
204: }
205: if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
206: error ("type name expected before `&'");
207: }
208: target = build_parse_node (ADDR_EXPR, target);
209: TREE_TYPE (target) = type_quals;
210: return target;
211: }
212:
213: /* Build names and nodes for overloaded operators. */
214:
215: tree ansi_opname[LAST_CPLUS_TREE_CODE];
216: tree ansi_assopname[LAST_CPLUS_TREE_CODE];
217:
218: char *
219: operator_name_string (name)
220: tree name;
221: {
222: char *opname = IDENTIFIER_POINTER (name) + 2;
223: tree *opname_table;
224: int i, assign;
225:
226: /* Works for builtin and user defined types. */
227: if (IDENTIFIER_GLOBAL_VALUE (name)
228: && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
229: return IDENTIFIER_POINTER (name);
230:
231: if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
232: {
233: opname += 1;
234: assign = 1;
235: opname_table = ansi_assopname;
236: }
237: else
238: {
239: assign = 0;
240: opname_table = ansi_opname;
241: }
242:
243: for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
244: {
245: if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
246: && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
247: break;
248: }
249:
250: if (i == LAST_CPLUS_TREE_CODE)
251: return "<invalid operator>";
252:
253: if (assign)
254: return assignop_tab[i];
255: else
256: return opname_tab[i];
257: }
258:
259: int interface_only; /* whether or not current file is only for
260: interface definitions. */
261: int interface_unknown; /* whether or not we know this class
262: to behave according to #pragma interface. */
263:
264: /* lexical analyzer */
265:
266: /* File used for outputting assembler code. */
267: extern FILE *asm_out_file;
268:
269: #ifndef WCHAR_TYPE_SIZE
270: #ifdef INT_TYPE_SIZE
271: #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
272: #else
273: #define WCHAR_TYPE_SIZE BITS_PER_WORD
274: #endif
275: #endif
276:
277: /* Number of bytes in a wide character. */
278: #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
279:
280: static int maxtoken; /* Current nominal length of token buffer. */
281: char *token_buffer; /* Pointer to token buffer.
282: Actual allocated length is maxtoken + 2. */
283:
284: #ifdef OBJCPLUS
285: #include "obcp-hash.h"
286: #else
287: #include "cp-hash.h"
288: #endif
289:
290:
291: int cplusplus_keywords_disabled = 0;
292:
293: #ifdef OBJCPLUS
294:
295: /* This is some code to handle << extern "objective-c" { ... } >> */
296:
297: void install_reserved_words (enum languages lang)
298: {
299: int i, n = sizeof (wordlist) / sizeof (struct resword);
300:
301: cplusplus_keywords_disabled = (lang != lang_cplusplus);
302: for (i = 0; i < n; i++)
303: {
304: if (wordlist[i].name && *wordlist[i].name != '\0')
305: {
306: /* The keyword is currently installed...
307: see if we should suspend it */
308: if (lang == lang_c || lang == lang_objc)
309: {
310: /* favor Objective-C for now...only suspend C++ keywords */
311: if (wordlist[i].lang == lang_cplusplus)
312: {
313: wordlist[i].save = wordlist[i].name;
314: wordlist[i].name = "";
315: }
316: }
317: }
318: else if (wordlist[i].save && *wordlist[i].save != '\0')
319: {
320: /* the keyword is currently suspended...
321: see if we should re-install it */
322:
323: if (lang == lang_cplusplus)
324: {
325: if (wordlist[i].lang == lang_cplusplus)
326: {
327: wordlist[i].name = wordlist[i].save;
328: wordlist[i].save = "";
329: }
330: }
331: }
332: }
333: }
334:
335: void
336: forget_protocol_qualifiers ()
337: {
338: int i, n = sizeof wordlist / sizeof (struct resword);
339:
340: /* Check the lookahead tokens for protocol qualifiers. */
341: forget_saved_protocol_qualifiers ();
342:
343: for (i = 0; i < n; i++)
344: {
345: if (wordlist[i].rid >= RID_IN && wordlist[i].rid <= RID_ONEWAY)
346: wordlist[i].name = "";
347: }
348: }
349:
350: void
351: remember_protocol_qualifiers ()
352: {
353: int i, n = sizeof wordlist / sizeof (struct resword);
354:
355: for (i = 0; i < n; i++)
356: {
357: if (wordlist[i].rid == RID_IN)
358: wordlist[i].name = "in";
359: else if (wordlist[i].rid == RID_OUT)
360: wordlist[i].name = "out";
361: else if (wordlist[i].rid == RID_INOUT)
362: wordlist[i].name = "inout";
363: else if (wordlist[i].rid == RID_BYCOPY)
364: wordlist[i].name = "bycopy";
365: else if (wordlist[i].rid == RID_ONEWAY)
366: wordlist[i].name = "oneway";
367: }
368: }
369:
370: #endif
371:
372: int check_newline ();
373:
374: /* Nonzero tells yylex to ignore \ in string constants. */
375: static int ignore_escape_flag = 0;
376:
377: static int skip_white_space ();
378:
379: static tree
380: get_time_identifier (name)
381: char *name;
382: {
383: tree time_identifier;
384: int len = strlen (name);
385: char *buf = (char *) alloca (len + 6);
386: strcpy (buf, "file ");
387: bcopy (name, buf+5, len);
388: buf[len+5] = '\0';
389: time_identifier = get_identifier (buf);
390: if (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
391: {
392: push_obstacks_nochange ();
393: end_temporary_allocation ();
394: IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
395: IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
396: IDENTIFIER_GLOBAL_VALUE (time_identifier) = filename_times;
397: filename_times = time_identifier;
398: pop_obstacks ();
399: }
400: return time_identifier;
401: }
402:
403: #ifdef __GNUC__
404: __inline
405: #endif
406: static int
407: my_get_run_time ()
408: {
409: int old_quiet_flag = quiet_flag;
410: int this_time;
411: quiet_flag = 0;
412: this_time = get_run_time ();
413: quiet_flag = old_quiet_flag;
414: return this_time;
415: }
416:
417: /* Table indexed by tree code giving a string containing a character
418: classifying the tree code. Possibilities are
419: t, d, s, c, r, <, 1 and 2. See cp-tree.def for details. */
420:
421: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
422:
423: char *cplus_tree_code_type[] = {
424: "x",
425: #include "cp-tree.def"
426: };
427: #undef DEFTREECODE
428:
429: /* Table indexed by tree code giving number of expression
430: operands beyond the fixed part of the node structure.
431: Not used for types or decls. */
432:
433: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
434:
435: int cplus_tree_code_length[] = {
436: 0,
437: #include "cp-tree.def"
438: };
439: #undef DEFTREECODE
440:
441: /* Names of tree components.
442: Used for printing out the tree and error messages. */
443: #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
444:
445: char *cplus_tree_code_name[] = {
446: "@@dummy",
447: #include "cp-tree.def"
448: };
449: #undef DEFTREECODE
450:
451: /* toplev.c needs to call these. */
452:
453: void
454: lang_init ()
455: {
456: /* the beginning of the file is a new line; check for # */
457: /* With luck, we discover the real source file's name from that
458: and put it in input_filename. */
459: put_back (check_newline ());
460:
461: if (flag_cadillac)
462: cadillac_start ();
463: if (flag_gnu_xref) GNU_xref_begin (input_filename);
464: #ifdef OBJCPLUS
465: objc_lang_init ();
466: #endif
467: }
468:
469: void
470: lang_finish ()
471: {
472: extern int errorcount, sorrycount;
473: if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
474: #ifdef OBJCPLUS
475: objc_lang_finish ();
476: #endif
477: }
478:
479: char *
480: lang_identify ()
481: {
482: return "cplusplus";
483: }
484:
485: void
486: init_filename_times ()
487: {
488: this_filename_time = get_time_identifier ("<top level>");
489: if (flag_detailed_statistics)
490: {
491: header_time = 0;
492: body_time = my_get_run_time ();
493: TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
494: }
495: }
496:
497: /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
498: Stuck this hack in to get the files open correctly; this is called
499: in place of init_lex if we are an unexec'd binary. */
500: void
501: reinit_lang_specific ()
502: {
503: init_filename_times ();
504: reinit_search_statistics ();
505: }
506:
507: void
508: init_lex ()
509: {
510: extern char *(*decl_printable_name) ();
511:
512: int i;
513:
514: /* Initialize the lookahead machinery. */
515: init_spew ();
516:
517: /* Make identifier nodes long enough for the language-specific slots. */
518: set_identifier_size (sizeof (struct lang_identifier));
519: decl_printable_name = lang_printable_name;
520:
521: init_cplus_expand ();
522:
523: tree_code_type
524: = (char **) realloc (tree_code_type,
525: sizeof (char *) * LAST_CPLUS_TREE_CODE);
526: tree_code_length
527: = (int *) realloc (tree_code_length,
528: sizeof (int) * LAST_CPLUS_TREE_CODE);
529: tree_code_name
530: = (char **) realloc (tree_code_name,
531: sizeof (char *) * LAST_CPLUS_TREE_CODE);
532: bcopy ((char *)cplus_tree_code_type,
533: (char *)(tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE),
534: (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
535: bcopy ((char *)cplus_tree_code_length,
536: (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
537: (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
538: bcopy ((char *)cplus_tree_code_name,
539: (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
540: (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
541:
542: opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
543: bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
544: assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
545: bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
546:
547: ansi_opname[0] = get_identifier ("<invalid operator>");
548: for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
549: {
550: ansi_opname[i] = ansi_opname[0];
551: ansi_assopname[i] = ansi_opname[0];
552: }
553:
554: ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
555: IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
556: ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
557: ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
558: IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
559: ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
560: ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
561: IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
562: ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
563: IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
564: ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
565: ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
566: ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
567: ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
568: IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
569: ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
570: ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
571: IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
572: ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
573: ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
574: IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
575: ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
576: IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
577: ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
578: IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
579: ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
580: IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
581: ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
582: IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
583: ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
584: IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
585: ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
586: IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
587: ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
588: IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
589: ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
590: IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
591: ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
592: IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
593: ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
594: ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
595: IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
596: ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
597: ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
598: IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
599: ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
600: IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
601: ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
602: IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
603: ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
604: ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
605: ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
606: ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
607: ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
608: ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
609: ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
610: ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
611: ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
612: IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
613: ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
614: IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
615: ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
616: ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
617: ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
618: IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
619: ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
620: IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
621: ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
622: IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
623: ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
624: IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
625: ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
626: IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
627: ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
628: IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
629: ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
630: IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
631: ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
632: ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
633: ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
634: IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
635: ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
636: IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
637: ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
638: IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
639: ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
640: IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
641: ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
642: IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
643: ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
644: ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
645: IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
646: ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
647: IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
648: ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
649: IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
650: ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
651: IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
652: ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
653: IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
654: ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
655: IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
656: ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
657: IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
658:
659: /* This is not true: these operators are not defined in ANSI,
660: but we need them anyway. */
661: ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
662: IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
663: ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
664: IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
665: ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
666: IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
667: ansi_opname[(int) METHOD_CALL_EXPR] = get_identifier ("__wr");
668: IDENTIFIER_OPNAME_P (ansi_opname[(int) METHOD_CALL_EXPR]) = 1;
669:
670: init_method ();
671: init_error ();
672: gcc_obstack_init (&inline_text_obstack);
673: inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
674:
675: /* Start it at 0, because check_newline is called at the very beginning
676: and will increment it to 1. */
677: lineno = 0;
678: current_function_decl = NULL;
679:
680: maxtoken = 40;
681: token_buffer = (char *) xmalloc (maxtoken + 2);
682:
683: ridpointers[(int) RID_INT] = get_identifier ("int");
684: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
685: build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
686: ridpointers[(int) RID_CHAR] = get_identifier ("char");
687: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
688: build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
689: ridpointers[(int) RID_VOID] = get_identifier ("void");
690: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
691: build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
692: ridpointers[(int) RID_FLOAT] = get_identifier ("float");
693: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
694: build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
695: ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
696: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
697: build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
698: ridpointers[(int) RID_SHORT] = get_identifier ("short");
699: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
700: build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
701: ridpointers[(int) RID_LONG] = get_identifier ("long");
702: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
703: build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
704: ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
705: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
706: build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
707: ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
708: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
709: build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
710: ridpointers[(int) RID_INLINE] = get_identifier ("inline");
711: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
712: build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
713: ridpointers[(int) RID_CONST] = get_identifier ("const");
714: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
715: build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
716: ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
717: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
718: build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
719: ridpointers[(int) RID_AUTO] = get_identifier ("auto");
720: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
721: build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
722: ridpointers[(int) RID_STATIC] = get_identifier ("static");
723: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
724: build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
725: ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
726: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
727: build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
728: ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
729: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
730: build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
731: ridpointers[(int) RID_REGISTER] = get_identifier ("register");
732: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
733: build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
734:
735: #ifdef OBJCPLUS
736: /* Objective-C protocol extensions */
737: ridpointers[(int) RID_ID] = get_identifier ("id");
738: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_ID],
739: build_tree_list (NULL_TREE, ridpointers[(int) RID_ID]));
740:
741: ridpointers[(int) RID_IN] = get_identifier ("in");
742: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_IN],
743: build_tree_list (NULL_TREE, ridpointers[(int) RID_IN]));
744:
745: ridpointers[(int) RID_OUT] = get_identifier ("out");
746: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_OUT],
747: build_tree_list (NULL_TREE, ridpointers[(int) RID_OUT]));
748:
749: ridpointers[(int) RID_INOUT] = get_identifier ("inout");
750: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INOUT],
751: build_tree_list (NULL_TREE, ridpointers[(int) RID_INOUT]));
752:
753: ridpointers[(int) RID_BYCOPY] = get_identifier ("bycopy");
754: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_BYCOPY],
755: build_tree_list (NULL_TREE, ridpointers[(int) RID_BYCOPY]));
756:
757: ridpointers[(int) RID_ONEWAY] = get_identifier ("oneway");
758: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_ONEWAY],
759: build_tree_list (NULL_TREE, ridpointers[(int) RID_ONEWAY]));
760:
761: forget_protocol_qualifiers ();
762: #endif /* OBJCPLUS */
763:
764:
765: /* C++ extensions. These are probably not correctly named. */
766: ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
767: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
768: build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
769: class_type_node = build_int_2 (class_type, 0);
770: TREE_TYPE (class_type_node) = class_type_node;
771: ridpointers[(int) RID_CLASS] = class_type_node;
772:
773: record_type_node = build_int_2 (record_type, 0);
774: TREE_TYPE (record_type_node) = record_type_node;
775: ridpointers[(int) RID_RECORD] = record_type_node;
776:
777: union_type_node = build_int_2 (union_type, 0);
778: TREE_TYPE (union_type_node) = union_type_node;
779: ridpointers[(int) RID_UNION] = union_type_node;
780:
781: enum_type_node = build_int_2 (enum_type, 0);
782: TREE_TYPE (enum_type_node) = enum_type_node;
783: ridpointers[(int) RID_ENUM] = enum_type_node;
784:
785: ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
786: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
787: build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
788: ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
789: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
790: build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
791:
792: ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
793: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
794: build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
795: ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
796: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
797: build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
798: ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
799: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
800: build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
801: /* This is for ANSI C++. */
802: ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
803: SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
804: build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
805:
806: /* Exception handling extensions. */
807: exception_type_node = build_int_2 (exception_type, 0);
808: TREE_TYPE (exception_type_node) = exception_type_node;
809: ridpointers[(int) RID_EXCEPTION] = exception_type_node;
810:
811: opname_tab[(int) COMPONENT_REF] = "->";
812: opname_tab[(int) MEMBER_REF] = "->*";
813: opname_tab[(int) METHOD_CALL_EXPR] = "->()";
814: opname_tab[(int) INDIRECT_REF] = "(unary *)";
815: opname_tab[(int) ARRAY_REF] = "[]";
816: opname_tab[(int) MODIFY_EXPR] = "=";
817: opname_tab[(int) NEW_EXPR] = "new";
818: opname_tab[(int) DELETE_EXPR] = "delete";
819: opname_tab[(int) COND_EXPR] = "... ? ... : ...";
820: opname_tab[(int) CALL_EXPR] = "()";
821: opname_tab[(int) PLUS_EXPR] = "+";
822: opname_tab[(int) MINUS_EXPR] = "-";
823: opname_tab[(int) MULT_EXPR] = "*";
824: opname_tab[(int) TRUNC_DIV_EXPR] = "/";
825: opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
826: opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
827: opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
828: opname_tab[(int) TRUNC_MOD_EXPR] = "%";
829: opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
830: opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
831: opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
832: opname_tab[(int) NEGATE_EXPR] = "-";
833: opname_tab[(int) MIN_EXPR] = "<?";
834: opname_tab[(int) MAX_EXPR] = ">?";
835: opname_tab[(int) ABS_EXPR] = "abs";
836: opname_tab[(int) FFS_EXPR] = "ffs";
837: opname_tab[(int) LSHIFT_EXPR] = "<<";
838: opname_tab[(int) RSHIFT_EXPR] = ">>";
839: opname_tab[(int) BIT_IOR_EXPR] = "|";
840: opname_tab[(int) BIT_XOR_EXPR] = "^";
841: opname_tab[(int) BIT_AND_EXPR] = "&";
842: opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
843: opname_tab[(int) BIT_NOT_EXPR] = "~";
844: opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
845: opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
846: opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
847: opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
848: opname_tab[(int) TRUTH_NOT_EXPR] = "!";
849: opname_tab[(int) LT_EXPR] = "<";
850: opname_tab[(int) LE_EXPR] = "<=";
851: opname_tab[(int) GT_EXPR] = ">";
852: opname_tab[(int) GE_EXPR] = ">=";
853: opname_tab[(int) EQ_EXPR] = "==";
854: opname_tab[(int) NE_EXPR] = "!=";
855: opname_tab[(int) IN_EXPR] = "in";
856: opname_tab[(int) RANGE_EXPR] = "..";
857: opname_tab[(int) CONVERT_EXPR] = "(unary +)";
858: opname_tab[(int) ADDR_EXPR] = "(unary &)";
859: opname_tab[(int) PREDECREMENT_EXPR] = "--";
860: opname_tab[(int) PREINCREMENT_EXPR] = "++";
861: opname_tab[(int) POSTDECREMENT_EXPR] = "--";
862: opname_tab[(int) POSTINCREMENT_EXPR] = "++";
863: opname_tab[(int) COMPOUND_EXPR] = ",";
864:
865: assignop_tab[(int) NOP_EXPR] = "=";
866: assignop_tab[(int) PLUS_EXPR] = "+=";
867: assignop_tab[(int) CONVERT_EXPR] = "+=";
868: assignop_tab[(int) MINUS_EXPR] = "-=";
869: assignop_tab[(int) NEGATE_EXPR] = "-=";
870: assignop_tab[(int) MULT_EXPR] = "*=";
871: assignop_tab[(int) INDIRECT_REF] = "*=";
872: assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
873: assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
874: assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
875: assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
876: assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
877: assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
878: assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
879: assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
880: assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
881: assignop_tab[(int) MIN_EXPR] = "<?=";
882: assignop_tab[(int) MAX_EXPR] = ">?=";
883: assignop_tab[(int) LSHIFT_EXPR] = "<<=";
884: assignop_tab[(int) RSHIFT_EXPR] = ">>=";
885: assignop_tab[(int) BIT_IOR_EXPR] = "|=";
886: assignop_tab[(int) BIT_XOR_EXPR] = "^=";
887: assignop_tab[(int) BIT_AND_EXPR] = "&=";
888: assignop_tab[(int) ADDR_EXPR] = "&=";
889:
890: init_filename_times ();
891:
892: /* Some options inhibit certain reserved words.
893: Clear those words out of the hash table so they won't be recognized. */
894: #define UNSET_RESERVED_WORD(STRING) \
895: do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
896: if (s) s->name = ""; } while (0)
897:
898: if (flag_ansi_exceptions)
899: flag_handle_exceptions = 2;
900:
901: if (!flag_ansi_exceptions)
902: {
903: UNSET_RESERVED_WORD ("catch");
904: }
905:
906: if (! flag_handle_exceptions)
907: {
908: /* Easiest way to not recognize exception
909: handling extensions... */
910: UNSET_RESERVED_WORD ("all");
911: UNSET_RESERVED_WORD ("except");
912: UNSET_RESERVED_WORD ("exception");
913: UNSET_RESERVED_WORD ("raise");
914: UNSET_RESERVED_WORD ("raises");
915: UNSET_RESERVED_WORD ("reraise");
916: UNSET_RESERVED_WORD ("try");
917: UNSET_RESERVED_WORD ("throw");
918: }
919: else if (flag_ansi_exceptions)
920: {
921: /* Easiest way to not recognize exception
922: handling extensions... */
923: UNSET_RESERVED_WORD ("exception");
924: UNSET_RESERVED_WORD ("all");
925: UNSET_RESERVED_WORD ("except");
926: UNSET_RESERVED_WORD ("raise");
927: UNSET_RESERVED_WORD ("raises");
928: UNSET_RESERVED_WORD ("reraise");
929: is_reserved_word ("try", sizeof ("try") - 1)->token = ANSI_TRY;
930: is_reserved_word ("throw", sizeof ("throw") - 1)->token = ANSI_THROW;
931: }
932: if (! (flag_gc || flag_dossier))
933: {
934: UNSET_RESERVED_WORD ("classof");
935: UNSET_RESERVED_WORD ("headof");
936: }
937: if (flag_no_asm)
938: UNSET_RESERVED_WORD ("asm");
939: if (flag_no_asm || flag_traditional)
940: UNSET_RESERVED_WORD ("typeof");
941:
942: token_count = init_parse ();
943: interface_unknown = 1;
944: }
945:
946: void
947: reinit_parse_for_function ()
948: {
949: current_base_init_list = NULL_TREE;
950: current_member_init_list = NULL_TREE;
951: }
952:
953: #ifdef __GNUC__
954: __inline
955: #endif
956: void
957: yyprint (file, yychar, yylval)
958: FILE *file;
959: int yychar;
960: YYSTYPE yylval;
961: {
962: tree t;
963: switch (yychar)
964: {
965: case IDENTIFIER:
966: case TYPENAME:
967: case TYPESPEC:
968: case PTYPENAME:
969: case IDENTIFIER_DEFN:
970: case TYPENAME_DEFN:
971: case PTYPENAME_DEFN:
972: case TYPENAME_COLON:
973: case TYPENAME_ELLIPSIS:
974: case SCOPED_TYPENAME:
975: case SCSPEC:
976: t = yylval.ttype;
977: print_id:
978: my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
979: if (IDENTIFIER_POINTER (t))
980: fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
981: break;
982: case AGGR:
983: if (yylval.ttype == class_type_node)
984: fprintf (file, " `class'");
985: else if (yylval.ttype == record_type_node)
986: fprintf (file, " `struct'");
987: else if (yylval.ttype == union_type_node)
988: fprintf (file, " `union'");
989: else if (yylval.ttype == enum_type_node)
990: fprintf (file, " `enum'");
991: else
992: my_friendly_abort (80);
993: break;
994: case PRE_PARSED_CLASS_DECL:
995: t = yylval.ttype;
996: my_friendly_assert (TREE_CODE (t) == TREE_LIST, 225);
997: t = TREE_VALUE (t);
998: goto print_id;
999: }
1000: }
1001:
1002: static int *reduce_count;
1003: int *token_count;
1004:
1005: #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
1006: #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
1007:
1008: #ifdef YYDEBUG
1009: extern char * const yytname[];
1010: extern const char yytranslate[];
1011: #endif
1012:
1013: int *
1014: init_parse ()
1015: {
1016: #ifdef GATHER_STATISTICS
1017: reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
1018: bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
1019: reduce_count += 1;
1020: token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
1021: bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
1022: token_count += 1;
1023: #endif
1024: return token_count;
1025: }
1026:
1027: #ifdef GATHER_STATISTICS
1028: void
1029: yyhook (yyn)
1030: int yyn;
1031: {
1032: reduce_count[yyn] += 1;
1033: }
1034: #endif
1035:
1036: static int
1037: reduce_cmp (p, q)
1038: int *p, *q;
1039: {
1040: return reduce_count[*q] - reduce_count[*p];
1041: }
1042:
1043: static int
1044: token_cmp (p, q)
1045: int *p, *q;
1046: {
1047: return token_count[*q] - token_count[*p];
1048: }
1049:
1050: void
1051: print_parse_statistics ()
1052: {
1053: #ifdef GATHER_STATISTICS
1054: #if YYDEBUG != 0
1055: int i;
1056: int maxlen = REDUCE_LENGTH;
1057: unsigned *sorted;
1058:
1059: if (reduce_count[-1] == 0)
1060: return;
1061:
1062: if (TOKEN_LENGTH > REDUCE_LENGTH)
1063: maxlen = TOKEN_LENGTH;
1064: sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1065:
1066: for (i = 0; i < TOKEN_LENGTH; i++)
1067: sorted[i] = i;
1068: qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1069: for (i = 0; i < TOKEN_LENGTH; i++)
1070: {
1071: int index = sorted[i];
1072: if (token_count[index] == 0)
1073: break;
1074: if (token_count[index] < token_count[-1])
1075: break;
1076: fprintf (stderr, "token %d, `%s', count = %d\n",
1077: index, yytname[YYTRANSLATE (index)], token_count[index]);
1078: }
1079: fprintf (stderr, "\n");
1080: for (i = 0; i < REDUCE_LENGTH; i++)
1081: sorted[i] = i;
1082: qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1083: for (i = 0; i < REDUCE_LENGTH; i++)
1084: {
1085: int index = sorted[i];
1086: if (reduce_count[index] == 0)
1087: break;
1088: if (reduce_count[index] < reduce_count[-1])
1089: break;
1090: fprintf (stderr, "rule %d, line %d, count = %d\n",
1091: index, yyrline[index], reduce_count[index]);
1092: }
1093: fprintf (stderr, "\n");
1094: #endif
1095: #endif
1096: }
1097:
1098: /* Sets the value of the 'yydebug' variable to VALUE.
1099: This is a function so we don't have to have YYDEBUG defined
1100: in order to build the compiler. */
1101: void
1102: set_yydebug (value)
1103: int value;
1104: {
1105: #if YYDEBUG != 0
1106: extern int yydebug;
1107: yydebug = value;
1108: #else
1109: warning ("YYDEBUG not defined.");
1110: #endif
1111: }
1112:
1113: #ifdef SPEW_DEBUG
1114: const char *
1115: debug_yytranslate (value)
1116: int value;
1117: {
1118: return yytname[YYTRANSLATE (value)];
1119: }
1120:
1121: #endif
1122:
1123: /* Functions and data structures for #pragma interface.
1124:
1125: `#pragma implementation' means that the main file being compiled
1126: is considered to implement (provide) the classes that appear in
1127: its main body. I.e., if this is file "foo.cc", and class `bar'
1128: is defined in "foo.cc", then we say that "foo.cc implements bar".
1129:
1130: All main input files "implement" themselves automagically.
1131:
1132: `#pragma interface' means that unless this file (of the form "foo.h"
1133: is not presently being included by file "foo.cc", the
1134: CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1135: of the vtables nor any of the inline functions defined in foo.h
1136: will ever be output.
1137:
1138: There are cases when we want to link files such as "defs.h" and
1139: "main.cc". In this case, we give "defs.h" a `#pragma interface',
1140: and "main.cc" has `#pragma implementation "defs.h"'. */
1141:
1142: struct impl_files
1143: {
1144: char *filename;
1145: struct impl_files *next;
1146: };
1147:
1148: static struct impl_files *impl_file_chain;
1149:
1150: /* Helper function to load global variables with interface
1151: information. */
1152: void
1153: extract_interface_info ()
1154: {
1155: tree fileinfo;
1156: #if 0 /* Maybe later. -jason */
1157: struct tinst_level *til;
1158:
1159: if (til = tinst_for_decl())
1160: fileinfo = get_time_identifier (til->file);
1161: else
1162: #endif
1163: fileinfo = get_time_identifier (input_filename);
1164: fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
1165: interface_only = TREE_INT_CST_LOW (fileinfo);
1166: if (!processing_template_defn || flag_external_templates)
1167: interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1168: }
1169:
1170: /* Return nonzero if S and T are not considered part of an
1171: INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1172: static int
1173: interface_strcmp (s)
1174: char *s;
1175: {
1176: /* Set the interface/implementation bits for this scope. */
1177: struct impl_files *ifiles;
1178: char *s1;
1179:
1180: s = FILE_NAME_NONDIRECTORY (s);
1181:
1182: for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1183: {
1184: char *t1 = ifiles->filename;
1185: s1 = s;
1186:
1187: if (*s1 != *t1 || *s1 == 0)
1188: continue;
1189:
1190: while (*s1 == *t1 && *s1 != 0)
1191: s1++, t1++;
1192:
1193: /* A match. */
1194: if (*s1 == *t1)
1195: return 0;
1196:
1197: /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1198: if (index (s1, '.') || index (t1, '.'))
1199: continue;
1200:
1201: if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1202: continue;
1203:
1204: /* A match. */
1205: return 0;
1206: }
1207:
1208: /* No matches. */
1209: return 1;
1210: }
1211:
1212: void
1213: set_typedecl_interface_info (prev, vars)
1214: tree prev, vars;
1215: {
1216: tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
1217: tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
1218: tree type = TREE_TYPE (vars);
1219:
1220: CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
1221: = interface_strcmp (DECL_SOURCE_FILE (vars));
1222: }
1223:
1224: void
1225: set_vardecl_interface_info (prev, vars)
1226: tree prev, vars;
1227: {
1228: tree type = DECL_CONTEXT (vars);
1229:
1230: if (CLASSTYPE_INTERFACE_KNOWN (type))
1231: {
1232: if (CLASSTYPE_INTERFACE_ONLY (type))
1233: set_typedecl_interface_info (prev, TYPE_NAME (type));
1234: else
1235: CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
1236: DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
1237: TREE_PUBLIC (vars) = 1;
1238: }
1239: }
1240:
1241: /* Called from the top level: if there are any pending inlines to
1242: do, set up to process them now. */
1243: void
1244: do_pending_inlines ()
1245: {
1246: struct pending_inline *prev = 0, *tail;
1247: struct pending_inline *t;
1248:
1249: /* Reverse the pending inline functions, since
1250: they were cons'd instead of appended. */
1251:
1252: for (t = pending_inlines; t; t = tail)
1253: {
1254: t->deja_vu = 1;
1255: tail = t->next;
1256: t->next = prev;
1257: prev = t;
1258: }
1259: /* Reset to zero so that if the inline functions we are currently
1260: processing define inline functions of their own, that is handled
1261: correctly. ??? This hasn't been checked in a while. */
1262: pending_inlines = 0;
1263:
1264: /* Now start processing the first inline function. */
1265: t = prev;
1266: my_friendly_assert ((t->parm_vec == NULL_TREE) == (t->bindings == NULL_TREE),
1267: 226);
1268: if (t->parm_vec)
1269: push_template_decls (t->parm_vec, t->bindings, 0);
1270: if (t->len > 0)
1271: {
1272: feed_input (t->buf, t->len, t->can_free ? &inline_text_obstack : 0);
1273: lineno = t->lineno;
1274: #if 0
1275: if (input_filename != t->filename)
1276: {
1277: input_filename = t->filename;
1278: /* Get interface/implementation back in sync. */
1279: extract_interface_info ();
1280: }
1281: #else
1282: input_filename = t->filename;
1283: interface_unknown = t->interface == 1;
1284: interface_only = t->interface == 0;
1285: #endif
1286: yychar = PRE_PARSED_FUNCTION_DECL;
1287: }
1288: /* Pass back a handle on the rest of the inline functions, so that they
1289: can be processed later. */
1290: yylval.ttype = build_tree_list ((tree) t, t->fndecl);
1291: if (flag_default_inline && t->fndecl
1292: /* If we're working from a template, don't change
1293: the `inline' state. */
1294: && t->parm_vec == NULL_TREE)
1295: DECL_INLINE (t->fndecl) = 1;
1296: DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
1297: }
1298:
1299: extern struct pending_input *to_be_restored;
1300: static int nextchar = -1;
1301:
1302: void
1303: process_next_inline (t)
1304: tree t;
1305: {
1306: struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
1307: my_friendly_assert ((i->parm_vec == NULL_TREE) == (i->bindings == NULL_TREE),
1308: 227);
1309: if (i->parm_vec)
1310: pop_template_decls (i->parm_vec, i->bindings, 0);
1311: i = i->next;
1312: if (yychar == YYEMPTY)
1313: yychar = yylex ();
1314: if (yychar != END_OF_SAVED_INPUT)
1315: {
1316: error ("parse error at end of saved function text");
1317: /* restore_pending_input will abort unless yychar is either
1318: * END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1319: * hosed, feed back YYEMPTY.
1320: * We also need to discard nextchar, since that may have gotten
1321: * set as well.
1322: */
1323: nextchar = -1;
1324: }
1325: yychar = YYEMPTY;
1326: if (to_be_restored == 0)
1327: my_friendly_abort (123);
1328: restore_pending_input (to_be_restored);
1329: to_be_restored = 0;
1330: if (i && i->fndecl != NULL_TREE)
1331: {
1332: my_friendly_assert ((i->parm_vec == NULL_TREE) == (i->bindings == NULL_TREE),
1333: 228);
1334: if (i->parm_vec)
1335: push_template_decls (i->parm_vec, i->bindings, 0);
1336: feed_input (i->buf, i->len, i->can_free ? &inline_text_obstack : 0);
1337: lineno = i->lineno;
1338: input_filename = i->filename;
1339: yychar = PRE_PARSED_FUNCTION_DECL;
1340: yylval.ttype = build_tree_list ((tree) i, i->fndecl);
1341: if (flag_default_inline
1342: /* If we're working from a template, don't change
1343: the `inline' state. */
1344: && i->parm_vec == NULL_TREE)
1345: DECL_INLINE (i->fndecl) = 1;
1346: DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
1347: }
1348: if (i)
1349: {
1350: interface_unknown = i->interface == 1;
1351: interface_only = i->interface == 0;
1352: }
1353: else
1354: extract_interface_info ();
1355: }
1356:
1357: /* Since inline methods can refer to text which has not yet been seen,
1358: we store the text of the method in a structure which is placed in the
1359: DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1360: After parsing the body of the class definition, the FUNCTION_DECL's are
1361: scanned to see which ones have this field set. Those are then digested
1362: one at a time.
1363:
1364: This function's FUNCTION_DECL will have a bit set in its common so
1365: that we know to watch out for it. */
1366:
1367: static void
1368: consume_string (this_obstack, matching_char)
1369: register struct obstack *this_obstack;
1370: int matching_char;
1371: {
1372: register int c;
1373: int starting_lineno = lineno;
1374: do
1375: {
1376: c = getch ();
1377: if (c == EOF)
1378: {
1379: int save_lineno = lineno;
1380: lineno = starting_lineno;
1381: if (matching_char == '"')
1382: error ("end of file encountered inside string constant");
1383: else
1384: error ("end of file encountered inside character constant");
1385: lineno = save_lineno;
1386: return;
1387: }
1388: if (c == '\\')
1389: {
1390: obstack_1grow (this_obstack, c);
1391: c = getch ();
1392: obstack_1grow (this_obstack, c);
1393:
1394: /* Make sure we continue the loop */
1395: c = 0;
1396: continue;
1397: }
1398: if (c == '\n')
1399: {
1400: if (pedantic)
1401: pedwarn ("ANSI C++ forbids newline in string constant");
1402: lineno++;
1403: }
1404: obstack_1grow (this_obstack, c);
1405: }
1406: while (c != matching_char);
1407: }
1408:
1409: static int nextyychar = YYEMPTY;
1410: static YYSTYPE nextyylval;
1411:
1412: struct pending_input {
1413: int nextchar, yychar, nextyychar, eof;
1414: YYSTYPE yylval, nextyylval;
1415: struct obstack token_obstack;
1416: int first_token;
1417: };
1418:
1419: struct pending_input *
1420: save_pending_input ()
1421: {
1422: struct pending_input *p;
1423: p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1424: p->nextchar = nextchar;
1425: p->yychar = yychar;
1426: p->nextyychar = nextyychar;
1427: p->yylval = yylval;
1428: p->nextyylval = nextyylval;
1429: p->eof = end_of_file;
1430: yychar = nextyychar = YYEMPTY;
1431: nextchar = -1;
1432: p->first_token = first_token;
1433: p->token_obstack = token_obstack;
1434:
1435: first_token = 0;
1436: gcc_obstack_init (&token_obstack);
1437: end_of_file = 0;
1438: return p;
1439: }
1440:
1441: void
1442: restore_pending_input (p)
1443: struct pending_input *p;
1444: {
1445: my_friendly_assert (nextchar == -1, 229);
1446: nextchar = p->nextchar;
1447: my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1448: yychar = p->yychar;
1449: my_friendly_assert (nextyychar == YYEMPTY, 231);
1450: nextyychar = p->nextyychar;
1451: yylval = p->yylval;
1452: nextyylval = p->nextyylval;
1453: first_token = p->first_token;
1454: obstack_free (&token_obstack, (char *) 0);
1455: token_obstack = p->token_obstack;
1456: end_of_file = p->eof;
1457: free (p);
1458: }
1459:
1460: /* Return next non-whitespace input character, which may come
1461: from `finput', or from `nextchar'. */
1462: static int
1463: yynextch ()
1464: {
1465: int c;
1466:
1467: if (nextchar >= 0)
1468: {
1469: c = nextchar;
1470: nextchar = -1;
1471: }
1472: else c = getch ();
1473: return skip_white_space (c);
1474: }
1475:
1476: /* Unget character CH from the input stream.
1477: If RESCAN is non-zero, then we want to `see' this
1478: character as the next input token. */
1479: void
1480: yyungetc (ch, rescan)
1481: int ch;
1482: int rescan;
1483: {
1484: /* Unget a character from the input stream. */
1485: if (yychar == YYEMPTY || rescan == 0)
1486: {
1487: if (nextchar >= 0)
1488: put_back (nextchar);
1489: nextchar = ch;
1490: }
1491: else
1492: {
1493: my_friendly_assert (nextyychar == YYEMPTY, 232);
1494: nextyychar = yychar;
1495: nextyylval = yylval;
1496: yychar = ch;
1497: }
1498: }
1499:
1500: /* This function stores away the text for an inline function that should
1501: be processed later. It decides how much later, and may need to move
1502: the info between obstacks; therefore, the caller should not refer to
1503: the T parameter after calling this function.
1504:
1505: This function also stores the list of template-parameter bindings that
1506: will be needed for expanding the template, if any. */
1507:
1508: static void
1509: store_pending_inline (decl, t)
1510: tree decl;
1511: struct pending_inline *t;
1512: {
1513: extern int processing_template_defn;
1514: int delay_to_eof = 0;
1515: struct pending_inline **inlines;
1516:
1517: t->fndecl = decl;
1518: /* Default: compile right away, and no extra bindings are needed. */
1519: t->parm_vec = t->bindings = 0;
1520: if (processing_template_defn)
1521: {
1522: tree type = current_class_type;
1523: /* Assumption: In this (possibly) nested class sequence, only
1524: one name will have template parms. */
1525: while (type && TREE_CODE_CLASS (TREE_CODE (type)) == 't')
1526: {
1527: tree decl = TYPE_NAME (type);
1528: tree tmpl = IDENTIFIER_TEMPLATE (DECL_NAME (decl));
1529: if (tmpl)
1530: {
1531: t->parm_vec = DECL_TEMPLATE_INFO (TREE_PURPOSE (tmpl))->parm_vec;
1532: t->bindings = TREE_VALUE (tmpl);
1533: }
1534: type = DECL_CONTEXT (decl);
1535: }
1536: if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
1537: || TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1538: {
1539: if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
1540: my_friendly_assert (TYPE_MAX_VALUE (TREE_TYPE (decl)) == current_class_type,
1541: 233);
1542:
1543: /* Inline functions can be compiled immediately. Other functions
1544: will be output separately, so if we're in interface-only mode,
1545: punt them now, or output them now if we're doing implementations
1546: and we know no overrides will exist. Otherwise, we delay until
1547: end-of-file, to see if the definition is really required. */
1548: if (DECL_INLINE (decl))
1549: /* delay_to_eof == 0 */;
1550: else if (current_class_type && !interface_unknown)
1551: {
1552: if (interface_only)
1553: {
1554: #if 0
1555: print_node_brief (stderr, "\ndiscarding text for ", decl, 0);
1556: #endif
1557: if (t->can_free)
1558: obstack_free (&inline_text_obstack, t->buf);
1559: DECL_PENDING_INLINE_INFO (decl) = 0;
1560: return;
1561: }
1562: }
1563: /* Don't delay the processing of virtual functions. */
1564: else if (DECL_VINDEX (decl) == NULL_TREE)
1565: delay_to_eof = 1;
1566: }
1567: else
1568: my_friendly_abort (58);
1569: }
1570:
1571: if (delay_to_eof)
1572: {
1573: extern struct pending_inline *pending_template_expansions;
1574:
1575: if (t->can_free)
1576: {
1577: char *free_to = t->buf;
1578: t->buf = (char *) obstack_copy (&permanent_obstack, t->buf,
1579: t->len + 1);
1580: t = (struct pending_inline *) obstack_copy (&permanent_obstack,
1581: (char *)t, sizeof (*t));
1582: obstack_free (&inline_text_obstack, free_to);
1583: }
1584: inlines = &pending_template_expansions;
1585: t->can_free = 0;
1586: }
1587: else
1588: {
1589: inlines = &pending_inlines;
1590: DECL_PENDING_INLINE_INFO (decl) = t;
1591: }
1592:
1593: /* Because we use obstacks, we must process these in precise order. */
1594: t->next = *inlines;
1595: *inlines = t;
1596: }
1597:
1598: void reinit_parse_for_block ();
1599:
1600: void
1601: reinit_parse_for_method (yychar, decl)
1602: int yychar;
1603: tree decl;
1604: {
1605: int len;
1606: int starting_lineno = lineno;
1607: char *starting_filename = input_filename;
1608:
1609: reinit_parse_for_block (yychar, &inline_text_obstack, 0);
1610:
1611: len = obstack_object_size (&inline_text_obstack);
1612: current_base_init_list = NULL_TREE;
1613: current_member_init_list = NULL_TREE;
1614: if (decl == void_type_node
1615: || (current_class_type && TYPE_REDEFINED (current_class_type)))
1616: {
1617: /* Happens when we get two declarations of the same
1618: function in the same scope. */
1619: char *buf = obstack_finish (&inline_text_obstack);
1620: obstack_free (&inline_text_obstack, buf);
1621: return;
1622: }
1623: else
1624: {
1625: struct pending_inline *t;
1626: char *buf = obstack_finish (&inline_text_obstack);
1627:
1628: t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1629: sizeof (struct pending_inline));
1630: t->lineno = starting_lineno;
1631: t->filename = starting_filename;
1632: t->token = YYEMPTY;
1633: t->token_value = 0;
1634: t->buf = buf;
1635: t->len = len;
1636: t->can_free = 1;
1637: t->deja_vu = 0;
1638: if (interface_unknown && processing_template_defn && flag_external_templates)
1639: warn_if_unknown_interface ();
1640: t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1641: store_pending_inline (decl, t);
1642: }
1643: }
1644:
1645: /* Consume a block -- actually, a method or template definition beginning
1646: with `:' or `{' -- and save it away on the specified obstack.
1647:
1648: Argument IS_TEMPLATE indicates which set of error messages should be
1649: output if something goes wrong. This should really be cleaned up somehow,
1650: without loss of clarity. */
1651: void
1652: reinit_parse_for_block (yychar, obstackp, is_template)
1653: int yychar;
1654: struct obstack *obstackp;
1655: int is_template;
1656: {
1657: register int c = 0;
1658: int blev = 1;
1659: int starting_lineno = lineno;
1660: char *starting_filename = input_filename;
1661: int len;
1662: int look_for_semicolon = 0;
1663: int look_for_lbrac = 0;
1664:
1665: if (yychar == '{')
1666: obstack_1grow (obstackp, '{');
1667: else if (yychar == '=')
1668: look_for_semicolon = 1;
1669: else if (yychar != ':' && (yychar != RETURN || is_template))
1670: {
1671: yyerror (is_template
1672: ? "parse error in template specification"
1673: : "parse error in method specification");
1674: obstack_1grow (obstackp, '{');
1675: }
1676: else
1677: {
1678: obstack_1grow (obstackp, yychar);
1679: look_for_lbrac = 1;
1680: blev = 0;
1681: }
1682:
1683: if (nextchar != EOF)
1684: {
1685: c = nextchar;
1686: nextchar = EOF;
1687: }
1688: else
1689: c = getch ();
1690:
1691: while (c != EOF)
1692: {
1693: int this_lineno = lineno;
1694:
1695: c = skip_white_space (c);
1696:
1697: /* Don't lose our cool if there are lots of comments. */
1698: if (lineno == this_lineno + 1)
1699: obstack_1grow (obstackp, '\n');
1700: else if (lineno == this_lineno)
1701: ;
1702: else if (lineno - this_lineno < 10)
1703: {
1704: int i;
1705: for (i = lineno - this_lineno; i > 0; i--)
1706: obstack_1grow (obstackp, '\n');
1707: }
1708: else
1709: {
1710: char buf[16];
1711: sprintf (buf, "\n# %d \"", lineno);
1712: len = strlen (buf);
1713: obstack_grow (obstackp, buf, len);
1714:
1715: len = strlen (input_filename);
1716: obstack_grow (obstackp, input_filename, len);
1717: obstack_1grow (obstackp, '\"');
1718: obstack_1grow (obstackp, '\n');
1719: }
1720:
1721: while (c > ' ') /* ASCII dependent... */
1722: {
1723: obstack_1grow (obstackp, c);
1724: if (c == '{')
1725: {
1726: look_for_lbrac = 0;
1727: blev++;
1728: }
1729: else if (c == '}')
1730: {
1731: blev--;
1732: if (blev == 0 && !look_for_semicolon)
1733: goto done;
1734: }
1735: else if (c == '\\')
1736: {
1737: /* Don't act on the next character...e.g, doing an escaped
1738: double-quote. */
1739: c = getch ();
1740: if (c == EOF)
1741: {
1742: error_with_file_and_line (starting_filename,
1743: starting_lineno,
1744: "end of file read inside definition");
1745: goto done;
1746: }
1747: obstack_1grow (obstackp, c);
1748: }
1749: else if (c == '\"')
1750: consume_string (obstackp, c);
1751: else if (c == '\'')
1752: consume_string (obstackp, c);
1753: else if (c == ';')
1754: {
1755: if (look_for_lbrac)
1756: {
1757: error (is_template
1758: ? "template body missing"
1759: : "function body for constructor missing");
1760: obstack_1grow (obstackp, '{');
1761: obstack_1grow (obstackp, '}');
1762: len += 2;
1763: goto done;
1764: }
1765: else if (look_for_semicolon && blev == 0)
1766: goto done;
1767: }
1768: c = getch ();
1769: }
1770:
1771: if (c == EOF)
1772: {
1773: error_with_file_and_line (starting_filename,
1774: starting_lineno,
1775: "end of file read inside definition");
1776: goto done;
1777: }
1778: else if (c != '\n')
1779: {
1780: obstack_1grow (obstackp, c);
1781: c = getch ();
1782: }
1783: }
1784: done:
1785: obstack_1grow (obstackp, '\0');
1786: }
1787:
1788: /* Build a default function named NAME for type TYPE.
1789: KIND says what to build.
1790:
1791: When KIND == 0, build default destructor.
1792: When KIND == 1, build virtual destructor.
1793: When KIND == 2, build default constructor.
1794: When KIND == 3, build default X(const X&) constructor.
1795: When KIND == 4, build default X(X&) constructor. */
1796:
1797: tree
1798: cons_up_default_function (type, name, fields, kind)
1799: tree type, name, fields;
1800: int kind;
1801: {
1802: extern tree void_list_node;
1803: char *func_buf = NULL;
1804: int func_len = 0;
1805: tree declspecs = NULL_TREE;
1806: tree fn, args;
1807: tree argtype;
1808:
1809: name = constructor_name (name);
1810: switch (kind)
1811: {
1812: /* Destructors. */
1813: case 1:
1814: declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
1815: /* Fall through... */
1816: case 0:
1817: name = build_parse_node (BIT_NOT_EXPR, name);
1818: /* Fall through... */
1819: case 2:
1820: /* Default constructor. */
1821: args = void_list_node;
1822: {
1823: if (declspecs)
1824: declspecs = decl_tree_cons (NULL_TREE,
1825: ridpointers [(int) RID_INLINE],
1826: declspecs);
1827: else
1828: declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_INLINE]);
1829: }
1830: break;
1831:
1832: case 3:
1833: type = build_type_variant (type, 1, 0);
1834: /* Fall through... */
1835: case 4:
1836: /* According to ARM $12.8, the default copy ctor will be declared, but
1837: not defined, unless it's needed. So we mark this as `inline'; that
1838: way, if it's never used it won't be emitted. */
1839: declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_INLINE]);
1840:
1841: argtype = build_reference_type (type);
1842: args = tree_cons (NULL_TREE,
1843: build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1844: get_identifier ("_ctor_arg")),
1845: void_list_node);
1846: default_copy_constructor_body (&func_buf, &func_len, type, fields);
1847: break;
1848:
1849: default:
1850: my_friendly_abort (59);
1851: }
1852:
1853: if (!func_buf)
1854: {
1855: func_len = 2;
1856: func_buf = obstack_alloc (&inline_text_obstack, func_len);
1857: strcpy (func_buf, "{}");
1858: }
1859:
1860: fn = start_method (declspecs,
1861: build_parse_node (CALL_EXPR, name, args, NULL_TREE),
1862: NULL_TREE);
1863: if (fn == void_type_node)
1864: return fn;
1865:
1866: current_base_init_list = NULL_TREE;
1867: current_member_init_list = NULL_TREE;
1868:
1869: {
1870: struct pending_inline *t;
1871:
1872: t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1873: sizeof (struct pending_inline));
1874: t->lineno = lineno;
1875:
1876: #if 1
1877: t->filename = input_filename;
1878: #else /* This breaks; why? */
1879: #define MGMSG "(synthetic code at) "
1880: t->filename = obstack_alloc (&inline_text_obstack,
1881: strlen (input_filename) + sizeof (MGMSG) + 1);
1882: strcpy (t->filename, MGMSG);
1883: strcat (t->filename, input_filename);
1884: #endif
1885: t->token = YYEMPTY;
1886: t->token_value = 0;
1887: t->buf = func_buf;
1888: t->len = func_len;
1889: t->can_free = 1;
1890: t->deja_vu = 0;
1891: if (interface_unknown && processing_template_defn && flag_external_templates)
1892: warn_if_unknown_interface ();
1893: t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1894: store_pending_inline (fn, t);
1895: if (interface_unknown)
1896: TREE_PUBLIC (fn) = 0;
1897: else
1898: {
1899: TREE_PUBLIC (fn) = 1;
1900: DECL_EXTERNAL (fn) = interface_only;
1901: }
1902: }
1903:
1904: finish_method (fn);
1905:
1906: #ifdef DEBUG_DEFAULT_FUNCTIONS
1907: { char *fn_type = NULL;
1908: tree t = name;
1909: switch (kind)
1910: {
1911: case 0: fn_type = "default destructor"; break;
1912: case 1: fn_type = "virtual destructor"; break;
1913: case 2: fn_type = "default constructor"; break;
1914: case 3: fn_type = "default X(const X&)"; break;
1915: case 4: fn_type = "default X(X&)"; break;
1916: }
1917: if (fn_type)
1918: {
1919: if (TREE_CODE (name) == BIT_NOT_EXPR)
1920: t = TREE_OPERAND (name, 0);
1921: fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
1922: IDENTIFIER_POINTER (t), func_buf);
1923: }
1924: }
1925: #endif /* DEBUG_DEFAULT_FUNCTIONS
1926:
1927: DECL_CLASS_CONTEXT (fn) = type;
1928: /* Show that this function was generated by the compiler. */
1929: DECL_SOURCE_LINE (fn) = 0;
1930: return fn;
1931: }
1932:
1933: /* Used by default_copy_constructor_body. For the anonymous union
1934: in TYPE, return the member that is at least as large as the rest
1935: of the members, so we can copy it. */
1936: static tree
1937: largest_union_member (type)
1938: tree type;
1939: {
1940: tree f, type_size = TYPE_SIZE (type);
1941:
1942: for (f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f))
1943: if (simple_cst_equal (DECL_SIZE (f), type_size))
1944: return f;
1945:
1946: /* We should always find one. */
1947: my_friendly_abort (323);
1948: }
1949:
1950: /* Construct the body of a default copy constructor. */
1951: static void
1952: default_copy_constructor_body (bufp, lenp, type, fields)
1953: char **bufp;
1954: int *lenp;
1955: tree type, fields;
1956: {
1957: static struct obstack prologue, body;
1958: static int inited = FALSE;
1959: int n_bases = CLASSTYPE_N_BASECLASSES (type);
1960: char sep = ':';
1961: char *tbuf;
1962: int tgot, tneed;
1963:
1964: /* Create two buffers: One of them, the prologue, calls base class
1965: constructors and constructs members (fields). The other one, the
1966: body, assigns base classes without constructors. */
1967:
1968: if (!inited)
1969: {
1970: obstack_init (&prologue);
1971: obstack_init (&body);
1972: inited = TRUE;
1973: }
1974: prologue.next_free = prologue.object_base;
1975: body.next_free = body.object_base;
1976:
1977: obstack_1grow (&body, '{');
1978:
1979: /* Small buffer for sprintf(). */
1980:
1981: tgot = 100;
1982: tbuf = (char *) alloca (tgot);
1983:
1984: /* Construct base classes... */
1985:
1986: if (n_bases)
1987: {
1988: /* Note that CLASSTYPE_VBASECLASSES isn't set yet... */
1989: tree v = get_vbase_types (type);
1990: tree bases = TYPE_BINFO_BASETYPES (type);
1991: int i = 0;
1992:
1993: for (;;)
1994: {
1995: tree binfo, btype, name;
1996: char *s, *p;
1997:
1998: if (v)
1999: {
2000: binfo = v;
2001: v = TREE_CHAIN (v);
2002: }
2003: else if (i < n_bases)
2004: {
2005: binfo = TREE_VEC_ELT (bases, i++);
2006: if (TREE_VIA_VIRTUAL (binfo))
2007: continue;
2008: }
2009: else
2010: break;
2011:
2012: btype = BINFO_TYPE (binfo);
2013: name = TYPE_NAME (btype);
2014: if (TREE_CODE (name) == TYPE_DECL)
2015: name = DECL_NAME (name);
2016: s = IDENTIFIER_POINTER (name);
2017:
2018: tneed = (2 * strlen (s)) + 30;
2019: if (tgot < tneed)
2020: {
2021: tgot = tneed;
2022: tbuf = (char *) alloca (tgot);
2023: }
2024:
2025: if (TYPE_HAS_CONSTRUCTOR (btype))
2026: {
2027: sprintf (tbuf, "%c%s((%s&)_ctor_arg)", sep, s, s);
2028: sep = ',';
2029: obstack_grow (&prologue, tbuf, strlen (tbuf));
2030: }
2031: else
2032: {
2033: sprintf (tbuf, "*(%s*)this=(%s&)_ctor_arg;", s, s);
2034: obstack_grow (&body, tbuf, strlen (tbuf));
2035: }
2036: }
2037: }
2038:
2039: /* Construct fields. */
2040:
2041: if (fields)
2042: {
2043: tree f;
2044:
2045: for (f = fields; f; f = TREE_CHAIN (f))
2046: {
2047: if (TREE_CODE (f) == FIELD_DECL && ! DECL_VIRTUAL_P (f))
2048: {
2049: char *s, *p;
2050: tree x;
2051: tree t = TREE_TYPE (f);
2052:
2053: if (DECL_NAME (f))
2054: x = f;
2055: else if (t != NULL_TREE
2056: && TREE_CODE (t) == UNION_TYPE
2057: && ((TREE_CODE (TYPE_NAME (t)) == IDENTIFIER_NODE
2058: && ANON_AGGRNAME_P (TYPE_NAME (t)))
2059: || (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
2060: && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t))))
2061: && TYPE_FIELDS (t) != NULL_TREE)
2062: x = largest_union_member (t);
2063: else
2064: continue;
2065:
2066: s = IDENTIFIER_POINTER (DECL_NAME (x));
2067: tneed = (2 * strlen (s)) + 30;
2068: if (tgot < tneed)
2069: {
2070: tgot = tneed;
2071: tbuf = (char *) alloca (tgot);
2072: }
2073:
2074: sprintf (tbuf, "%c%s(_ctor_arg.%s)", sep, s, s);
2075: sep = ',';
2076: obstack_grow (&prologue, tbuf, strlen (tbuf));
2077: }
2078: }
2079: }
2080:
2081: /* Concatenate constructor body to prologue, and free body. */
2082: obstack_1grow (&body, '}');
2083:
2084: *lenp = obstack_object_size (&prologue) + obstack_object_size (&body);
2085: *bufp = obstack_alloc (&inline_text_obstack, *lenp + 1);
2086:
2087: obstack_1grow (&prologue, '\0');
2088: obstack_1grow (&body, '\0');
2089:
2090: strcpy (*bufp, prologue.object_base);
2091: strcat (*bufp, body.object_base);
2092: }
2093:
2094: /* Heuristic to tell whether the user is missing a semicolon
2095: after a struct or enum declaration. Emit an error message
2096: if we know the user has blown it. */
2097: void
2098: check_for_missing_semicolon (type)
2099: tree type;
2100: {
2101: if (yychar < 0)
2102: yychar = yylex ();
2103:
2104: if (yychar > 255
2105: && yychar != SCSPEC
2106: && yychar != IDENTIFIER
2107: && yychar != TYPENAME)
2108: {
2109: if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2110: error ("semicolon missing after %s declaration",
2111: TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2112: else
2113: error ("semicolon missing after declaration of `%s'",
2114: TYPE_NAME_STRING (type));
2115: shadow_tag (build_tree_list (0, type));
2116: }
2117: /* Could probably also hack cases where class { ... } f (); appears. */
2118: clear_anon_tags ();
2119: }
2120:
2121: void
2122: note_got_semicolon (type)
2123: tree type;
2124: {
2125: if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
2126: my_friendly_abort (60);
2127: if (IS_AGGR_TYPE (type))
2128: CLASSTYPE_GOT_SEMICOLON (type) = 1;
2129: }
2130:
2131: void
2132: note_list_got_semicolon (declspecs)
2133: tree declspecs;
2134: {
2135: tree link;
2136:
2137: for (link = declspecs; link; link = TREE_CHAIN (link))
2138: {
2139: tree type = TREE_VALUE (link);
2140: if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
2141: note_got_semicolon (type);
2142: }
2143: clear_anon_tags ();
2144: }
2145:
2146: /* If C is not whitespace, return C.
2147: Otherwise skip whitespace and return first nonwhite char read. */
2148:
2149: static int
2150: skip_white_space (c)
2151: register int c;
2152: {
2153: for (;;)
2154: {
2155: switch (c)
2156: {
2157: case '\n':
2158: c = check_newline ();
2159: break;
2160:
2161: case ' ':
2162: case '\t':
2163: case '\f':
2164: case '\r':
2165: case '\v':
2166: case '\b':
2167: do
2168: c = getch ();
2169: while (c == ' ' || c == '\t');
2170: break;
2171:
2172: case '\\':
2173: c = getch ();
2174: if (c == '\n')
2175: lineno++;
2176: else
2177: error ("stray '\\' in program");
2178: c = getch ();
2179: break;
2180:
2181: default:
2182: return (c);
2183: }
2184: }
2185: }
2186:
2187:
2188:
2189: /* Make the token buffer longer, preserving the data in it.
2190: P should point to just beyond the last valid character in the old buffer.
2191: The value we return is a pointer to the new buffer
2192: at a place corresponding to P. */
2193:
2194: static char *
2195: extend_token_buffer (p)
2196: char *p;
2197: {
2198: int offset = p - token_buffer;
2199:
2200: maxtoken = maxtoken * 2 + 10;
2201: token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2202:
2203: return token_buffer + offset;
2204: }
2205:
2206: static int
2207: get_last_nonwhite_on_line ()
2208: {
2209: register int c;
2210:
2211: /* Is this the last nonwhite stuff on the line? */
2212: if (nextchar >= 0)
2213: c = nextchar, nextchar = -1;
2214: else
2215: c = getch ();
2216:
2217: while (c == ' ' || c == '\t')
2218: c = getch ();
2219: return c;
2220: }
2221:
2222: /* At the beginning of a line, increment the line number
2223: and process any #-directive on this line.
2224: If the line is a #-directive, read the entire line and return a newline.
2225: Otherwise, return the line's first non-whitespace character. */
2226:
2227: int
2228: check_newline ()
2229: {
2230: register int c;
2231: register int token;
2232:
2233: lineno++;
2234:
2235: /* Read first nonwhite char on the line. */
2236:
2237: do
2238: c = getch ();
2239: while (c == ' ' || c == '\t');
2240:
2241: if (c != '#')
2242: {
2243: /* If not #, return it so caller will use it. */
2244: return c;
2245: }
2246:
2247: /* Read first nonwhite char after the `#'. */
2248:
2249: do
2250: c = getch ();
2251: while (c == ' ' || c == '\t');
2252:
2253: /* If a letter follows, then if the word here is `line', skip
2254: it and ignore it; otherwise, ignore the line, with an error
2255: if the word isn't `pragma'. */
2256:
2257: if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
2258: {
2259: if (c == 'p')
2260: {
2261: if (getch () == 'r'
2262: && getch () == 'a'
2263: && getch () == 'g'
2264: && getch () == 'm'
2265: && getch () == 'a')
2266: {
2267: /* Read first nonwhite char after the `#pragma'. */
2268:
2269: do
2270: c = getch ();
2271: while (c == ' ' || c == '\t');
2272:
2273: if (c == 'c'
2274: && getch () == 'p'
2275: && getch () == 'l'
2276: && getch () == 'u'
2277: && getch () == 's'
2278: && getch () == 'p'
2279: && getch () == 'l'
2280: && getch () == 'u'
2281: && getch () == 's'
2282: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2283: {
2284: if (!in_system_header && current_lang_name != lang_name_cplusplus)
2285: error ("`#pragma cplusplus' used inside explicit `extern \"%s\"'",
2286: IDENTIFIER_POINTER (current_lang_name));
2287:
2288: goto skipline;
2289: }
2290: else if (c == 'v'
2291: && getch () == 't'
2292: && getch () == 'a'
2293: && getch () == 'b'
2294: && getch () == 'l'
2295: && getch () == 'e'
2296: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2297: {
2298: extern tree pending_vtables;
2299:
2300: /* More follows: it must be a string constant (class name). */
2301: token = real_yylex ();
2302: if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2303: {
2304: error ("invalid #pragma vtable");
2305: goto skipline;
2306: }
2307: if (write_virtuals != 2)
2308: {
2309: warning ("use `+e2' option to enable #pragma vtable");
2310: goto skipline;
2311: }
2312: pending_vtables = perm_tree_cons (NULL_TREE, get_identifier (TREE_STRING_POINTER (yylval.ttype)), pending_vtables);
2313: if (nextchar < 0)
2314: nextchar = getch ();
2315: c = nextchar;
2316: if (c != '\n')
2317: warning ("trailing characters ignored");
2318: }
2319: else if (c == 'u'
2320: && getch () == 'n'
2321: && getch () == 'i'
2322: && getch () == 't'
2323: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2324: {
2325: /* More follows: it must be a string constant (unit name). */
2326: token = real_yylex ();
2327: if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2328: {
2329: error ("invalid #pragma unit");
2330: goto skipline;
2331: }
2332: current_unit_name = get_identifier (TREE_STRING_POINTER (yylval.ttype));
2333: current_unit_language = current_lang_name;
2334: if (nextchar < 0)
2335: nextchar = getch ();
2336: c = nextchar;
2337: if (c != '\n')
2338: warning ("trailing characters ignored");
2339: }
2340: else if (c == 'i')
2341: {
2342: tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
2343: c = getch ();
2344:
2345: if (c == 'n'
2346: && getch () == 't'
2347: && getch () == 'e'
2348: && getch () == 'r'
2349: && getch () == 'f'
2350: && getch () == 'a'
2351: && getch () == 'c'
2352: && getch () == 'e'
2353: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2354: {
2355: int warned_interface = 0;
2356:
2357: /* Read to newline. */
2358:
2359: while (c != '\n')
2360: {
2361: c = getch ();
2362: if (!warned_interface && extra_warnings
2363: && c != ' ' && c != '\t' && c != '\n')
2364: {
2365: warning ("garbage after `#pragma interface' ignored");
2366: warned_interface = 1;
2367: }
2368: }
2369:
2370: write_virtuals = 3;
2371:
2372: if (impl_file_chain == 0)
2373: {
2374: char *filename;
2375: tree fi;
2376:
2377: /* If this is zero at this point, then we are
2378: auto-implementing. */
2379: if (main_input_filename == 0)
2380: main_input_filename = input_filename;
2381:
2382: filename = FILE_NAME_NONDIRECTORY (main_input_filename);
2383: fi = get_time_identifier (filename);
2384: fi = IDENTIFIER_CLASS_VALUE (fi);
2385: TREE_INT_CST_LOW (fi) = 0;
2386: TREE_INT_CST_HIGH (fi) = 1;
2387: /* Get default. */
2388: impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
2389: impl_file_chain->filename = filename;
2390: impl_file_chain->next = 0;
2391: }
2392:
2393: interface_only = interface_strcmp (input_filename);
2394: interface_unknown = 0;
2395: TREE_INT_CST_LOW (fileinfo) = interface_only;
2396: TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
2397: }
2398: else if (c == 'm'
2399: && getch () == 'p'
2400: && getch () == 'l'
2401: && getch () == 'e'
2402: && getch () == 'm'
2403: && getch () == 'e'
2404: && getch () == 'n'
2405: && getch () == 't'
2406: && getch () == 'a'
2407: && getch () == 't'
2408: && getch () == 'i'
2409: && getch () == 'o'
2410: && getch () == 'n'
2411: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2412: {
2413: char *main_filename = main_input_filename ? main_input_filename : input_filename;
2414:
2415: while (c == ' ' || c == '\t')
2416: c = getch ();
2417: if (c != '\n')
2418: {
2419: put_back (c);
2420: token = real_yylex ();
2421: if (token != STRING
2422: || TREE_CODE (yylval.ttype) != STRING_CST)
2423: {
2424: error ("invalid `#pragma implementation'");
2425: goto skipline;
2426: }
2427: main_filename = TREE_STRING_POINTER (yylval.ttype);
2428: }
2429: main_filename = FILE_NAME_NONDIRECTORY (main_filename);
2430:
2431: /* read to newline. */
2432: while (c != '\n')
2433: c = getch ();
2434:
2435: if (write_virtuals == 3)
2436: {
2437: struct impl_files *ifiles = impl_file_chain;
2438: while (ifiles)
2439: {
2440: if (! strcmp (ifiles->filename, main_filename))
2441: break;
2442: ifiles = ifiles->next;
2443: }
2444: if (ifiles == 0)
2445: {
2446: ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
2447: ifiles->filename = main_filename;
2448: ifiles->next = impl_file_chain;
2449: impl_file_chain = ifiles;
2450: }
2451: }
2452: else if ((main_input_filename != 0
2453: && ! strcmp (main_input_filename, input_filename))
2454: || ! strcmp (input_filename, main_filename))
2455: {
2456: write_virtuals = 3;
2457: if (impl_file_chain == 0)
2458: {
2459: impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
2460: impl_file_chain->filename = main_filename;
2461: impl_file_chain->next = 0;
2462: }
2463: }
2464: else
2465: error ("`#pragma implementation' can only appear at top-level");
2466: interface_only = 0;
2467: /* We make this non-zero so that we infer decl linkage
2468: in the impl file only for variables first declared
2469: in the interface file. */
2470: interface_unknown = 1;
2471: TREE_INT_CST_LOW (fileinfo) = interface_only;
2472: TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
2473: }
2474: }
2475: }
2476: goto skipline;
2477: }
2478: else if (c == 'd')
2479: {
2480: if (getch () == 'e'
2481: && getch () == 'f'
2482: && getch () == 'i'
2483: && getch () == 'n'
2484: && getch () == 'e'
2485: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2486: {
2487: #ifdef DWARF_DEBUGGING_INFO
2488: if ((debug_info_level == DINFO_LEVEL_VERBOSE)
2489: && (write_symbols == DWARF_DEBUG))
2490: dwarfout_define (lineno, get_directive_line (finput));
2491: #endif /* DWARF_DEBUGGING_INFO */
2492: goto skipline;
2493: }
2494: }
2495: else if (c == 'u')
2496: {
2497: if (getch () == 'n'
2498: && getch () == 'd'
2499: && getch () == 'e'
2500: && getch () == 'f'
2501: && ((c = getch ()) == ' ' || c == '\t' || c == '\n'))
2502: {
2503: #ifdef DWARF_DEBUGGING_INFO
2504: if ((debug_info_level == DINFO_LEVEL_VERBOSE)
2505: && (write_symbols == DWARF_DEBUG))
2506: dwarfout_undef (lineno, get_directive_line (finput));
2507: #endif /* DWARF_DEBUGGING_INFO */
2508: goto skipline;
2509: }
2510: }
2511: else if (c == 'l')
2512: {
2513: if (getch () == 'i'
2514: && getch () == 'n'
2515: && getch () == 'e'
2516: && ((c = getch ()) == ' ' || c == '\t'))
2517: goto linenum;
2518: }
2519: else if (c == 'i')
2520: {
2521: if (getch () == 'd'
2522: && getch () == 'e'
2523: && getch () == 'n'
2524: && getch () == 't'
2525: && ((c = getch ()) == ' ' || c == '\t'))
2526: {
2527: #ifdef ASM_OUTPUT_IDENT
2528: extern FILE *asm_out_file;
2529: #endif
2530: /* #ident. The pedantic warning is now in cccp.c. */
2531:
2532: /* Here we have just seen `#ident '.
2533: A string constant should follow. */
2534:
2535: while (c == ' ' || c == '\t')
2536: c = getch ();
2537:
2538: /* If no argument, ignore the line. */
2539: if (c == '\n')
2540: return c;
2541:
2542: put_back (c);
2543: token = real_yylex ();
2544: if (token != STRING
2545: || TREE_CODE (yylval.ttype) != STRING_CST)
2546: {
2547: error ("invalid #ident");
2548: goto skipline;
2549: }
2550:
2551: if (! flag_no_ident)
2552: {
2553: #ifdef ASM_OUTPUT_IDENT
2554: ASM_OUTPUT_IDENT (asm_out_file,
2555: TREE_STRING_POINTER (yylval.ttype));
2556: #endif
2557: }
2558:
2559: /* Skip the rest of this line. */
2560: goto skipline;
2561: }
2562: }
2563: else if (c == 'n')
2564: {
2565: if (getch () == 'e'
2566: && getch () == 'w'
2567: && getch () == 'w'
2568: && getch () == 'o'
2569: && getch () == 'r'
2570: && getch () == 'l'
2571: && getch () == 'd'
2572: && ((c = getch ()) == ' ' || c == '\t'))
2573: {
2574: /* Used to test incremental compilation. */
2575: sorry ("#pragma newworld");
2576: goto skipline;
2577: }
2578: }
2579: error ("undefined or invalid # directive");
2580: goto skipline;
2581: }
2582:
2583: linenum:
2584: /* Here we have either `#line' or `# <nonletter>'.
2585: In either case, it should be a line number; a digit should follow. */
2586:
2587: while (c == ' ' || c == '\t')
2588: c = getch ();
2589:
2590: /* If the # is the only nonwhite char on the line,
2591: just ignore it. Check the new newline. */
2592: if (c == '\n')
2593: return c;
2594:
2595: /* Something follows the #; read a token. */
2596:
2597: put_back (c);
2598: token = real_yylex ();
2599:
2600: if (token == CONSTANT
2601: && TREE_CODE (yylval.ttype) == INTEGER_CST)
2602: {
2603: int old_lineno = lineno;
2604: int used_up = 0;
2605: /* subtract one, because it is the following line that
2606: gets the specified number */
2607:
2608: int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2609: c = get_last_nonwhite_on_line ();
2610: if (c == '\n')
2611: {
2612: /* No more: store the line number and check following line. */
2613: lineno = l;
2614: return c;
2615: }
2616: put_back (c);
2617:
2618: /* More follows: it must be a string constant (filename). */
2619:
2620: /* Read the string constant, but don't treat \ as special. */
2621: ignore_escape_flag = 1;
2622: token = real_yylex ();
2623: ignore_escape_flag = 0;
2624:
2625: if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2626: {
2627: error ("invalid #line");
2628: goto skipline;
2629: }
2630:
2631: /* Changing files again. This means currently collected time
2632: is charged against header time, and body time starts back
2633: at 0. */
2634: if (flag_detailed_statistics)
2635: {
2636: int this_time = my_get_run_time ();
2637: tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2638: header_time += this_time - body_time;
2639: TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
2640: += this_time - body_time;
2641: this_filename_time = time_identifier;
2642: body_time = this_time;
2643: }
2644:
2645: if (flag_cadillac)
2646: cadillac_note_source ();
2647:
2648: input_filename
2649: = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
2650: strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
2651: lineno = l;
2652: GNU_xref_file (input_filename);
2653:
2654: /* Each change of file name
2655: reinitializes whether we are now in a system header. */
2656: in_system_header = 0;
2657:
2658: if (in_c_header)
2659: pop_lang_context ();
2660: in_c_header = 0;
2661:
2662: if (main_input_filename == 0)
2663: {
2664: struct impl_files *ifiles = impl_file_chain;
2665:
2666: if (ifiles)
2667: {
2668: while (ifiles->next)
2669: ifiles = ifiles->next;
2670: ifiles->filename = FILE_NAME_NONDIRECTORY (input_filename);
2671: }
2672:
2673: main_input_filename = input_filename;
2674: if (write_virtuals == 3)
2675: walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
2676: }
2677:
2678: extract_interface_info ();
2679:
2680: c = get_last_nonwhite_on_line ();
2681: if (c == '\n')
2682: {
2683: if (flag_cadillac)
2684: cadillac_switch_source (-1);
2685: return c;
2686: }
2687: put_back (c);
2688:
2689: token = real_yylex ();
2690: used_up = 0;
2691:
2692: /* `1' after file name means entering new file.
2693: `2' after file name means just left a file. */
2694:
2695: if (token == CONSTANT
2696: && TREE_CODE (yylval.ttype) == INTEGER_CST)
2697: {
2698: if (TREE_INT_CST_LOW (yylval.ttype) == 1)
2699: {
2700: /* Pushing to a new file. */
2701: struct file_stack *p
2702: = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2703: input_file_stack->line = old_lineno;
2704: p->next = input_file_stack;
2705: p->name = input_filename;
2706: input_file_stack = p;
2707: input_file_stack_tick++;
2708: #ifdef DWARF_DEBUGGING_INFO
2709: if (debug_info_level == DINFO_LEVEL_VERBOSE
2710: && write_symbols == DWARF_DEBUG)
2711: dwarfout_start_new_source_file (input_filename);
2712: #endif /* DWARF_DEBUGGING_INFO */
2713:
2714: used_up = 1;
2715: if (flag_cadillac)
2716: cadillac_push_source ();
2717: }
2718: else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
2719: {
2720: /* Popping out of a file. */
2721: if (input_file_stack->next)
2722: {
2723: struct file_stack *p = input_file_stack;
2724:
2725: if (flag_cadillac)
2726: cadillac_pop_source ();
2727:
2728: input_file_stack = p->next;
2729: free (p);
2730: input_file_stack_tick++;
2731: #ifdef DWARF_DEBUGGING_INFO
2732: if (debug_info_level == DINFO_LEVEL_VERBOSE
2733: && write_symbols == DWARF_DEBUG)
2734: dwarfout_resume_previous_source_file (input_file_stack->line);
2735: #endif /* DWARF_DEBUGGING_INFO */
2736: }
2737: else
2738: error ("#-lines for entering and leaving files don't match");
2739:
2740: used_up = 1;
2741: }
2742: }
2743: else if (flag_cadillac)
2744: cadillac_switch_source (-1);
2745:
2746: /* If we have handled a `1' or a `2',
2747: see if there is another number to read. */
2748: if (used_up)
2749: {
2750: c = get_last_nonwhite_on_line ();
2751: if (c == '\n')
2752: {
2753: if (flag_cadillac)
2754: cadillac_switch_source (-1);
2755: return c;
2756: }
2757: put_back (c);
2758:
2759: token = real_yylex ();
2760: used_up = 0;
2761: }
2762:
2763: /* `3' after file name means this is a system header file. */
2764:
2765: if (token == CONSTANT
2766: && TREE_CODE (yylval.ttype) == INTEGER_CST
2767: && TREE_INT_CST_LOW (yylval.ttype) == 3)
2768: {
2769: in_system_header = 1;
2770: used_up = 1;
2771: }
2772:
2773: if (used_up)
2774: {
2775: c = get_last_nonwhite_on_line ();
2776: if (c == '\n')
2777: {
2778: if (flag_cadillac)
2779: cadillac_switch_source (-1);
2780: return c;
2781: }
2782: put_back (c);
2783:
2784: token = real_yylex ();
2785: used_up = 0;
2786: }
2787:
2788: /* `4' after file name means implicit extern "C". */
2789:
2790: if (token == CONSTANT
2791: && TREE_CODE (yylval.ttype) == INTEGER_CST
2792: && TREE_INT_CST_LOW (yylval.ttype) == 4)
2793: {
2794: in_c_header = 1;
2795: #ifdef OBJCPLUS
2796: if (doing_objc_thang)
2797: push_lang_context (lang_name_objc);
2798: else
2799: #endif
2800: push_lang_context (lang_name_c);
2801: }
2802:
2803: /* If NEXTCHAR is not end of line, we don't care what it is. */
2804: if (nextchar == '\n')
2805: return '\n';
2806: }
2807: else
2808: error ("invalid #-line");
2809:
2810: /* skip the rest of this line. */
2811: skipline:
2812: if (c == '\n')
2813: return c;
2814: while ((c = getch ()) != EOF && c != '\n');
2815: return c;
2816: }
2817:
2818: #if 0
2819: #define isalnum(char) (char >= 'a' ? char <= 'z' : char >= '0' ? char <= '9' || (char >= 'A' && char <= 'Z') : 0)
2820: #define isdigit(char) (char >= '0' && char <= '9')
2821: #else
2822: #include <ctype.h>
2823: #endif
2824:
2825: #define ENDFILE -1 /* token that represents end-of-file */
2826:
2827: /* Read an escape sequence, returning its equivalent as a character,
2828: or store 1 in *ignore_ptr if it is backslash-newline. */
2829:
2830: static int
2831: readescape (ignore_ptr)
2832: int *ignore_ptr;
2833: {
2834: register int c = getch ();
2835: register int code;
2836: register unsigned count;
2837: unsigned firstdig;
2838: int nonnull;
2839:
2840: switch (c)
2841: {
2842: case 'x':
2843: if (warn_traditional)
2844: warning ("the meaning of `\\x' varies with -traditional");
2845:
2846: if (flag_traditional)
2847: return c;
2848:
2849: code = 0;
2850: count = 0;
2851: nonnull = 0;
2852: while (1)
2853: {
2854: c = getch ();
2855: if (! isxdigit (c))
2856: {
2857: put_back (c);
2858: break;
2859: }
2860: code *= 16;
2861: if (c >= 'a' && c <= 'f')
2862: code += c - 'a' + 10;
2863: if (c >= 'A' && c <= 'F')
2864: code += c - 'A' + 10;
2865: if (c >= '0' && c <= '9')
2866: code += c - '0';
2867: if (code != 0 || count != 0)
2868: {
2869: if (count == 0)
2870: firstdig = code;
2871: count++;
2872: }
2873: nonnull = 1;
2874: }
2875: if (! nonnull)
2876: error ("\\x used with no following hex digits");
2877: else if (count == 0)
2878: /* Digits are all 0's. Ok. */
2879: ;
2880: else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
2881: || (count > 1
2882: && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
2883: <= firstdig)))
2884: warning ("hex escape out of range");
2885: return code;
2886:
2887: case '0': case '1': case '2': case '3': case '4':
2888: case '5': case '6': case '7':
2889: code = 0;
2890: count = 0;
2891: while ((c <= '7') && (c >= '0') && (count++ < 3))
2892: {
2893: code = (code * 8) + (c - '0');
2894: c = getch ();
2895: }
2896: put_back (c);
2897: return code;
2898:
2899: case '\\': case '\'': case '"':
2900: return c;
2901:
2902: case '\n':
2903: lineno++;
2904: *ignore_ptr = 1;
2905: return 0;
2906:
2907: case 'n':
2908: return TARGET_NEWLINE;
2909:
2910: case 't':
2911: return TARGET_TAB;
2912:
2913: case 'r':
2914: return TARGET_CR;
2915:
2916: case 'f':
2917: return TARGET_FF;
2918:
2919: case 'b':
2920: return TARGET_BS;
2921:
2922: case 'a':
2923: if (warn_traditional)
2924: warning ("the meaning of `\\a' varies with -traditional");
2925:
2926: if (flag_traditional)
2927: return c;
2928: return TARGET_BELL;
2929:
2930: case 'v':
2931: return TARGET_VT;
2932:
2933: case 'e':
2934: case 'E':
2935: if (pedantic)
2936: pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
2937: return 033;
2938:
2939: case '?':
2940: return c;
2941:
2942: /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2943: case '(':
2944: case '{':
2945: case '[':
2946: /* `\%' is used to prevent SCCS from getting confused. */
2947: case '%':
2948: if (pedantic)
2949: pedwarn ("unknown escape sequence `\\%c'", c);
2950: return c;
2951: }
2952: if (c >= 040 && c < 0177)
2953: pedwarn ("unknown escape sequence `\\%c'", c);
2954: else
2955: pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
2956: return c;
2957: }
2958:
2959: /* Value is 1 if we should try to make the next identifier look like a
2960: typename (when it may be a local variable or a class variable).
2961: Value is 0 if we treat this name in a default fashion.
2962: Value is -1 if we must not see a type name. */
2963: int looking_for_typename = 0;
2964:
2965: void
2966: dont_see_typename ()
2967: {
2968: looking_for_typename = -1;
2969: #ifdef OBJCPLUS
2970: if (yychar == TYPENAME || yychar == PTYPENAME
2971: || yychar == OBJECTNAME || yychar == CLASSNAME)
2972: #else
2973: if (yychar == TYPENAME || yychar == PTYPENAME)
2974: #endif
2975: {
2976: yychar = IDENTIFIER;
2977: lastiddecl = 0;
2978: }
2979: }
2980:
2981: #ifdef __GNUC__
2982: extern __inline int identifier_type ();
2983: __inline
2984: #endif
2985: int
2986: identifier_type (decl)
2987: tree decl;
2988: {
2989: if (TREE_CODE (decl) == TEMPLATE_DECL
2990: && DECL_TEMPLATE_IS_CLASS (decl))
2991: return PTYPENAME;
2992: if (TREE_CODE (decl) != TYPE_DECL)
2993: return IDENTIFIER;
2994: return TYPENAME;
2995: }
2996:
2997: void
2998: see_typename ()
2999: {
3000: looking_for_typename = 0;
3001: if (yychar == IDENTIFIER)
3002: {
3003: lastiddecl = lookup_name (yylval.ttype, -1);
3004: if (lastiddecl == 0)
3005: {
3006: if (flag_labels_ok)
3007: lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
3008: }
3009: else
3010: yychar = identifier_type (lastiddecl);
3011: }
3012: }
3013:
3014: tree
3015: do_identifier (token)
3016: register tree token;
3017: {
3018: register tree id = lastiddecl;
3019: #ifdef OBJCPLUS
3020: int is_objc_receiver_context = objc_receiver_context;
3021: objc_receiver_context = 0;
3022: #endif
3023: if (yychar == YYEMPTY)
3024: yychar = yylex ();
3025: /* Scope class declarations before global
3026: declarations. */
3027:
3028: #ifdef OBJCPLUS
3029: /* lastiddecl gets reassigned to the following selector part if an i
3030: dentifier is used as a keywordexpr or receiver. E.g. in
3031: [.. x bar: ..] lastiddecl gets reassigned to the decl of bar
3032: when handling x. So we look it up once more */
3033: if (objc_msg_context)
3034: id = lookup_name (token, 1);
3035: #endif
3036:
3037: if (id == IDENTIFIER_GLOBAL_VALUE (token)
3038: && current_class_type != 0
3039: && TYPE_SIZE (current_class_type) == 0
3040: && TREE_CODE (current_class_type) != UNINSTANTIATED_P_TYPE)
3041: {
3042: /* Could be from one of the base classes. */
3043: tree field = lookup_field (current_class_type, token, 1, 0);
3044: if (field == 0)
3045: ;
3046: else if (field == error_mark_node)
3047: /* We have already generated the error message.
3048: But we still want to return this value. */
3049: id = lookup_field (current_class_type, token, 0, 0);
3050: else if (TREE_CODE (field) == VAR_DECL
3051: || TREE_CODE (field) == CONST_DECL)
3052: id = field;
3053: else if (TREE_CODE (field) != FIELD_DECL)
3054: my_friendly_abort (61);
3055: else
3056: {
3057: cp_error ("invalid use of member `%D' from base class `%T'", field,
3058: DECL_FIELD_CONTEXT (field));
3059: id = error_mark_node;
3060: return id;
3061: }
3062: }
3063:
3064: if (!id || id == error_mark_node)
3065: {
3066: if (id == error_mark_node && current_class_type != NULL_TREE)
3067: {
3068: id = lookup_nested_field (token, 1);
3069: /* In lookup_nested_field(), we marked this so we can gracefully
3070: leave this whole mess. */
3071: if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
3072: return id;
3073: }
3074: if (yychar == '(' || yychar == LEFT_RIGHT)
3075: {
3076: #ifdef OBJCPLUS
3077: /* This may be an application of a function pointer ivar */
3078: if (objc_method_context && is_ivar (objc_ivar_chain, token))
3079: {
3080: id = build_ivar_reference (token);
3081: }
3082: else
3083: #endif /* OBJCPLUS */
3084: {
3085: id = implicitly_declare (token);
3086: }
3087: }
3088: else if (current_function_decl == 0)
3089: {
3090: cp_error ("`%D' was not declared in this scope", token);
3091: id = error_mark_node;
3092: }
3093: else
3094: #ifdef OBJCPLUS
3095: if (is_objc_receiver_context
3096: && !strcmp (IDENTIFIER_POINTER (token), "super"))
3097: {
3098: id = get_super_receiver ();
3099: }
3100: else if (objc_method_context
3101: && is_ivar (objc_ivar_chain, token))
3102: {
3103: id = build_ivar_reference (token);
3104: }
3105: else
3106: #endif
3107: {
3108: if (IDENTIFIER_GLOBAL_VALUE (token) != error_mark_node
3109: || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
3110: {
3111: static int undeclared_variable_notice;
3112:
3113: cp_error ("`%D' undeclared (first use this function)", token);
3114:
3115: if (! undeclared_variable_notice)
3116: {
3117: error ("(Each undeclared identifier is reported only once");
3118: error ("for each function it appears in.)");
3119: undeclared_variable_notice = 1;
3120: }
3121: }
3122: id = error_mark_node;
3123: /* Prevent repeated error messages. */
3124: IDENTIFIER_GLOBAL_VALUE (token) = error_mark_node;
3125: SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
3126: }
3127: }
3128: #ifdef OBJCPLUS
3129: else /* if (id && id != error_mark_node) */
3130: {
3131: /* we have a definition - still check if iVariable */
3132:
3133: if (is_objc_receiver_context
3134: && !strcmp (IDENTIFIER_POINTER (token), "super"))
3135: {
3136: id = get_super_receiver ();
3137: }
3138: else
3139: {
3140: if (objc_method_context && is_ivar (objc_ivar_chain, token))
3141: {
3142: if (IDENTIFIER_LOCAL_VALUE (token))
3143: warning ("local declaration of `%s' "
3144: "hides instance variable",
3145: IDENTIFIER_POINTER (token));
3146: else
3147: id = build_ivar_reference (token);
3148: }
3149: }
3150: }
3151: #endif /* OBJCPLUS */
3152:
3153: /* TREE_USED is set in `hack_identifier'. */
3154: if (TREE_CODE (id) == CONST_DECL)
3155: {
3156: if (IDENTIFIER_CLASS_VALUE (token) == id)
3157: {
3158: /* Check visibility. */
3159: enum visibility_type visibility
3160: = compute_visibility (TYPE_BINFO (current_class_type), id);
3161: if (visibility == visibility_private)
3162: cp_error ("enum `%D' is private", id);
3163: /* protected is OK, since it's an enum of `this'. */
3164: }
3165: id = DECL_INITIAL (id);
3166: }
3167: else
3168: id = hack_identifier (id, token, yychar);
3169: return id;
3170: }
3171:
3172: tree
3173: identifier_typedecl_value (node)
3174: tree node;
3175: {
3176: tree t, type;
3177: type = IDENTIFIER_TYPE_VALUE (node);
3178: if (type == NULL_TREE)
3179: return NULL_TREE;
3180: #define do(X) \
3181: { \
3182: t = (X); \
3183: if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3184: return t; \
3185: }
3186: do (IDENTIFIER_LOCAL_VALUE (node));
3187: do (IDENTIFIER_CLASS_VALUE (node));
3188: do (IDENTIFIER_GLOBAL_VALUE (node));
3189: #undef do
3190: /* Will this one ever happen? */
3191: if (TYPE_NAME (type))
3192: return TYPE_NAME (type);
3193:
3194: /* We used to do an internal error of 62 here, but instead we will
3195: handle the return of a null appropriately in the callers. */
3196: return NULL_TREE;
3197: }
3198:
3199: struct try_type
3200: {
3201: tree *node_var;
3202: char unsigned_flag;
3203: char long_flag;
3204: char long_long_flag;
3205: };
3206:
3207: struct try_type type_sequence[] =
3208: {
3209: { &integer_type_node, 0, 0, 0},
3210: { &unsigned_type_node, 1, 0, 0},
3211: { &long_integer_type_node, 0, 1, 0},
3212: { &long_unsigned_type_node, 1, 1, 0},
3213: { &long_long_integer_type_node, 0, 1, 1},
3214: { &long_long_unsigned_type_node, 1, 1, 1}
3215: };
3216:
3217: int
3218: real_yylex ()
3219: {
3220: register int c;
3221: register int value;
3222: int wide_flag = 0;
3223: #ifdef OBJCPLUS
3224: int objc_flag = 0;
3225: #endif
3226: int dollar_seen = 0;
3227: int i;
3228:
3229: if (nextchar >= 0)
3230: c = nextchar, nextchar = -1;
3231: else
3232: c = getch ();
3233:
3234: /* Effectively do c = skip_white_space (c)
3235: but do it faster in the usual cases. */
3236: while (1)
3237: switch (c)
3238: {
3239: case ' ':
3240: case '\t':
3241: case '\f':
3242: case '\v':
3243: case '\b':
3244: c = getch ();
3245: break;
3246:
3247: case '\r':
3248: /* Call skip_white_space so we can warn if appropriate. */
3249:
3250: case '\n':
3251: case '/':
3252: case '\\':
3253: c = skip_white_space (c);
3254: default:
3255: goto found_nonwhite;
3256: }
3257: found_nonwhite:
3258:
3259: token_buffer[0] = c;
3260: token_buffer[1] = 0;
3261:
3262: /* yylloc.first_line = lineno; */
3263:
3264: switch (c)
3265: {
3266: case EOF:
3267: token_buffer[0] = '\0';
3268: end_of_file = 1;
3269: if (input_redirected ())
3270: value = END_OF_SAVED_INPUT;
3271: else if (do_pending_expansions ())
3272: /* this will set yychar for us */
3273: return yychar;
3274: else
3275: value = ENDFILE;
3276: break;
3277:
3278: case '$':
3279: if (dollars_in_ident)
3280: {
3281: dollar_seen = 1;
3282: goto letter;
3283: }
3284: value = '$';
3285: goto done;
3286:
3287: case 'L':
3288: /* Capital L may start a wide-string or wide-character constant. */
3289: {
3290: register int c = getch ();
3291: if (c == '\'')
3292: {
3293: wide_flag = 1;
3294: goto char_constant;
3295: }
3296: if (c == '"')
3297: {
3298: wide_flag = 1;
3299: goto string_constant;
3300: }
3301: put_back (c);
3302: }
3303:
3304: #ifdef OBJCPLUS
3305: case '@':
3306: /* '@' may start a constant string object as in @"String". */
3307: if (doing_objc_thang)
3308: {
3309: register int c = getc (finput);
3310: if (c == '"')
3311: {
3312: objc_flag = 1;
3313: goto string_constant;
3314: }
3315: ungetc (c, finput);
3316: }
3317: else
3318: {
3319: warning ("possible Objective-C token in C++ input. Use -ObjC");
3320: }
3321: /* If we FALL THROUGH to this point,
3322: @ is the beginning of a keyword */
3323: #endif /* OBJCPLUS */
3324:
3325: case 'A': case 'B': case 'C': case 'D': case 'E':
3326: case 'F': case 'G': case 'H': case 'I': case 'J':
3327: case 'K': case 'M': case 'N': case 'O':
3328: case 'P': case 'Q': case 'R': case 'S': case 'T':
3329: case 'U': case 'V': case 'W': case 'X': case 'Y':
3330: case 'Z':
3331: case 'a': case 'b': case 'c': case 'd': case 'e':
3332: case 'f': case 'g': case 'h': case 'i': case 'j':
3333: case 'k': case 'l': case 'm': case 'n': case 'o':
3334: case 'p': case 'q': case 'r': case 's': case 't':
3335: case 'u': case 'v': case 'w': case 'x': case 'y':
3336: case 'z':
3337: case '_':
3338: letter:
3339: {
3340: register char *p;
3341:
3342: p = token_buffer;
3343: if (input == 0)
3344: {
3345: /* We know that `token_buffer' can hold at least on char,
3346: so we install C immediately.
3347: We may have to read the value in `putback_char', so call
3348: `getch' once. */
3349: *p++ = c;
3350: c = getch ();
3351:
3352: /* Make this run fast. We know that we are reading straight
3353: from FINPUT in this case (since identifiers cannot straddle
3354: input sources. */
3355: while (isalnum (c) || (c == '_') || c == '$')
3356: {
3357: if (c == '$' && ! dollars_in_ident)
3358: break;
3359: if (p >= token_buffer + maxtoken)
3360: p = extend_token_buffer (p);
3361:
3362: *p++ = c;
3363: c = getc (finput);
3364: }
3365: }
3366: else
3367: {
3368: /* We know that `token_buffer' can hold at least on char,
3369: so we install C immediately. */
3370: *p++ = c;
3371: c = getch ();
3372:
3373: while (isalnum (c) || (c == '_') || c == '$')
3374: {
3375: if (c == '$' && ! dollars_in_ident)
3376: break;
3377: if (p >= token_buffer + maxtoken)
3378: p = extend_token_buffer (p);
3379:
3380: *p++ = c;
3381: c = getch ();
3382: }
3383: }
3384:
3385: *p = 0;
3386: nextchar = c;
3387:
3388: value = IDENTIFIER;
3389: yylval.itype = 0;
3390:
3391:
3392: /* Try to recognize a keyword. Uses minimum-perfect hash function */
3393: {
3394: register struct resword *ptr;
3395:
3396: if (ptr = is_reserved_word (token_buffer, p - token_buffer))
3397: {
3398: if (ptr->rid)
3399: {
3400: tree old_ttype = ridpointers[(int) ptr->rid];
3401:
3402: /* If this provides a type for us, then revert lexical
3403: state to standard state. */
3404: if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
3405: && IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
3406: && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
3407: looking_for_typename = 0;
3408: else if (ptr->token == AGGR || ptr->token == ENUM)
3409: looking_for_typename = 1;
3410:
3411: /* Check if this is a language-type declaration.
3412: Just glimpse the next non-white character. */
3413: nextchar = skip_white_space (nextchar);
3414: if (nextchar == '"')
3415: {
3416: /* We are looking at a string. Complain
3417: if the token before the string is no `extern'.
3418:
3419: Could cheat some memory by placing this string
3420: on the temporary_, instead of the saveable_
3421: obstack. */
3422:
3423: if (ptr->rid != RID_EXTERN)
3424: error ("invalid modifier `%s' for language string",
3425: ptr->name);
3426: real_yylex ();
3427: value = EXTERN_LANG_STRING;
3428: yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
3429: break;
3430: }
3431: if (ptr->token == VISSPEC)
3432: {
3433: switch (ptr->rid)
3434: {
3435: case RID_PUBLIC:
3436: yylval.itype = visibility_public;
3437: break;
3438: case RID_PRIVATE:
3439: yylval.itype = visibility_private;
3440: break;
3441: case RID_PROTECTED:
3442: yylval.itype = visibility_protected;
3443: break;
3444: default:
3445: my_friendly_abort (63);
3446: }
3447: }
3448: else
3449: yylval.ttype = old_ttype;
3450: }
3451: value = (int) ptr->token;
3452:
3453: #ifdef OBJCPLUS
3454: /* Only return OBJECTNAME if it is a typedef. */
3455: if (value == OBJECTNAME)
3456: {
3457: lastiddecl = lookup_name (yylval.ttype, 1);
3458:
3459: if (!objc_declarator_context
3460: && doing_objc_thang
3461: && lastiddecl
3462: && TREE_CODE (lastiddecl) == TYPE_DECL)
3463: value = OBJECTNAME;
3464: else
3465: value = IDENTIFIER;
3466: }
3467: #endif /* OBJCPLUS */
3468:
3469: }
3470: }
3471:
3472: /* If we did not find a keyword, look for an identifier
3473: (or a typename). */
3474:
3475: if (current_lang_name == lang_name_cplusplus &&
3476: (strcmp ("catch", token_buffer) == 0
3477: || strcmp ("throw", token_buffer) == 0
3478: || strcmp ("try", token_buffer) == 0))
3479: pedwarn ("`catch', `throw', and `try' are all C++ reserved words");
3480:
3481: if (value == IDENTIFIER || value == TYPESPEC)
3482: GNU_xref_ref (current_function_decl, token_buffer);
3483:
3484: if (value == IDENTIFIER)
3485: {
3486: register tree tmp = get_identifier (token_buffer);
3487:
3488: #ifdef OBJCPLUS
3489: identifier:
3490: if (token_buffer[0] == '@')
3491: error ("illegal identifier `%s'", token_buffer);
3492: #endif /* OBJCPLUS */
3493:
3494: #if !defined(VMS) && defined(JOINER)
3495: /* Make sure that user does not collide with our internal
3496: naming scheme. */
3497: if (JOINER == '$'
3498: && dollar_seen
3499: && (THIS_NAME_P (tmp)
3500: || VPTR_NAME_P (tmp)
3501: || DESTRUCTOR_NAME_P (tmp)
3502: || VTABLE_NAME_P (tmp)
3503: || TEMP_NAME_P (tmp)
3504: || ANON_AGGRNAME_P (tmp)
3505: || ANON_PARMNAME_P (tmp)))
3506: warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3507: token_buffer);
3508: #ifdef OBJCPLUS
3509: else /* match syntax below */
3510: #endif
3511: #endif
3512: #ifdef OBJCPLUS
3513: if (doing_objc_thang
3514: && is_class_name (tmp))
3515: value = CLASSNAME;
3516: #endif /* OBJCPLUS */
3517:
3518:
3519: yylval.ttype = tmp;
3520:
3521: #if 0
3522: /* This can not be done this way in C++ because
3523: lookup_name can find ambiguous names, and yield an
3524: error. Because this routine can be called at token
3525: scan time, this is unacceptable. (mrs) */
3526:
3527: /* A user-invisible read-only initialized variable
3528: should be replaced by its value. We only handle strings
3529: since that's the only case used in C (and C++). */
3530: tmp = lookup_name (yylval.ttype, 0);
3531: if (tmp != NULL_TREE && TREE_CODE (tmp) == VAR_DECL
3532: && DECL_IGNORED_P (tmp)
3533: && TREE_READONLY (tmp)
3534: && DECL_INITIAL (tmp) != NULL_TREE
3535: && TREE_CODE (DECL_INITIAL (tmp)) == STRING_CST)
3536: {
3537: yylval.ttype = DECL_INITIAL (tmp);
3538: value = STRING;
3539: }
3540: #endif
3541: }
3542: if (value == NEW && ! global_bindings_p ())
3543: {
3544: looking_for_typename = 1;
3545: value = NEW;
3546: goto done;
3547: }
3548: }
3549: break;
3550:
3551: case '.':
3552: {
3553: register int c1 = getch ();
3554: token_buffer[0] = c;
3555: token_buffer[1] = c1;
3556: if (c1 == '*')
3557: {
3558: value = DOT_STAR;
3559: token_buffer[2] = 0;
3560: goto done;
3561: }
3562: if (c1 == '.')
3563: {
3564: c1 = getch ();
3565: if (c1 == '.')
3566: {
3567: token_buffer[2] = c1;
3568: token_buffer[3] = 0;
3569: value = ELLIPSIS;
3570: goto done;
3571: }
3572: nextchar = c1;
3573: token_buffer[2] = '\0';
3574: value = RANGE;
3575: goto done;
3576: }
3577: if (isdigit (c1))
3578: {
3579: put_back (c1);
3580: goto resume_numerical_scan;
3581: }
3582: nextchar = c1;
3583: value = '.';
3584: token_buffer[1] = 0;
3585: goto done;
3586: }
3587: case '0': case '1':
3588: /* Optimize for most frequent case. */
3589: {
3590: register int c1 = getch ();
3591: if (! isalnum (c1) && c1 != '.')
3592: {
3593: /* Terminate string. */
3594: token_buffer[0] = c;
3595: token_buffer[1] = 0;
3596: if (c == '0')
3597: yylval.ttype = integer_zero_node;
3598: else
3599: yylval.ttype = integer_one_node;
3600: nextchar = c1;
3601: value = CONSTANT;
3602: goto done;
3603: }
3604: put_back (c1);
3605: }
3606: /* fall through... */
3607: case '2': case '3': case '4':
3608: case '5': case '6': case '7': case '8': case '9':
3609: resume_numerical_scan:
3610: {
3611: register char *p;
3612: int base = 10;
3613: int count = 0;
3614: int largest_digit = 0;
3615: int numdigits = 0;
3616: /* for multi-precision arithmetic,
3617: we actually store only HOST_BITS_PER_CHAR bits in each part.
3618: The number of parts is chosen so as to be sufficient to hold
3619: the enough bits to fit into the two HOST_WIDE_INTs that contain
3620: the integer value (this is always at least as many bits as are
3621: in a target `long long' value, but may be wider). */
3622: #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3623: int parts[TOTAL_PARTS];
3624: int overflow = 0;
3625:
3626: enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
3627: = NOT_FLOAT;
3628:
3629: p = token_buffer;
3630: *p++ = c;
3631:
3632: for (count = 0; count < TOTAL_PARTS; count++)
3633: parts[count] = 0;
3634:
3635: if (c == '0')
3636: {
3637: *p++ = (c = getch ());
3638: if ((c == 'x') || (c == 'X'))
3639: {
3640: base = 16;
3641: *p++ = (c = getch ());
3642: }
3643: /* Leading 0 forces octal unless the 0 is the only digit. */
3644: else if (c >= '0' && c <= '9')
3645: {
3646: base = 8;
3647: numdigits++;
3648: }
3649: else
3650: numdigits++;
3651: }
3652:
3653: /* Read all the digits-and-decimal-points. */
3654:
3655: while (c == '.'
3656: || (isalnum (c) && (c != 'l') && (c != 'L')
3657: && (c != 'u') && (c != 'U')
3658: && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
3659: {
3660: if (c == '.')
3661: {
3662: if (base == 16)
3663: error ("floating constant may not be in radix 16");
3664: if (floatflag == AFTER_POINT)
3665: {
3666: error ("malformed floating constant");
3667: floatflag = TOO_MANY_POINTS;
3668: }
3669: else
3670: floatflag = AFTER_POINT;
3671:
3672: base = 10;
3673: *p++ = c = getch ();
3674: /* Accept '.' as the start of a floating-point number
3675: only when it is followed by a digit.
3676: Otherwise, unread the following non-digit
3677: and use the '.' as a structural token. */
3678: if (p == token_buffer + 2 && !isdigit (c))
3679: {
3680: if (c == '.')
3681: {
3682: c = getch ();
3683: if (c == '.')
3684: {
3685: *p++ = '.';
3686: *p = '\0';
3687: value = ELLIPSIS;
3688: goto done;
3689: }
3690: nextchar = c;
3691: token_buffer[2] = '\0';
3692: value = RANGE;
3693: goto done;
3694: }
3695: nextchar = c;
3696: token_buffer[1] = '\0';
3697: value = '.';
3698: goto done;
3699: }
3700: }
3701: else
3702: {
3703: /* It is not a decimal point.
3704: It should be a digit (perhaps a hex digit). */
3705:
3706: if (isdigit (c))
3707: {
3708: c = c - '0';
3709: }
3710: else if (base <= 10)
3711: {
3712: if (c == 'e' || c == 'E')
3713: {
3714: base = 10;
3715: floatflag = AFTER_POINT;
3716: break; /* start of exponent */
3717: }
3718: error ("nondigits in number and not hexadecimal");
3719: c = 0;
3720: }
3721: else if (c >= 'a')
3722: {
3723: c = c - 'a' + 10;
3724: }
3725: else
3726: {
3727: c = c - 'A' + 10;
3728: }
3729: if (c >= largest_digit)
3730: largest_digit = c;
3731: numdigits++;
3732:
3733: for (count = 0; count < TOTAL_PARTS; count++)
3734: {
3735: parts[count] *= base;
3736: if (count)
3737: {
3738: parts[count]
3739: += (parts[count-1] >> HOST_BITS_PER_CHAR);
3740: parts[count-1]
3741: &= (1 << HOST_BITS_PER_CHAR) - 1;
3742: }
3743: else
3744: parts[0] += c;
3745: }
3746:
3747: /* If the extra highest-order part ever gets anything in it,
3748: the number is certainly too big. */
3749: if (parts[TOTAL_PARTS - 1] != 0)
3750: overflow = 1;
3751:
3752: if (p >= token_buffer + maxtoken - 3)
3753: p = extend_token_buffer (p);
3754: *p++ = (c = getch ());
3755: }
3756: }
3757:
3758: if (numdigits == 0)
3759: error ("numeric constant with no digits");
3760:
3761: if (largest_digit >= base)
3762: error ("numeric constant contains digits beyond the radix");
3763:
3764: /* Remove terminating char from the token buffer and delimit the string */
3765: *--p = 0;
3766:
3767: if (floatflag != NOT_FLOAT)
3768: {
3769: tree type = double_type_node;
3770: char f_seen = 0;
3771: char l_seen = 0;
3772: int garbage_chars = 0, exceeds_double = 0;
3773: REAL_VALUE_TYPE value;
3774: jmp_buf handler;
3775:
3776: /* Read explicit exponent if any, and put it in tokenbuf. */
3777:
3778: if ((c == 'e') || (c == 'E'))
3779: {
3780: if (p >= token_buffer + maxtoken - 3)
3781: p = extend_token_buffer (p);
3782: *p++ = c;
3783: c = getch ();
3784: if ((c == '+') || (c == '-'))
3785: {
3786: *p++ = c;
3787: c = getch ();
3788: }
3789: if (! isdigit (c))
3790: error ("floating constant exponent has no digits");
3791: while (isdigit (c))
3792: {
3793: if (p >= token_buffer + maxtoken - 3)
3794: p = extend_token_buffer (p);
3795: *p++ = c;
3796: c = getch ();
3797: }
3798: }
3799:
3800: *p = 0;
3801: errno = 0;
3802:
3803: /* Convert string to a double, checking for overflow. */
3804: if (setjmp (handler))
3805: {
3806: error ("floating constant out of range");
3807: value = dconst0;
3808: }
3809: else
3810: {
3811: set_float_handler (handler);
3812: /* The second argument, machine_mode, of REAL_VALUE_ATOF
3813: tells the desired precision of the binary result of
3814: decimal-to-binary conversion. */
3815:
3816: /* Read the suffixes to choose a data type. */
3817: switch (c)
3818: {
3819: case 'f': case 'F':
3820: type = float_type_node;
3821: value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
3822: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3823: && REAL_VALUE_ISINF (value) && pedantic)
3824: pedwarn ("floating point number exceeds range of `float'");
3825: garbage_chars = -1;
3826: break;
3827:
3828: case 'l': case 'L':
3829: type = long_double_type_node;
3830: value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
3831: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3832: && REAL_VALUE_ISINF (value) && pedantic)
3833: pedwarn (
3834: "floating point number exceeds range of `long double'");
3835: garbage_chars = -1;
3836: break;
3837:
3838: default:
3839: value = REAL_VALUE_ATOF (token_buffer, TYPE_MODE (type));
3840: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3841: && REAL_VALUE_ISINF (value) && pedantic)
3842: pedwarn ("floating point number exceeds range of `double'");
3843: }
3844: set_float_handler (NULL);
3845: }
3846: #ifdef ERANGE
3847: if (errno == ERANGE && !flag_traditional && pedantic)
3848: {
3849: char *p1 = token_buffer;
3850: /* Check for "0.0" and variants;
3851: SunOS 4 spuriously returns ERANGE for them. */
3852: while (*p1 == '0') p1++;
3853: if (*p1 == '.')
3854: {
3855: p1++;
3856: while (*p1 == '0') p1++;
3857: }
3858: if (*p1 == 'e' || *p1 == 'E')
3859: {
3860: /* with significand==0, ignore the exponent */
3861: p1++;
3862: while (*p1 != 0) p1++;
3863: }
3864: /* ERANGE is also reported for underflow,
3865: so test the value to distinguish overflow from that. */
3866: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3867: && (REAL_VALUES_LESS (dconst1, value)
3868: || REAL_VALUES_LESS (value, dconstm1)))
3869: {
3870: pedwarn ("floating point number exceeds range of `double'");
3871: exceeds_double = 1;
3872: }
3873: }
3874: #endif
3875: /* Note: garbage_chars is -1 if first char is *not* garbage. */
3876: while (isalnum (c))
3877: {
3878: if (c == 'f' || c == 'F')
3879: {
3880: if (f_seen)
3881: error ("two `f's in floating constant");
3882: f_seen = 1;
3883: }
3884: if (c == 'l' || c == 'L')
3885: {
3886: if (l_seen)
3887: error ("two `l's in floating constant");
3888: l_seen = 1;
3889: }
3890: if (p >= token_buffer + maxtoken - 3)
3891: p = extend_token_buffer (p);
3892: *p++ = c;
3893: c = getch ();
3894: garbage_chars++;
3895: }
3896:
3897: if (garbage_chars > 0)
3898: error ("garbage at end of number");
3899:
3900: /* Create a node with determined type and value. */
3901: yylval.ttype = build_real (type, value);
3902:
3903: put_back (c);
3904: *p = 0;
3905: }
3906: else
3907: {
3908: tree type;
3909: HOST_WIDE_INT high, low;
3910: int spec_unsigned = 0;
3911: int spec_long = 0;
3912: int spec_long_long = 0;
3913: int bytes, warn;
3914:
3915: while (1)
3916: {
3917: if (c == 'u' || c == 'U')
3918: {
3919: if (spec_unsigned)
3920: error ("two `u's in integer constant");
3921: spec_unsigned = 1;
3922: }
3923: else if (c == 'l' || c == 'L')
3924: {
3925: if (spec_long)
3926: {
3927: if (spec_long_long)
3928: error ("three `l's in integer constant");
3929: else if (pedantic)
3930: pedwarn ("ANSI C++ forbids long long integer constants");
3931: spec_long_long = 1;
3932: }
3933: spec_long = 1;
3934: }
3935: else
3936: {
3937: if (isalnum (c))
3938: {
3939: error ("garbage at end of number");
3940: while (isalnum (c))
3941: {
3942: if (p >= token_buffer + maxtoken - 3)
3943: p = extend_token_buffer (p);
3944: *p++ = c;
3945: c = getch ();
3946: }
3947: }
3948: break;
3949: }
3950: if (p >= token_buffer + maxtoken - 3)
3951: p = extend_token_buffer (p);
3952: *p++ = c;
3953: c = getch ();
3954: }
3955:
3956: put_back (c);
3957:
3958: /* If the constant is not long long and it won't fit in an
3959: unsigned long, or if the constant is long long and won't fit
3960: in an unsigned long long, then warn that the constant is out
3961: of range. */
3962:
3963: /* ??? This assumes that long long and long integer types are
3964: a multiple of 8 bits. This better than the original code
3965: though which assumed that long was exactly 32 bits and long
3966: long was exactly 64 bits. */
3967:
3968: if (spec_long_long)
3969: bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
3970: else
3971: bytes = TYPE_PRECISION (long_integer_type_node) / 8;
3972:
3973: warn = overflow;
3974: for (i = bytes; i < TOTAL_PARTS; i++)
3975: if (parts[i])
3976: warn = 1;
3977: if (warn)
3978: pedwarn ("integer constant out of range");
3979:
3980: /* This is simplified by the fact that our constant
3981: is always positive. */
3982: high = low = 0;
3983:
3984: for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
3985: {
3986: high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
3987: / HOST_BITS_PER_CHAR)]
3988: << (i * HOST_BITS_PER_CHAR));
3989: low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
3990: }
3991:
3992:
3993: yylval.ttype = build_int_2 (low, high);
3994: TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
3995:
3996: #if 0
3997: /* Find the first allowable type that the value fits in. */
3998: type = 0;
3999: for (i = 0; i < sizeof (type_sequence) / sizeof (type_sequence[0]);
4000: i++)
4001: if (!(spec_long && !type_sequence[i].long_flag)
4002: && !(spec_long_long && !type_sequence[i].long_long_flag)
4003: && !(spec_unsigned && !type_sequence[i].unsigned_flag)
4004: /* A hex or octal constant traditionally is unsigned. */
4005: && !(base != 10 && flag_traditional
4006: && !type_sequence[i].unsigned_flag)
4007: /* A decimal constant can't be unsigned int
4008: unless explicitly specified. */
4009: && !(base == 10 && !spec_unsigned
4010: && *type_sequence[i].node_var == unsigned_type_node))
4011: if (int_fits_type_p (yylval.ttype, *type_sequence[i].node_var))
4012: {
4013: type = *type_sequence[i].node_var;
4014: break;
4015: }
4016: if (flag_traditional && type == long_unsigned_type_node
4017: && !spec_unsigned)
4018: type = long_integer_type_node;
4019:
4020: if (type == 0)
4021: {
4022: type = long_long_integer_type_node;
4023: warning ("integer constant out of range");
4024: }
4025:
4026: /* Warn about some cases where the type of a given constant
4027: changes from traditional C to ANSI C. */
4028: if (warn_traditional)
4029: {
4030: tree other_type = 0;
4031:
4032: /* This computation is the same as the previous one
4033: except that flag_traditional is used backwards. */
4034: for (i = 0; i < sizeof (type_sequence) / sizeof (type_sequence[0]);
4035: i++)
4036: if (!(spec_long && !type_sequence[i].long_flag)
4037: && !(spec_long_long && !type_sequence[i].long_long_flag)
4038: && !(spec_unsigned && !type_sequence[i].unsigned_flag)
4039: /* A hex or octal constant traditionally is unsigned. */
4040: && !(base != 10 && !flag_traditional
4041: && !type_sequence[i].unsigned_flag)
4042: /* A decimal constant can't be unsigned int
4043: unless explicitly specified. */
4044: && !(base == 10 && !spec_unsigned
4045: && *type_sequence[i].node_var == unsigned_type_node))
4046: if (int_fits_type_p (yylval.ttype, *type_sequence[i].node_var))
4047: {
4048: other_type = *type_sequence[i].node_var;
4049: break;
4050: }
4051: if (!flag_traditional && type == long_unsigned_type_node
4052: && !spec_unsigned)
4053: type = long_integer_type_node;
4054:
4055: if (other_type != 0 && other_type != type)
4056: {
4057: if (flag_traditional)
4058: warning ("type of integer constant would be different without -traditional");
4059: else
4060: warning ("type of integer constant would be different with -traditional");
4061: }
4062: }
4063:
4064: #else /* 1 */
4065: if (!spec_long && !spec_unsigned
4066: && !(flag_traditional && base != 10)
4067: && int_fits_type_p (yylval.ttype, integer_type_node))
4068: {
4069: #if 0
4070: if (warn_traditional && base != 10)
4071: warning ("small nondecimal constant becomes signed in ANSI C++");
4072: #endif
4073: type = integer_type_node;
4074: }
4075: else if (!spec_long && (base != 10 || spec_unsigned)
4076: && int_fits_type_p (yylval.ttype, unsigned_type_node))
4077: {
4078: /* Nondecimal constants try unsigned even in traditional C. */
4079: type = unsigned_type_node;
4080: }
4081:
4082: else if (!spec_unsigned && !spec_long_long
4083: && int_fits_type_p (yylval.ttype, long_integer_type_node))
4084: type = long_integer_type_node;
4085:
4086: else if (! spec_long_long
4087: && int_fits_type_p (yylval.ttype,
4088: long_unsigned_type_node))
4089: {
4090: #if 0
4091: if (warn_traditional && !spec_unsigned)
4092: warning ("large integer constant becomes unsigned in ANSI C++");
4093: #endif
4094: if (flag_traditional && !spec_unsigned)
4095: type = long_integer_type_node;
4096: else
4097: type = long_unsigned_type_node;
4098: }
4099:
4100: else if (! spec_unsigned
4101: /* Verify value does not overflow into sign bit. */
4102: && TREE_INT_CST_HIGH (yylval.ttype) >= 0
4103: && int_fits_type_p (yylval.ttype,
4104: long_long_integer_type_node))
4105: type = long_long_integer_type_node;
4106:
4107: else if (int_fits_type_p (yylval.ttype,
4108: long_long_unsigned_type_node))
4109: {
4110: #if 0
4111: if (warn_traditional && !spec_unsigned)
4112: warning ("large nondecimal constant is unsigned in ANSI C++");
4113: #endif
4114:
4115: if (flag_traditional && !spec_unsigned)
4116: type = long_long_integer_type_node;
4117: else
4118: type = long_long_unsigned_type_node;
4119: }
4120:
4121: else
4122: {
4123: type = long_long_integer_type_node;
4124: warning ("integer constant out of range");
4125:
4126: if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
4127: warning ("decimal integer constant is so large that it is unsigned");
4128: }
4129: #endif
4130:
4131: TREE_TYPE (yylval.ttype) = type;
4132: *p = 0;
4133: }
4134:
4135: value = CONSTANT; break;
4136: }
4137:
4138: case '\'':
4139: char_constant:
4140: {
4141: register int result = 0;
4142: register int num_chars = 0;
4143: unsigned width = TYPE_PRECISION (char_type_node);
4144: int max_chars;
4145:
4146: if (wide_flag)
4147: {
4148: width = WCHAR_TYPE_SIZE;
4149: #ifdef MULTIBYTE_CHARS
4150: max_chars = MB_CUR_MAX;
4151: #else
4152: max_chars = 1;
4153: #endif
4154: }
4155: else
4156: max_chars = TYPE_PRECISION (integer_type_node) / width;
4157:
4158: while (1)
4159: {
4160: tryagain:
4161:
4162: c = getch ();
4163:
4164: if (c == '\'' || c == EOF)
4165: break;
4166:
4167: if (c == '\\')
4168: {
4169: int ignore = 0;
4170: c = readescape (&ignore);
4171: if (ignore)
4172: goto tryagain;
4173: if (width < HOST_BITS_PER_INT
4174: && (unsigned) c >= (1 << width))
4175: pedwarn ("escape sequence out of range for character");
4176: #ifdef MAP_CHARACTER
4177: if (isprint (c))
4178: c = MAP_CHARACTER (c);
4179: #endif
4180: }
4181: else if (c == '\n')
4182: {
4183: if (pedantic)
4184: pedwarn ("ANSI C++ forbids newline in character constant");
4185: lineno++;
4186: }
4187: #ifdef MAP_CHARACTER
4188: else
4189: c = MAP_CHARACTER (c);
4190: #endif
4191:
4192: num_chars++;
4193: if (num_chars > maxtoken - 4)
4194: extend_token_buffer (token_buffer);
4195:
4196: token_buffer[num_chars] = c;
4197:
4198: /* Merge character into result; ignore excess chars. */
4199: if (num_chars < max_chars + 1)
4200: {
4201: if (width < HOST_BITS_PER_INT)
4202: result = (result << width) | (c & ((1 << width) - 1));
4203: else
4204: result = c;
4205: }
4206: }
4207:
4208: token_buffer[num_chars + 1] = '\'';
4209: token_buffer[num_chars + 2] = 0;
4210:
4211: if (c != '\'')
4212: error ("malformatted character constant");
4213: else if (num_chars == 0)
4214: error ("empty character constant");
4215: else if (num_chars > max_chars)
4216: {
4217: num_chars = max_chars;
4218: error ("character constant too long");
4219: }
4220: else if (num_chars != 1 && ! flag_traditional)
4221: warning ("multi-character character constant");
4222:
4223: /* If char type is signed, sign-extend the constant. */
4224: if (! wide_flag)
4225: {
4226: int num_bits = num_chars * width;
4227: if (num_bits == 0)
4228: /* We already got an error; avoid invalid shift. */
4229: yylval.ttype = build_int_2 (0, 0);
4230: else if (TREE_UNSIGNED (char_type_node)
4231: || ((result >> (num_bits - 1)) & 1) == 0)
4232: yylval.ttype
4233: = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
4234: >> (HOST_BITS_PER_INT - num_bits)),
4235: 0);
4236: else
4237: yylval.ttype
4238: = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
4239: >> (HOST_BITS_PER_INT - num_bits)),
4240: -1);
4241: if (num_chars<=1)
4242: TREE_TYPE (yylval.ttype) = char_type_node;
4243: else
4244: TREE_TYPE (yylval.ttype) = integer_type_node;
4245: }
4246: else
4247: {
4248: #ifdef MULTIBYTE_CHARS
4249: /* Set the initial shift state and convert the next sequence. */
4250: result = 0;
4251: /* In all locales L'\0' is zero and mbtowc will return zero,
4252: so don't use it. */
4253: if (num_chars > 1
4254: || (num_chars == 1 && token_buffer[1] != '\0'))
4255: {
4256: wchar_t wc;
4257: (void) mbtowc (NULL, NULL, 0);
4258: if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
4259: result = wc;
4260: else
4261: warning ("Ignoring invalid multibyte character");
4262: }
4263: #endif
4264: yylval.ttype = build_int_2 (result, 0);
4265: TREE_TYPE (yylval.ttype) = wchar_type_node;
4266: }
4267:
4268: value = CONSTANT;
4269: break;
4270: }
4271:
4272: case '"':
4273: string_constant:
4274: {
4275: register char *p;
4276:
4277: c = getch ();
4278: p = token_buffer + 1;
4279:
4280: while (c != '"' && c >= 0)
4281: {
4282: /* ignore_escape_flag is set for reading the filename in #line. */
4283: if (!ignore_escape_flag && c == '\\')
4284: {
4285: int ignore = 0;
4286: c = readescape (&ignore);
4287: if (ignore)
4288: goto skipnewline;
4289: if (!wide_flag
4290: && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
4291: && c >= ((unsigned) 1 << TYPE_PRECISION (char_type_node)))
4292: pedwarn ("escape sequence out of range for character");
4293: }
4294: else if (c == '\n')
4295: {
4296: if (pedantic)
4297: pedwarn ("ANSI C++ forbids newline in string constant");
4298: lineno++;
4299: }
4300:
4301: if (p == token_buffer + maxtoken)
4302: p = extend_token_buffer (p);
4303: *p++ = c;
4304:
4305: skipnewline:
4306: c = getch ();
4307: if (c == EOF) {
4308: error("Unterminated string");
4309: break;
4310: }
4311: }
4312: *p = 0;
4313:
4314: /* We have read the entire constant.
4315: Construct a STRING_CST for the result. */
4316:
4317: if (wide_flag)
4318: {
4319: /* If this is a L"..." wide-string, convert the multibyte string
4320: to a wide character string. */
4321: char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
4322: int len;
4323:
4324: #ifdef MULTIBYTE_CHARS
4325: len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
4326: if (len < 0 || len >= (p - token_buffer))
4327: {
4328: warning ("Ignoring invalid multibyte string");
4329: len = 0;
4330: }
4331: bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
4332: #else
4333: {
4334: union { long l; char c[sizeof (long)]; } u;
4335: int big_endian;
4336: char *wp, *cp;
4337:
4338: /* Determine whether host is little or big endian. */
4339: u.l = 1;
4340: big_endian = u.c[sizeof (long) - 1];
4341: wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
4342:
4343: bzero (widep, (p - token_buffer) * WCHAR_BYTES);
4344: for (cp = token_buffer + 1; cp < p; cp++)
4345: *wp = *cp, wp += WCHAR_BYTES;
4346: len = p - token_buffer - 1;
4347: }
4348: #endif
4349: yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
4350: TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4351: value = STRING;
4352: }
4353: #ifdef OBJCPLUS
4354: else if (objc_flag)
4355: {
4356: /* Return an Objective-C @"..." constant string object. */
4357: extern tree build_objc_string();
4358: yylval.ttype = build_objc_string (p - token_buffer,
4359: token_buffer + 1);
4360: value = OBJC_STRING;
4361: }
4362: #endif
4363: else
4364: {
4365: yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
4366: TREE_TYPE (yylval.ttype) = char_array_type_node;
4367: value = STRING;
4368: }
4369:
4370: *p++ = '"';
4371: *p = 0;
4372:
4373: break;
4374: }
4375:
4376: case '+':
4377: case '-':
4378: case '&':
4379: case '|':
4380: case '<':
4381: case '>':
4382: case '*':
4383: case '/':
4384: case '%':
4385: case '^':
4386: case '!':
4387: case '=':
4388: {
4389: register int c1;
4390:
4391: combine:
4392:
4393: switch (c)
4394: {
4395: case '+':
4396: yylval.code = PLUS_EXPR; break;
4397: case '-':
4398: yylval.code = MINUS_EXPR; break;
4399: case '&':
4400: yylval.code = BIT_AND_EXPR; break;
4401: case '|':
4402: yylval.code = BIT_IOR_EXPR; break;
4403: case '*':
4404: yylval.code = MULT_EXPR; break;
4405: case '/':
4406: yylval.code = TRUNC_DIV_EXPR; break;
4407: case '%':
4408: yylval.code = TRUNC_MOD_EXPR; break;
4409: case '^':
4410: yylval.code = BIT_XOR_EXPR; break;
4411: case LSHIFT:
4412: yylval.code = LSHIFT_EXPR; break;
4413: case RSHIFT:
4414: yylval.code = RSHIFT_EXPR; break;
4415: case '<':
4416: yylval.code = LT_EXPR; break;
4417: case '>':
4418: yylval.code = GT_EXPR; break;
4419: }
4420:
4421: token_buffer[1] = c1 = getch ();
4422: token_buffer[2] = 0;
4423:
4424: if (c1 == '=')
4425: {
4426: switch (c)
4427: {
4428: case '<':
4429: value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4430: case '>':
4431: value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4432: case '!':
4433: value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4434: case '=':
4435: value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4436: }
4437: value = ASSIGN; goto done;
4438: }
4439: else if (c == c1)
4440: switch (c)
4441: {
4442: case '+':
4443: value = PLUSPLUS; goto done;
4444: case '-':
4445: value = MINUSMINUS; goto done;
4446: case '&':
4447: value = ANDAND; goto done;
4448: case '|':
4449: value = OROR; goto done;
4450: case '<':
4451: c = LSHIFT;
4452: goto combine;
4453: case '>':
4454: c = RSHIFT;
4455: goto combine;
4456: }
4457: else if ((c == '-') && (c1 == '>'))
4458: {
4459: nextchar = skip_white_space (getch ());
4460: if (nextchar == '*')
4461: {
4462: nextchar = -1;
4463: value = POINTSAT_STAR;
4464: }
4465: else
4466: value = POINTSAT;
4467: goto done;
4468: }
4469: else if (c1 == '?' && (c == '<' || c == '>'))
4470: {
4471: token_buffer[3] = 0;
4472:
4473: c1 = getch ();
4474: yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4475: if (c1 == '=')
4476: {
4477: /* <?= or >?= expression. */
4478: token_buffer[2] = c1;
4479: value = ASSIGN;
4480: }
4481: else
4482: {
4483: value = MIN_MAX;
4484: nextchar = c1;
4485: }
4486: if (pedantic)
4487: error ("use of `operator %s' is not standard C++",
4488: token_buffer);
4489: goto done;
4490: }
4491:
4492: nextchar = c1;
4493: token_buffer[1] = 0;
4494:
4495: value = c;
4496: goto done;
4497: }
4498:
4499: case ':':
4500: c = getch ();
4501: if (c == ':' && !cplusplus_keywords_disabled)
4502: {
4503: token_buffer[1] = ':';
4504: token_buffer[2] = '\0';
4505: value = SCOPE;
4506: yylval.itype = 1;
4507: }
4508: else
4509: {
4510: nextchar = c;
4511: value = ':';
4512: }
4513: break;
4514:
4515: case 0:
4516: /* Don't make yyparse think this is eof. */
4517: value = 1;
4518: break;
4519:
4520: case '(':
4521: /* try, weakly, to handle casts to pointers to functions. */
4522: nextchar = skip_white_space (getch ());
4523: if (nextchar == '*')
4524: {
4525: int next_c = skip_white_space (getch ());
4526: if (next_c == ')')
4527: {
4528: nextchar = -1;
4529: yylval.ttype = build1 (INDIRECT_REF, 0, 0);
4530: value = PAREN_STAR_PAREN;
4531: }
4532: else
4533: {
4534: put_back (next_c);
4535: value = c;
4536: }
4537: }
4538: else if (nextchar == ')')
4539: {
4540: nextchar = -1;
4541: yylval.ttype = NULL_TREE;
4542: value = LEFT_RIGHT;
4543: }
4544: else value = c;
4545: break;
4546:
4547: default:
4548: value = c;
4549: }
4550:
4551: done:
4552: /* yylloc.last_line = lineno; */
4553: #ifdef GATHER_STATISTICS
4554: token_count[value] += 1;
4555: #endif
4556:
4557: return value;
4558: }
4559:
4560: typedef enum
4561: {
4562: d_kind, t_kind, s_kind, r_kind, e_kind, c_kind,
4563: id_kind, op_id_kind, perm_list_kind, temp_list_kind,
4564: vec_kind, x_kind, lang_decl, lang_type, all_kinds
4565: } tree_node_kind;
4566: extern int tree_node_counts[];
4567: extern int tree_node_sizes[];
4568: extern char *tree_node_kind_names[];
4569:
4570: /* Place to save freed lang_decls which were allocated on the
4571: permanent_obstack. @@ Not currently used. */
4572: tree free_lang_decl_chain;
4573:
4574: tree
4575: build_lang_decl (code, name, type)
4576: enum tree_code code;
4577: tree name;
4578: tree type;
4579: {
4580: register tree t = build_decl (code, name, type);
4581: struct obstack *obstack = current_obstack;
4582: register int i = sizeof (struct lang_decl) / sizeof (int);
4583: register int *pi;
4584:
4585: if (! TREE_PERMANENT (t))
4586: obstack = saveable_obstack;
4587: else
4588: /* Could be that saveable is permanent and current is not. */
4589: obstack = &permanent_obstack;
4590:
4591: if (free_lang_decl_chain && obstack == &permanent_obstack)
4592: {
4593: pi = (int *)free_lang_decl_chain;
4594: free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
4595: }
4596: else
4597: pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4598:
4599: while (i > 0)
4600: pi[--i] = 0;
4601:
4602: DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4603: LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4604: = obstack == &permanent_obstack;
4605: my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4606: == TREE_PERMANENT (t), 234);
4607: DECL_MAIN_VARIANT (t) = t;
4608: if (current_lang_name == lang_name_cplusplus)
4609: {
4610: DECL_LANGUAGE (t) = lang_cplusplus;
4611: #ifndef NO_AUTO_OVERLOAD
4612: if (code == FUNCTION_DECL && name != 0
4613: && ! (IDENTIFIER_LENGTH (name) == 4
4614: && IDENTIFIER_POINTER (name)[0] == 'm'
4615: && strcmp (IDENTIFIER_POINTER (name), "main") == 0)
4616: && ! (IDENTIFIER_LENGTH (name) > 10
4617: && IDENTIFIER_POINTER (name)[0] == '_'
4618: && IDENTIFIER_POINTER (name)[1] == '_'
4619: && strncmp (IDENTIFIER_POINTER (name)+2, "builtin_", 8) == 0))
4620: TREE_OVERLOADED (name) = 1;
4621: #endif
4622: }
4623: else if (current_lang_name == lang_name_c)
4624: DECL_LANGUAGE (t) = lang_c;
4625: #ifdef OBJCPLUS
4626: else if (current_lang_name == lang_name_objc)
4627: DECL_LANGUAGE (t) = lang_objc;
4628: #endif
4629: else my_friendly_abort (64);
4630:
4631: #if 0 /* not yet, should get fixed properly later */
4632: if (code == TYPE_DECL)
4633: {
4634: tree id;
4635: id = get_identifier (build_overload_name (type, 1, 1));
4636: DECL_ASSEMBLER_NAME (t) = id;
4637: }
4638:
4639: #endif
4640: #ifdef GATHER_STATISTICS
4641: tree_node_counts[(int)lang_decl] += 1;
4642: tree_node_sizes[(int)lang_decl] += sizeof(struct lang_decl);
4643: #endif
4644:
4645: return t;
4646: }
4647:
4648: tree
4649: build_lang_field_decl (code, name, type)
4650: enum tree_code code;
4651: tree name;
4652: tree type;
4653: {
4654: extern struct obstack *current_obstack, *saveable_obstack;
4655: register tree t = build_decl (code, name, type);
4656: struct obstack *obstack = current_obstack;
4657: register int i = sizeof (struct lang_decl_flags) / sizeof (int);
4658: register int *pi;
4659: #if 0 /* not yet, should get fixed properly later */
4660:
4661: if (code == TYPE_DECL)
4662: {
4663: tree id;
4664: id = get_identifier (build_overload_name (type, 1, 1));
4665: DECL_ASSEMBLER_NAME (t) = id;
4666: }
4667: #endif
4668:
4669: if (! TREE_PERMANENT (t))
4670: obstack = saveable_obstack;
4671: else
4672: my_friendly_assert (obstack == &permanent_obstack, 235);
4673:
4674: pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
4675: while (i > 0)
4676: pi[--i] = 0;
4677:
4678: DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4679: return t;
4680: }
4681:
4682: void
4683: copy_lang_decl (node)
4684: tree node;
4685: {
4686: int size;
4687: int *pi;
4688:
4689: if (TREE_CODE (node) == FIELD_DECL)
4690: size = sizeof (struct lang_decl_flags);
4691: else
4692: size = sizeof (struct lang_decl);
4693: pi = (int *)obstack_alloc (&permanent_obstack, size);
4694: bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
4695: DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
4696: }
4697:
4698: tree
4699: make_lang_type (code)
4700: enum tree_code code;
4701: {
4702: extern struct obstack *current_obstack, *saveable_obstack;
4703: register tree t = make_node (code);
4704: struct obstack *obstack = current_obstack;
4705: register int i = sizeof (struct lang_type) / sizeof (int);
4706: register int *pi;
4707:
4708: /* Set up some flags that give proper default behavior. */
4709: IS_AGGR_TYPE (t) = 1;
4710:
4711: if (! TREE_PERMANENT (t))
4712: obstack = saveable_obstack;
4713: else
4714: my_friendly_assert (obstack == &permanent_obstack, 236);
4715:
4716: pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
4717: while (i > 0)
4718: pi[--i] = 0;
4719:
4720: TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
4721: CLASSTYPE_AS_LIST (t) = build_tree_list (NULL_TREE, t);
4722: SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
4723: CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
4724: CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
4725: TYPE_BINFO (t) = make_binfo (integer_zero_node, t, 0, 0, 0);
4726: CLASSTYPE_BINFO_AS_LIST (t) = build_tree_list (NULL_TREE, TYPE_BINFO (t));
4727:
4728: /* Make sure this is laid out, for ease of use later.
4729: In the presence of parse errors, the normal was of assuring
4730: this might not ever get executed, so we lay it out *immediately*. */
4731: build_pointer_type (t);
4732:
4733: #ifdef GATHER_STATISTICS
4734: tree_node_counts[(int)lang_type] += 1;
4735: tree_node_sizes[(int)lang_type] += sizeof(struct lang_type);
4736: #endif
4737:
4738: return t;
4739: }
4740:
4741: void
4742: copy_decl_lang_specific (decl)
4743: tree decl;
4744: {
4745: extern struct obstack *current_obstack, *saveable_obstack;
4746: register int *old = (int *)DECL_LANG_SPECIFIC (decl);
4747: struct obstack *obstack = current_obstack;
4748: register int i = sizeof (struct lang_decl) / sizeof (int);
4749: register int *pi;
4750:
4751: if (! TREE_PERMANENT (decl))
4752: obstack = saveable_obstack;
4753: else
4754: my_friendly_assert (obstack == &permanent_obstack, 237);
4755:
4756: pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4757: while (i-- > 0)
4758: pi[i] = old[i];
4759:
4760: DECL_LANG_SPECIFIC (decl) = (struct lang_decl *) pi;
4761:
4762: #ifdef GATHER_STATISTICS
4763: tree_node_counts[(int)lang_decl] += 1;
4764: tree_node_sizes[(int)lang_decl] += sizeof(struct lang_decl);
4765: #endif
4766: }
4767:
4768: void
4769: dump_time_statistics ()
4770: {
4771: register tree prev = 0, decl, next;
4772: int this_time = my_get_run_time ();
4773: TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
4774: += this_time - body_time;
4775:
4776: fprintf (stderr, "\n******\n");
4777: print_time ("header files (total)", header_time);
4778: print_time ("main file (total)", this_time - body_time);
4779: fprintf (stderr, "ratio = %g : 1\n",
4780: (double)header_time / (double)(this_time - body_time));
4781: fprintf (stderr, "\n******\n");
4782:
4783: for (decl = filename_times; decl; decl = next)
4784: {
4785: next = IDENTIFIER_GLOBAL_VALUE (decl);
4786: IDENTIFIER_GLOBAL_VALUE (decl) = prev;
4787: prev = decl;
4788: }
4789:
4790: for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
4791: print_time (IDENTIFIER_POINTER (decl),
4792: TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
4793: }
4794:
4795: void
4796: compiler_error (s, v, v2)
4797: char *s;
4798: HOST_WIDE_INT v, v2; /* @@also used as pointer */
4799: {
4800: char buf[1024];
4801: sprintf (buf, s, v, v2);
4802: error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
4803: }
4804:
4805: void
4806: compiler_error_with_decl (decl, s)
4807: tree decl;
4808: char *s;
4809: {
4810: char *name;
4811: count_error (0);
4812:
4813: report_error_function (0);
4814:
4815: if (TREE_CODE (decl) == PARM_DECL)
4816: fprintf (stderr, "%s:%d: ",
4817: DECL_SOURCE_FILE (DECL_CONTEXT (decl)),
4818: DECL_SOURCE_LINE (DECL_CONTEXT (decl)));
4819: else
4820: fprintf (stderr, "%s:%d: ",
4821: DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
4822:
4823: name = lang_printable_name (decl);
4824: if (name)
4825: fprintf (stderr, s, name);
4826: else
4827: fprintf (stderr, s, "((anonymous))");
4828: fprintf (stderr, " (compiler error)\n");
4829: }
4830:
4831: void
4832: yyerror (string)
4833: char *string;
4834: {
4835: extern int end_of_file;
4836: char buf[200];
4837:
4838: strcpy (buf, string);
4839:
4840: /* We can't print string and character constants well
4841: because the token_buffer contains the result of processing escapes. */
4842: if (end_of_file)
4843: strcat (buf, input_redirected ()
4844: ? " at end of saved text"
4845: : " at end of input");
4846: else if (token_buffer[0] == 0)
4847: strcat (buf, " at null character");
4848: else if (token_buffer[0] == '"')
4849: strcat (buf, " before string constant");
4850: else if (token_buffer[0] == '\'')
4851: strcat (buf, " before character constant");
4852: else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
4853: sprintf (buf + strlen (buf), " before character 0%o",
4854: (unsigned char) token_buffer[0]);
4855: else
4856: strcat (buf, " before `%s'");
4857:
4858: error (buf, token_buffer);
4859: }
4860:
4861:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.