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, 2010
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"
35 #include "c-family/c-pragma.h"
36 #include "c-family/c-objc.h"
40 static int interface_strcmp (const char *);
41 static void init_cp_pragma (void);
43 static tree
parse_strconst_pragma (const char *, int);
44 static void handle_pragma_vtable (cpp_reader
*);
45 static void handle_pragma_unit (cpp_reader
*);
46 static void handle_pragma_interface (cpp_reader
*);
47 static void handle_pragma_implementation (cpp_reader
*);
48 static void handle_pragma_java_exceptions (cpp_reader
*);
50 static void init_operators (void);
51 static void copy_lang_type (tree
);
53 /* A constraint that can be tested at compile time. */
54 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
56 /* Functions and data structures for #pragma interface.
58 `#pragma implementation' means that the main file being compiled
59 is considered to implement (provide) the classes that appear in
60 its main body. I.e., if this is file "foo.cc", and class `bar'
61 is defined in "foo.cc", then we say that "foo.cc implements bar".
63 All main input files "implement" themselves automagically.
65 `#pragma interface' means that unless this file (of the form "foo.h"
66 is not presently being included by file "foo.cc", the
67 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
68 of the vtables nor any of the inline functions defined in foo.h
71 There are cases when we want to link files such as "defs.h" and
72 "main.cc". In this case, we give "defs.h" a `#pragma interface',
73 and "main.cc" has `#pragma implementation "defs.h"'. */
78 struct impl_files
*next
;
81 static struct impl_files
*impl_file_chain
;
83 /* True if we saw "#pragma GCC java_exceptions". */
84 bool pragma_java_exceptions
;
92 /* A mapping from tree codes to operator name information. */
93 operator_name_info_t operator_name_info
[(int) MAX_TREE_CODES
];
94 /* Similar, but for assignment operators. */
95 operator_name_info_t assignment_operator_name_info
[(int) MAX_TREE_CODES
];
97 /* Initialize data structures that keep track of operator names. */
99 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
100 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
101 #include "operators.def"
105 init_operators (void)
109 struct operator_name_info_t
*oni
;
111 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
112 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
113 identifier = get_identifier (buffer); \
114 IDENTIFIER_OPNAME_P (identifier) = 1; \
117 ? &assignment_operator_name_info[(int) CODE] \
118 : &operator_name_info[(int) CODE]); \
119 oni->identifier = identifier; \
121 oni->mangled_name = MANGLING; \
124 #include "operators.def"
127 operator_name_info
[(int) ERROR_MARK
].identifier
128 = get_identifier ("<invalid operator>");
130 /* Handle some special cases. These operators are not defined in
131 the language, but can be produced internally. We may need them
132 for error-reporting. (Eventually, we should ensure that this
133 does not happen. Error messages involving these operators will
134 be confusing to users.) */
136 operator_name_info
[(int) INIT_EXPR
].name
137 = operator_name_info
[(int) MODIFY_EXPR
].name
;
138 operator_name_info
[(int) EXACT_DIV_EXPR
].name
= "(ceiling /)";
139 operator_name_info
[(int) CEIL_DIV_EXPR
].name
= "(ceiling /)";
140 operator_name_info
[(int) FLOOR_DIV_EXPR
].name
= "(floor /)";
141 operator_name_info
[(int) ROUND_DIV_EXPR
].name
= "(round /)";
142 operator_name_info
[(int) CEIL_MOD_EXPR
].name
= "(ceiling %)";
143 operator_name_info
[(int) FLOOR_MOD_EXPR
].name
= "(floor %)";
144 operator_name_info
[(int) ROUND_MOD_EXPR
].name
= "(round %)";
145 operator_name_info
[(int) ABS_EXPR
].name
= "abs";
146 operator_name_info
[(int) TRUTH_AND_EXPR
].name
= "strict &&";
147 operator_name_info
[(int) TRUTH_OR_EXPR
].name
= "strict ||";
148 operator_name_info
[(int) RANGE_EXPR
].name
= "...";
149 operator_name_info
[(int) UNARY_PLUS_EXPR
].name
= "+";
151 assignment_operator_name_info
[(int) EXACT_DIV_EXPR
].name
153 assignment_operator_name_info
[(int) CEIL_DIV_EXPR
].name
155 assignment_operator_name_info
[(int) FLOOR_DIV_EXPR
].name
157 assignment_operator_name_info
[(int) ROUND_DIV_EXPR
].name
159 assignment_operator_name_info
[(int) CEIL_MOD_EXPR
].name
161 assignment_operator_name_info
[(int) FLOOR_MOD_EXPR
].name
163 assignment_operator_name_info
[(int) ROUND_MOD_EXPR
].name
167 /* Initialize the reserved words. */
176 if (cxx_dialect
< cxx0x
)
179 mask
|= D_ASM
| D_EXT
;
180 if (flag_no_gnu_keywords
)
183 /* The Objective-C keywords are all context-dependent. */
186 ridpointers
= ggc_alloc_cleared_vec_tree ((int) RID_MAX
);
187 for (i
= 0; i
< num_c_common_reswords
; i
++)
189 if (c_common_reswords
[i
].disable
& D_CONLY
)
191 id
= get_identifier (c_common_reswords
[i
].word
);
192 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
193 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
194 if (! (c_common_reswords
[i
].disable
& mask
))
195 C_IS_RESERVED_WORD (id
) = 1;
200 init_cp_pragma (void)
202 c_register_pragma (0, "vtable", handle_pragma_vtable
);
203 c_register_pragma (0, "unit", handle_pragma_unit
);
204 c_register_pragma (0, "interface", handle_pragma_interface
);
205 c_register_pragma (0, "implementation", handle_pragma_implementation
);
206 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
207 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
208 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions
);
211 /* TRUE if a code represents a statement. */
213 bool statement_code_p
[MAX_TREE_CODES
];
215 /* Initialize the C++ front end. This function is very sensitive to
216 the exact order that things are done here. It would be nice if the
217 initialization done by this routine were moved to its subroutines,
218 and the ordering dependencies clarified and reduced. */
222 location_t saved_loc
;
224 static const enum tree_code stmt_codes
[] = {
225 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
226 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
227 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
228 RANGE_FOR_STMT
, WHILE_STMT
, DO_STMT
,
229 BREAK_STMT
, CONTINUE_STMT
, SWITCH_STMT
,
233 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
234 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
235 statement_code_p
[stmt_codes
[i
]] = true;
237 saved_loc
= input_location
;
238 input_location
= BUILTINS_LOCATION
;
242 init_cp_semantics ();
247 current_function_decl
= NULL
;
249 class_type_node
= ridpointers
[(int) RID_CLASS
];
251 cxx_init_decl_processing ();
253 if (c_common_init () == false)
255 input_location
= saved_loc
;
263 input_location
= saved_loc
;
267 /* Return nonzero if S is not considered part of an
268 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
271 interface_strcmp (const char* s
)
273 /* Set the interface/implementation bits for this scope. */
274 struct impl_files
*ifiles
;
277 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
279 const char *t1
= ifiles
->filename
;
282 if (*s1
== 0 || filename_ncmp (s1
, t1
, 1) != 0)
285 while (*s1
!= 0 && filename_ncmp (s1
, t1
, 1) == 0)
292 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
293 if (strchr (s1
, '.') || strchr (t1
, '.'))
296 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
309 /* Parse a #pragma whose sole argument is a string constant.
310 If OPT is true, the argument is optional. */
312 parse_strconst_pragma (const char* name
, int opt
)
317 t
= pragma_lex (&result
);
320 if (pragma_lex (&x
) != CPP_EOF
)
321 warning (0, "junk at end of #pragma %s", name
);
325 if (t
== CPP_EOF
&& opt
)
328 error ("invalid #pragma %s", name
);
329 return error_mark_node
;
333 handle_pragma_vtable (cpp_reader
* /*dfile*/)
335 parse_strconst_pragma ("vtable", 0);
336 sorry ("#pragma vtable no longer supported");
340 handle_pragma_unit (cpp_reader
* /*dfile*/)
342 /* Validate syntax, but don't do anything. */
343 parse_strconst_pragma ("unit", 0);
347 handle_pragma_interface (cpp_reader
* /*dfile*/)
349 tree fname
= parse_strconst_pragma ("interface", 1);
350 struct c_fileinfo
*finfo
;
351 const char *filename
;
353 if (fname
== error_mark_node
)
356 filename
= lbasename (input_filename
);
358 filename
= TREE_STRING_POINTER (fname
);
360 finfo
= get_fileinfo (input_filename
);
362 if (impl_file_chain
== 0)
364 /* If this is zero at this point, then we are
365 auto-implementing. */
366 if (main_input_filename
== 0)
367 main_input_filename
= input_filename
;
370 finfo
->interface_only
= interface_strcmp (filename
);
371 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
372 a definition in another file. */
373 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
374 finfo
->interface_unknown
= 0;
377 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
378 We used to only allow this at toplevel, but that restriction was buggy
379 in older compilers and it seems reasonable to allow it in the headers
380 themselves, too. It only needs to precede the matching #p interface.
382 We don't touch finfo->interface_only or finfo->interface_unknown;
383 the user must specify a matching #p interface for this to have
387 handle_pragma_implementation (cpp_reader
* /*dfile*/)
389 tree fname
= parse_strconst_pragma ("implementation", 1);
390 const char *filename
;
391 struct impl_files
*ifiles
= impl_file_chain
;
393 if (fname
== error_mark_node
)
398 if (main_input_filename
)
399 filename
= main_input_filename
;
401 filename
= input_filename
;
402 filename
= lbasename (filename
);
406 filename
= TREE_STRING_POINTER (fname
);
407 if (cpp_included_before (parse_in
, filename
, input_location
))
408 warning (0, "#pragma implementation for %qs appears after "
409 "file is included", filename
);
412 for (; ifiles
; ifiles
= ifiles
->next
)
414 if (! filename_cmp (ifiles
->filename
, filename
))
419 ifiles
= XNEW (struct impl_files
);
420 ifiles
->filename
= xstrdup (filename
);
421 ifiles
->next
= impl_file_chain
;
422 impl_file_chain
= ifiles
;
426 /* Indicate that this file uses Java-personality exception handling. */
428 handle_pragma_java_exceptions (cpp_reader
* /*dfile*/)
431 if (pragma_lex (&x
) != CPP_EOF
)
432 warning (0, "junk at end of #pragma GCC java_exceptions");
434 choose_personality_routine (lang_java
);
435 pragma_java_exceptions
= true;
438 /* Issue an error message indicating that the lookup of NAME (an
439 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
442 unqualified_name_lookup_error (tree name
)
444 if (IDENTIFIER_OPNAME_P (name
))
446 if (name
!= ansi_opname (ERROR_MARK
))
447 error ("%qD not defined", name
);
451 if (!objc_diagnose_private_ivar (name
))
453 error ("%qD was not declared in this scope", name
);
454 suggest_alternatives_for (location_of (name
), name
);
456 /* Prevent repeated error messages by creating a VAR_DECL with
457 this NAME in the innermost block scope. */
458 if (local_bindings_p ())
461 decl
= build_decl (input_location
,
462 VAR_DECL
, name
, error_mark_node
);
463 DECL_CONTEXT (decl
) = current_function_decl
;
464 push_local_binding (name
, decl
, 0);
465 /* Mark the variable as used so that we do not get warnings
466 about it being unused later. */
467 TREE_USED (decl
) = 1;
471 return error_mark_node
;
474 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
475 used as a function. Returns an appropriate expression for
479 unqualified_fn_lookup_error (tree name
)
481 if (processing_template_decl
)
483 /* In a template, it is invalid to write "f()" or "f(3)" if no
484 declaration of "f" is available. Historically, G++ and most
485 other compilers accepted that usage since they deferred all name
486 lookup until instantiation time rather than doing unqualified
487 name lookup at template definition time; explain to the user what
490 Note that we have the exact wording of the following message in
491 the manual (trouble.texi, node "Name lookup"), so they need to
493 permerror (input_location
, "there are no arguments to %qD that depend on a template "
494 "parameter, so a declaration of %qD must be available",
497 if (!flag_permissive
)
502 inform (input_location
, "(if you use %<-fpermissive%>, G++ will accept your "
503 "code, but allowing the use of an undeclared name is "
511 return unqualified_name_lookup_error (name
);
514 /* Wrapper around build_lang_decl_loc(). Should gradually move to
515 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
516 build_lang_decl(). */
519 build_lang_decl (enum tree_code code
, tree name
, tree type
)
521 return build_lang_decl_loc (input_location
, code
, name
, type
);
524 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
525 DECL_LANG_SPECIFIC info to the result. */
528 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
532 t
= build_decl (loc
, code
, name
, type
);
533 retrofit_lang_decl (t
);
538 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
539 and pushdecl (for functions generated by the back end). */
542 retrofit_lang_decl (tree t
)
544 struct lang_decl
*ld
;
548 if (TREE_CODE (t
) == FUNCTION_DECL
)
549 sel
= 1, size
= sizeof (struct lang_decl_fn
);
550 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
551 sel
= 2, size
= sizeof (struct lang_decl_ns
);
552 else if (TREE_CODE (t
) == PARM_DECL
)
553 sel
= 3, size
= sizeof (struct lang_decl_parm
);
554 else if (LANG_DECL_HAS_MIN (t
))
555 sel
= 0, size
= sizeof (struct lang_decl_min
);
559 ld
= ggc_alloc_cleared_lang_decl (size
);
561 ld
->u
.base
.selector
= sel
;
563 DECL_LANG_SPECIFIC (t
) = ld
;
564 if (current_lang_name
== lang_name_cplusplus
565 || decl_linkage (t
) == lk_none
)
566 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
567 else if (current_lang_name
== lang_name_c
)
568 SET_DECL_LANGUAGE (t
, lang_c
);
569 else if (current_lang_name
== lang_name_java
)
570 SET_DECL_LANGUAGE (t
, lang_java
);
574 if (GATHER_STATISTICS
)
576 tree_node_counts
[(int)lang_decl
] += 1;
577 tree_node_sizes
[(int)lang_decl
] += size
;
582 cxx_dup_lang_specific_decl (tree node
)
585 struct lang_decl
*ld
;
587 if (! DECL_LANG_SPECIFIC (node
))
590 if (TREE_CODE (node
) == FUNCTION_DECL
)
591 size
= sizeof (struct lang_decl_fn
);
592 else if (TREE_CODE (node
) == NAMESPACE_DECL
)
593 size
= sizeof (struct lang_decl_ns
);
594 else if (TREE_CODE (node
) == PARM_DECL
)
595 size
= sizeof (struct lang_decl_parm
);
596 else if (LANG_DECL_HAS_MIN (node
))
597 size
= sizeof (struct lang_decl_min
);
601 ld
= ggc_alloc_lang_decl (size
);
602 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
603 DECL_LANG_SPECIFIC (node
) = ld
;
605 if (GATHER_STATISTICS
)
607 tree_node_counts
[(int)lang_decl
] += 1;
608 tree_node_sizes
[(int)lang_decl
] += size
;
612 /* Copy DECL, including any language-specific parts. */
615 copy_decl (tree decl
)
619 copy
= copy_node (decl
);
620 cxx_dup_lang_specific_decl (copy
);
624 /* Replace the shared language-specific parts of NODE with a new copy. */
627 copy_lang_type (tree node
)
630 struct lang_type
*lt
;
632 if (! TYPE_LANG_SPECIFIC (node
))
635 if (TYPE_LANG_SPECIFIC (node
)->u
.h
.is_lang_type_class
)
636 size
= sizeof (struct lang_type
);
638 size
= sizeof (struct lang_type_ptrmem
);
639 lt
= ggc_alloc_lang_type (size
);
640 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), size
);
641 TYPE_LANG_SPECIFIC (node
) = lt
;
643 if (GATHER_STATISTICS
)
645 tree_node_counts
[(int)lang_type
] += 1;
646 tree_node_sizes
[(int)lang_type
] += size
;
650 /* Copy TYPE, including any language-specific parts. */
653 copy_type (tree type
)
657 copy
= copy_node (type
);
658 copy_lang_type (copy
);
663 cxx_make_type (enum tree_code code
)
665 tree t
= make_node (code
);
667 /* Create lang_type structure. */
668 if (RECORD_OR_UNION_CODE_P (code
)
669 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
672 = ggc_alloc_cleared_lang_type (sizeof (struct lang_type
));
674 TYPE_LANG_SPECIFIC (t
) = pi
;
675 pi
->u
.c
.h
.is_lang_type_class
= 1;
677 if (GATHER_STATISTICS
)
679 tree_node_counts
[(int)lang_type
] += 1;
680 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
684 /* Set up some flags that give proper default behavior. */
685 if (RECORD_OR_UNION_CODE_P (code
))
687 struct c_fileinfo
*finfo
= get_fileinfo (input_filename
);
688 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
689 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
696 make_class_type (enum tree_code code
)
698 tree t
= cxx_make_type (code
);
699 SET_CLASS_TYPE_P (t
, 1);
703 /* Returns true if we are currently in the main source file, or in a
704 template instantiation started from the main source file. */
707 in_main_input_context (void)
709 struct tinst_level
*tl
= outermost_tinst_level();
712 return filename_cmp (main_input_filename
,
713 LOCATION_FILE (tl
->locus
)) == 0;
715 return filename_cmp (main_input_filename
, input_filename
) == 0;