1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* This file is the lexical analyzer for GNU C++. */
28 #include "coretypes.h"
41 static int interface_strcmp (const char *);
42 static void init_cp_pragma (void);
44 static tree parse_strconst_pragma (const char *, int);
45 static void handle_pragma_vtable (cpp_reader *);
46 static void handle_pragma_unit (cpp_reader *);
47 static void handle_pragma_interface (cpp_reader *);
48 static void handle_pragma_implementation (cpp_reader *);
49 static void handle_pragma_java_exceptions (cpp_reader *);
51 static void init_operators (void);
52 static void copy_lang_type (tree);
54 /* A constraint that can be tested at compile time. */
55 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
57 /* Functions and data structures for #pragma interface.
59 `#pragma implementation' means that the main file being compiled
60 is considered to implement (provide) the classes that appear in
61 its main body. I.e., if this is file "foo.cc", and class `bar'
62 is defined in "foo.cc", then we say that "foo.cc implements bar".
64 All main input files "implement" themselves automagically.
66 `#pragma interface' means that unless this file (of the form "foo.h"
67 is not presently being included by file "foo.cc", the
68 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
69 of the vtables nor any of the inline functions defined in foo.h
72 There are cases when we want to link files such as "defs.h" and
73 "main.cc". In this case, we give "defs.h" a `#pragma interface',
74 and "main.cc" has `#pragma implementation "defs.h"'. */
79 struct impl_files *next;
82 static struct impl_files *impl_file_chain;
91 /* A mapping from tree codes to operator name information. */
92 operator_name_info_t operator_name_info[(int) MAX_TREE_CODES];
93 /* Similar, but for assignment operators. */
94 operator_name_info_t assignment_operator_name_info[(int) MAX_TREE_CODES];
96 /* Initialize data structures that keep track of operator names. */
98 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
99 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
100 #include "operators.def"
104 init_operators (void)
108 struct operator_name_info_t *oni;
110 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
111 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
112 identifier = get_identifier (buffer); \
113 IDENTIFIER_OPNAME_P (identifier) = 1; \
116 ? &assignment_operator_name_info[(int) CODE] \
117 : &operator_name_info[(int) CODE]); \
118 oni->identifier = identifier; \
120 oni->mangled_name = MANGLING; \
123 #include "operators.def"
126 operator_name_info[(int) ERROR_MARK].identifier
127 = get_identifier ("<invalid operator>");
129 /* Handle some special cases. These operators are not defined in
130 the language, but can be produced internally. We may need them
131 for error-reporting. (Eventually, we should ensure that this
132 does not happen. Error messages involving these operators will
133 be confusing to users.) */
135 operator_name_info [(int) INIT_EXPR].name
136 = operator_name_info [(int) MODIFY_EXPR].name;
137 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
138 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
139 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
140 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
141 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
142 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
143 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
144 operator_name_info [(int) ABS_EXPR].name = "abs";
145 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
146 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
147 operator_name_info [(int) RANGE_EXPR].name = "...";
148 operator_name_info [(int) UNARY_PLUS_EXPR].name = "+";
150 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
152 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
154 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
156 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
158 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
160 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
162 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
166 /* Initialize the reserved words. */
175 if (cxx_dialect != cxx0x)
178 mask |= D_ASM | D_EXT;
179 if (flag_no_gnu_keywords)
182 /* The Objective-C keywords are all context-dependent. */
185 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
186 for (i = 0; i < num_c_common_reswords; i++)
188 if (c_common_reswords[i].disable & D_CONLY)
190 id = get_identifier (c_common_reswords[i].word);
191 C_SET_RID_CODE (id, c_common_reswords[i].rid);
192 ridpointers [(int) c_common_reswords[i].rid] = id;
193 if (! (c_common_reswords[i].disable & mask))
194 C_IS_RESERVED_WORD (id) = 1;
199 init_cp_pragma (void)
201 c_register_pragma (0, "vtable", handle_pragma_vtable);
202 c_register_pragma (0, "unit", handle_pragma_unit);
203 c_register_pragma (0, "interface", handle_pragma_interface);
204 c_register_pragma (0, "implementation", handle_pragma_implementation);
205 c_register_pragma ("GCC", "interface", handle_pragma_interface);
206 c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
207 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
210 /* TRUE if a code represents a statement. */
212 bool statement_code_p[MAX_TREE_CODES];
214 /* Initialize the C++ front end. This function is very sensitive to
215 the exact order that things are done here. It would be nice if the
216 initialization done by this routine were moved to its subroutines,
217 and the ordering dependencies clarified and reduced. */
221 location_t saved_loc;
223 static const enum tree_code stmt_codes[] = {
224 CTOR_INITIALIZER, TRY_BLOCK, HANDLER,
225 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN,
226 IF_STMT, CLEANUP_STMT, FOR_STMT,
227 WHILE_STMT, DO_STMT, BREAK_STMT,
228 CONTINUE_STMT, SWITCH_STMT, EXPR_STMT
231 memset (&statement_code_p, 0, sizeof (statement_code_p));
232 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
233 statement_code_p[stmt_codes[i]] = true;
235 saved_loc = input_location;
236 input_location = BUILTINS_LOCATION;
240 init_cp_semantics ();
245 current_function_decl = NULL;
247 class_type_node = ridpointers[(int) RID_CLASS];
249 cxx_init_decl_processing ();
251 if (c_common_init () == false)
253 input_location = saved_loc;
261 input_location = saved_loc;
265 /* Return nonzero if S is not considered part of an
266 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
269 interface_strcmp (const char* s)
271 /* Set the interface/implementation bits for this scope. */
272 struct impl_files *ifiles;
275 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
277 const char *t1 = ifiles->filename;
280 if (*s1 != *t1 || *s1 == 0)
283 while (*s1 == *t1 && *s1 != 0)
290 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
291 if (strchr (s1, '.') || strchr (t1, '.'))
294 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
307 /* Parse a #pragma whose sole argument is a string constant.
308 If OPT is true, the argument is optional. */
310 parse_strconst_pragma (const char* name, int opt)
315 t = pragma_lex (&result);
318 if (pragma_lex (&x) != CPP_EOF)
319 warning (0, "junk at end of #pragma %s", name);
323 if (t == CPP_EOF && opt)
326 error ("invalid #pragma %s", name);
327 return error_mark_node;
331 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
333 parse_strconst_pragma ("vtable", 0);
334 sorry ("#pragma vtable no longer supported");
338 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
340 /* Validate syntax, but don't do anything. */
341 parse_strconst_pragma ("unit", 0);
345 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
347 tree fname = parse_strconst_pragma ("interface", 1);
348 struct c_fileinfo *finfo;
349 const char *filename;
351 if (fname == error_mark_node)
354 filename = lbasename (input_filename);
356 filename = TREE_STRING_POINTER (fname);
358 finfo = get_fileinfo (input_filename);
360 if (impl_file_chain == 0)
362 /* If this is zero at this point, then we are
363 auto-implementing. */
364 if (main_input_filename == 0)
365 main_input_filename = input_filename;
368 finfo->interface_only = interface_strcmp (filename);
369 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
370 a definition in another file. */
371 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
372 finfo->interface_unknown = 0;
375 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
376 We used to only allow this at toplevel, but that restriction was buggy
377 in older compilers and it seems reasonable to allow it in the headers
378 themselves, too. It only needs to precede the matching #p interface.
380 We don't touch finfo->interface_only or finfo->interface_unknown;
381 the user must specify a matching #p interface for this to have
385 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
387 tree fname = parse_strconst_pragma ("implementation", 1);
388 const char *filename;
389 struct impl_files *ifiles = impl_file_chain;
391 if (fname == error_mark_node)
396 if (main_input_filename)
397 filename = main_input_filename;
399 filename = input_filename;
400 filename = lbasename (filename);
404 filename = TREE_STRING_POINTER (fname);
405 if (cpp_included_before (parse_in, filename, input_location))
406 warning (0, "#pragma implementation for %qs appears after "
407 "file is included", filename);
410 for (; ifiles; ifiles = ifiles->next)
412 if (! strcmp (ifiles->filename, filename))
417 ifiles = XNEW (struct impl_files);
418 ifiles->filename = xstrdup (filename);
419 ifiles->next = impl_file_chain;
420 impl_file_chain = ifiles;
424 /* Indicate that this file uses Java-personality exception handling. */
426 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
429 if (pragma_lex (&x) != CPP_EOF)
430 warning (0, "junk at end of #pragma GCC java_exceptions");
432 choose_personality_routine (lang_java);
435 /* Issue an error message indicating that the lookup of NAME (an
436 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
439 unqualified_name_lookup_error (tree name)
441 if (IDENTIFIER_OPNAME_P (name))
443 if (name != ansi_opname (ERROR_MARK))
444 error ("%qD not defined", name);
448 error ("%qD was not declared in this scope", name);
449 /* Prevent repeated error messages by creating a VAR_DECL with
450 this NAME in the innermost block scope. */
451 if (current_function_decl)
454 decl = build_decl (VAR_DECL, name, error_mark_node);
455 DECL_CONTEXT (decl) = current_function_decl;
456 push_local_binding (name, decl, 0);
457 /* Mark the variable as used so that we do not get warnings
458 about it being unused later. */
459 TREE_USED (decl) = 1;
463 return error_mark_node;
466 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
467 used as a function. Returns an appropriate expression for
471 unqualified_fn_lookup_error (tree name)
473 if (processing_template_decl)
475 /* In a template, it is invalid to write "f()" or "f(3)" if no
476 declaration of "f" is available. Historically, G++ and most
477 other compilers accepted that usage since they deferred all name
478 lookup until instantiation time rather than doing unqualified
479 name lookup at template definition time; explain to the user what
482 Note that we have the exact wording of the following message in
483 the manual (trouble.texi, node "Name lookup"), so they need to
485 permerror (input_location, "there are no arguments to %qD that depend on a template "
486 "parameter, so a declaration of %qD must be available",
489 if (!flag_permissive)
494 inform (input_location, "(if you use %<-fpermissive%>, G++ will accept your "
495 "code, but allowing the use of an undeclared name is "
503 return unqualified_name_lookup_error (name);
507 build_lang_decl (enum tree_code code, tree name, tree type)
511 t = build_decl (code, name, type);
512 retrofit_lang_decl (t);
514 /* All nesting of C++ functions is lexical; there is never a "static
515 chain" in the sense of GNU C nested functions. */
516 if (code == FUNCTION_DECL)
517 DECL_NO_STATIC_CHAIN (t) = 1;
522 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
523 and pushdecl (for functions generated by the back end). */
526 retrofit_lang_decl (tree t)
528 struct lang_decl *ld;
531 if (CAN_HAVE_FULL_LANG_DECL_P (t))
532 size = sizeof (struct lang_decl);
534 size = sizeof (struct lang_decl_flags);
536 ld = GGC_CNEWVAR (struct lang_decl, size);
538 ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
539 ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
540 ld->decl_flags.u2sel = 0;
541 if (ld->decl_flags.can_be_full)
542 ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
544 DECL_LANG_SPECIFIC (t) = ld;
545 if (current_lang_name == lang_name_cplusplus
546 || decl_linkage (t) == lk_none)
547 SET_DECL_LANGUAGE (t, lang_cplusplus);
548 else if (current_lang_name == lang_name_c)
549 SET_DECL_LANGUAGE (t, lang_c);
550 else if (current_lang_name == lang_name_java)
551 SET_DECL_LANGUAGE (t, lang_java);
555 #ifdef GATHER_STATISTICS
556 tree_node_counts[(int)lang_decl] += 1;
557 tree_node_sizes[(int)lang_decl] += size;
562 cxx_dup_lang_specific_decl (tree node)
565 struct lang_decl *ld;
567 if (! DECL_LANG_SPECIFIC (node))
570 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
571 size = sizeof (struct lang_decl_flags);
573 size = sizeof (struct lang_decl);
574 ld = GGC_NEWVAR (struct lang_decl, size);
575 memcpy (ld, DECL_LANG_SPECIFIC (node), size);
576 DECL_LANG_SPECIFIC (node) = ld;
578 #ifdef GATHER_STATISTICS
579 tree_node_counts[(int)lang_decl] += 1;
580 tree_node_sizes[(int)lang_decl] += size;
584 /* Copy DECL, including any language-specific parts. */
587 copy_decl (tree decl)
591 copy = copy_node (decl);
592 cxx_dup_lang_specific_decl (copy);
596 /* Replace the shared language-specific parts of NODE with a new copy. */
599 copy_lang_type (tree node)
602 struct lang_type *lt;
604 if (! TYPE_LANG_SPECIFIC (node))
607 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
608 size = sizeof (struct lang_type);
610 size = sizeof (struct lang_type_ptrmem);
611 lt = GGC_NEWVAR (struct lang_type, size);
612 memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
613 TYPE_LANG_SPECIFIC (node) = lt;
615 #ifdef GATHER_STATISTICS
616 tree_node_counts[(int)lang_type] += 1;
617 tree_node_sizes[(int)lang_type] += size;
621 /* Copy TYPE, including any language-specific parts. */
624 copy_type (tree type)
628 copy = copy_node (type);
629 copy_lang_type (copy);
634 cxx_make_type (enum tree_code code)
636 tree t = make_node (code);
638 /* Create lang_type structure. */
639 if (RECORD_OR_UNION_CODE_P (code)
640 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
642 struct lang_type *pi = GGC_CNEW (struct lang_type);
644 TYPE_LANG_SPECIFIC (t) = pi;
645 pi->u.c.h.is_lang_type_class = 1;
647 #ifdef GATHER_STATISTICS
648 tree_node_counts[(int)lang_type] += 1;
649 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
653 /* Set up some flags that give proper default behavior. */
654 if (RECORD_OR_UNION_CODE_P (code))
656 struct c_fileinfo *finfo = get_fileinfo (input_filename);
657 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
658 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
665 make_class_type (enum tree_code code)
667 tree t = cxx_make_type (code);
668 SET_CLASS_TYPE_P (t, 1);
672 /* Returns true if we are currently in the main source file, or in a
673 template instantiation started from the main source file. */
676 in_main_input_context (void)
678 struct tinst_level *tl = outermost_tinst_level();
681 return strcmp (main_input_filename,
682 LOCATION_FILE (tl->locus)) == 0;
684 return strcmp (main_input_filename, input_filename) == 0;