1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC 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 3, or (at your option)
12 GCC 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.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file is the lexical analyzer for GNU C++. */
26 #include "coretypes.h"
30 #include "stringpool.h"
34 #include "c-family/c-pragma.h"
35 #include "c-family/c-objc.h"
39 static int interface_strcmp (const char *);
40 static void init_cp_pragma (void);
42 static tree
parse_strconst_pragma (const char *, int);
43 static void handle_pragma_vtable (cpp_reader
*);
44 static void handle_pragma_unit (cpp_reader
*);
45 static void handle_pragma_interface (cpp_reader
*);
46 static void handle_pragma_implementation (cpp_reader
*);
47 static void handle_pragma_java_exceptions (cpp_reader
*);
49 static void init_operators (void);
50 static void copy_lang_type (tree
);
52 /* A constraint that can be tested at compile time. */
53 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
55 /* Functions and data structures for #pragma interface.
57 `#pragma implementation' means that the main file being compiled
58 is considered to implement (provide) the classes that appear in
59 its main body. I.e., if this is file "foo.cc", and class `bar'
60 is defined in "foo.cc", then we say that "foo.cc implements bar".
62 All main input files "implement" themselves automagically.
64 `#pragma interface' means that unless this file (of the form "foo.h"
65 is not presently being included by file "foo.cc", the
66 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
67 of the vtables nor any of the inline functions defined in foo.h
70 There are cases when we want to link files such as "defs.h" and
71 "main.cc". In this case, we give "defs.h" a `#pragma interface',
72 and "main.cc" has `#pragma implementation "defs.h"'. */
77 struct impl_files
*next
;
80 static struct impl_files
*impl_file_chain
;
82 /* True if we saw "#pragma GCC java_exceptions". */
83 bool pragma_java_exceptions
;
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
< cxx11
)
178 mask
|= D_CXX_CONCEPTS
;
180 mask
|= D_ASM
| D_EXT
;
181 if (flag_no_gnu_keywords
)
184 /* The Objective-C keywords are all context-dependent. */
187 ridpointers
= ggc_cleared_vec_alloc
<tree
> ((int) RID_MAX
);
188 for (i
= 0; i
< num_c_common_reswords
; i
++)
190 if (c_common_reswords
[i
].disable
& D_CONLY
)
192 id
= get_identifier (c_common_reswords
[i
].word
);
193 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
194 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
195 if (! (c_common_reswords
[i
].disable
& mask
))
196 C_IS_RESERVED_WORD (id
) = 1;
199 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
202 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
203 id
= get_identifier (name
);
204 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
205 C_IS_RESERVED_WORD (id
) = 1;
210 init_cp_pragma (void)
212 c_register_pragma (0, "vtable", handle_pragma_vtable
);
213 c_register_pragma (0, "unit", handle_pragma_unit
);
214 c_register_pragma (0, "interface", handle_pragma_interface
);
215 c_register_pragma (0, "implementation", handle_pragma_implementation
);
216 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
217 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
218 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions
);
221 /* TRUE if a code represents a statement. */
223 bool statement_code_p
[MAX_TREE_CODES
];
225 /* Initialize the C++ front end. This function is very sensitive to
226 the exact order that things are done here. It would be nice if the
227 initialization done by this routine were moved to its subroutines,
228 and the ordering dependencies clarified and reduced. */
232 location_t saved_loc
;
234 static const enum tree_code stmt_codes
[] = {
235 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
236 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
237 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
238 RANGE_FOR_STMT
, WHILE_STMT
, DO_STMT
,
239 BREAK_STMT
, CONTINUE_STMT
, SWITCH_STMT
,
243 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
244 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
245 statement_code_p
[stmt_codes
[i
]] = true;
247 saved_loc
= input_location
;
248 input_location
= BUILTINS_LOCATION
;
252 init_cp_semantics ();
256 current_function_decl
= NULL
;
258 class_type_node
= ridpointers
[(int) RID_CLASS
];
260 cxx_init_decl_processing ();
262 if (c_common_init () == false)
264 input_location
= saved_loc
;
272 input_location
= saved_loc
;
276 /* Return nonzero if S is not considered part of an
277 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
280 interface_strcmp (const char* s
)
282 /* Set the interface/implementation bits for this scope. */
283 struct impl_files
*ifiles
;
286 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
288 const char *t1
= ifiles
->filename
;
291 if (*s1
== 0 || filename_ncmp (s1
, t1
, 1) != 0)
294 while (*s1
!= 0 && filename_ncmp (s1
, t1
, 1) == 0)
301 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
302 if (strchr (s1
, '.') || strchr (t1
, '.'))
305 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
318 /* Parse a #pragma whose sole argument is a string constant.
319 If OPT is true, the argument is optional. */
321 parse_strconst_pragma (const char* name
, int opt
)
326 t
= pragma_lex (&result
);
329 if (pragma_lex (&x
) != CPP_EOF
)
330 warning (0, "junk at end of #pragma %s", name
);
334 if (t
== CPP_EOF
&& opt
)
337 error ("invalid #pragma %s", name
);
338 return error_mark_node
;
342 handle_pragma_vtable (cpp_reader
* /*dfile*/)
344 parse_strconst_pragma ("vtable", 0);
345 sorry ("#pragma vtable no longer supported");
349 handle_pragma_unit (cpp_reader
* /*dfile*/)
351 /* Validate syntax, but don't do anything. */
352 parse_strconst_pragma ("unit", 0);
356 handle_pragma_interface (cpp_reader
* /*dfile*/)
358 tree fname
= parse_strconst_pragma ("interface", 1);
359 struct c_fileinfo
*finfo
;
360 const char *filename
;
362 if (fname
== error_mark_node
)
365 filename
= lbasename (LOCATION_FILE (input_location
));
367 filename
= TREE_STRING_POINTER (fname
);
369 finfo
= get_fileinfo (LOCATION_FILE (input_location
));
371 if (impl_file_chain
== 0)
373 /* If this is zero at this point, then we are
374 auto-implementing. */
375 if (main_input_filename
== 0)
376 main_input_filename
= LOCATION_FILE (input_location
);
379 finfo
->interface_only
= interface_strcmp (filename
);
380 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
381 a definition in another file. */
382 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
383 finfo
->interface_unknown
= 0;
386 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
387 We used to only allow this at toplevel, but that restriction was buggy
388 in older compilers and it seems reasonable to allow it in the headers
389 themselves, too. It only needs to precede the matching #p interface.
391 We don't touch finfo->interface_only or finfo->interface_unknown;
392 the user must specify a matching #p interface for this to have
396 handle_pragma_implementation (cpp_reader
* /*dfile*/)
398 tree fname
= parse_strconst_pragma ("implementation", 1);
399 const char *filename
;
400 struct impl_files
*ifiles
= impl_file_chain
;
402 if (fname
== error_mark_node
)
407 if (main_input_filename
)
408 filename
= main_input_filename
;
410 filename
= LOCATION_FILE (input_location
);
411 filename
= lbasename (filename
);
415 filename
= TREE_STRING_POINTER (fname
);
416 if (cpp_included_before (parse_in
, filename
, input_location
))
417 warning (0, "#pragma implementation for %qs appears after "
418 "file is included", filename
);
421 for (; ifiles
; ifiles
= ifiles
->next
)
423 if (! filename_cmp (ifiles
->filename
, filename
))
428 ifiles
= XNEW (struct impl_files
);
429 ifiles
->filename
= xstrdup (filename
);
430 ifiles
->next
= impl_file_chain
;
431 impl_file_chain
= ifiles
;
435 /* Indicate that this file uses Java-personality exception handling. */
437 handle_pragma_java_exceptions (cpp_reader
* /*dfile*/)
440 if (pragma_lex (&x
) != CPP_EOF
)
441 warning (0, "junk at end of #pragma GCC java_exceptions");
443 choose_personality_routine (lang_java
);
444 pragma_java_exceptions
= true;
447 /* Issue an error message indicating that the lookup of NAME (an
448 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
451 unqualified_name_lookup_error (tree name
)
453 if (IDENTIFIER_OPNAME_P (name
))
455 if (name
!= ansi_opname (ERROR_MARK
))
456 error ("%qD not defined", name
);
460 if (!objc_diagnose_private_ivar (name
))
462 error ("%qD was not declared in this scope", name
);
463 suggest_alternatives_for (location_of (name
), name
);
465 /* Prevent repeated error messages by creating a VAR_DECL with
466 this NAME in the innermost block scope. */
467 if (local_bindings_p ())
470 decl
= build_decl (input_location
,
471 VAR_DECL
, name
, error_mark_node
);
472 DECL_CONTEXT (decl
) = current_function_decl
;
473 push_local_binding (name
, decl
, 0);
474 /* Mark the variable as used so that we do not get warnings
475 about it being unused later. */
476 TREE_USED (decl
) = 1;
480 return error_mark_node
;
483 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
484 used as a function. Returns an appropriate expression for
488 unqualified_fn_lookup_error (tree name
)
490 if (processing_template_decl
)
492 /* In a template, it is invalid to write "f()" or "f(3)" if no
493 declaration of "f" is available. Historically, G++ and most
494 other compilers accepted that usage since they deferred all name
495 lookup until instantiation time rather than doing unqualified
496 name lookup at template definition time; explain to the user what
499 Note that we have the exact wording of the following message in
500 the manual (trouble.texi, node "Name lookup"), so they need to
502 permerror (input_location
, "there are no arguments to %qD that depend on a template "
503 "parameter, so a declaration of %qD must be available",
506 if (!flag_permissive
)
511 inform (input_location
, "(if you use %<-fpermissive%>, G++ will accept your "
512 "code, but allowing the use of an undeclared name is "
520 return unqualified_name_lookup_error (name
);
523 /* Wrapper around build_lang_decl_loc(). Should gradually move to
524 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
525 build_lang_decl(). */
528 build_lang_decl (enum tree_code code
, tree name
, tree type
)
530 return build_lang_decl_loc (input_location
, code
, name
, type
);
533 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
534 DECL_LANG_SPECIFIC info to the result. */
537 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
541 t
= build_decl (loc
, code
, name
, type
);
542 retrofit_lang_decl (t
);
547 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
548 and pushdecl (for functions generated by the back end). */
551 retrofit_lang_decl (tree t
)
553 struct lang_decl
*ld
;
557 if (DECL_LANG_SPECIFIC (t
))
560 if (TREE_CODE (t
) == FUNCTION_DECL
)
561 sel
= 1, size
= sizeof (struct lang_decl_fn
);
562 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
563 sel
= 2, size
= sizeof (struct lang_decl_ns
);
564 else if (TREE_CODE (t
) == PARM_DECL
)
565 sel
= 3, size
= sizeof (struct lang_decl_parm
);
566 else if (LANG_DECL_HAS_MIN (t
))
567 sel
= 0, size
= sizeof (struct lang_decl_min
);
571 ld
= (struct lang_decl
*) ggc_internal_cleared_alloc (size
);
573 ld
->u
.base
.selector
= sel
;
575 DECL_LANG_SPECIFIC (t
) = ld
;
576 if (current_lang_name
== lang_name_cplusplus
577 || decl_linkage (t
) == lk_none
)
578 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
579 else if (current_lang_name
== lang_name_c
)
580 SET_DECL_LANGUAGE (t
, lang_c
);
581 else if (current_lang_name
== lang_name_java
)
582 SET_DECL_LANGUAGE (t
, lang_java
);
586 if (GATHER_STATISTICS
)
588 tree_node_counts
[(int)lang_decl
] += 1;
589 tree_node_sizes
[(int)lang_decl
] += size
;
594 cxx_dup_lang_specific_decl (tree node
)
597 struct lang_decl
*ld
;
599 if (! DECL_LANG_SPECIFIC (node
))
602 if (TREE_CODE (node
) == FUNCTION_DECL
)
603 size
= sizeof (struct lang_decl_fn
);
604 else if (TREE_CODE (node
) == NAMESPACE_DECL
)
605 size
= sizeof (struct lang_decl_ns
);
606 else if (TREE_CODE (node
) == PARM_DECL
)
607 size
= sizeof (struct lang_decl_parm
);
608 else if (LANG_DECL_HAS_MIN (node
))
609 size
= sizeof (struct lang_decl_min
);
613 ld
= (struct lang_decl
*) ggc_internal_alloc (size
);
614 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
615 DECL_LANG_SPECIFIC (node
) = ld
;
617 if (GATHER_STATISTICS
)
619 tree_node_counts
[(int)lang_decl
] += 1;
620 tree_node_sizes
[(int)lang_decl
] += size
;
624 /* Copy DECL, including any language-specific parts. */
627 copy_decl (tree decl
)
631 copy
= copy_node (decl
);
632 cxx_dup_lang_specific_decl (copy
);
636 /* Replace the shared language-specific parts of NODE with a new copy. */
639 copy_lang_type (tree node
)
642 struct lang_type
*lt
;
644 if (! TYPE_LANG_SPECIFIC (node
))
647 if (TYPE_LANG_SPECIFIC (node
)->u
.h
.is_lang_type_class
)
648 size
= sizeof (struct lang_type
);
650 size
= sizeof (struct lang_type_ptrmem
);
651 lt
= (struct lang_type
*) ggc_internal_alloc (size
);
652 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), size
);
653 TYPE_LANG_SPECIFIC (node
) = lt
;
655 if (GATHER_STATISTICS
)
657 tree_node_counts
[(int)lang_type
] += 1;
658 tree_node_sizes
[(int)lang_type
] += size
;
662 /* Copy TYPE, including any language-specific parts. */
665 copy_type (tree type
)
669 copy
= copy_node (type
);
670 copy_lang_type (copy
);
675 cxx_make_type (enum tree_code code
)
677 tree t
= make_node (code
);
679 /* Create lang_type structure. */
680 if (RECORD_OR_UNION_CODE_P (code
)
681 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
684 = (struct lang_type
*) ggc_internal_cleared_alloc
685 (sizeof (struct lang_type
));
687 TYPE_LANG_SPECIFIC (t
) = pi
;
688 pi
->u
.c
.h
.is_lang_type_class
= 1;
690 if (GATHER_STATISTICS
)
692 tree_node_counts
[(int)lang_type
] += 1;
693 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
697 /* Set up some flags that give proper default behavior. */
698 if (RECORD_OR_UNION_CODE_P (code
))
700 struct c_fileinfo
*finfo
= \
701 get_fileinfo (LOCATION_FILE (input_location
));
702 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
703 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
710 make_class_type (enum tree_code code
)
712 tree t
= cxx_make_type (code
);
713 SET_CLASS_TYPE_P (t
, 1);
717 /* Returns true if we are currently in the main source file, or in a
718 template instantiation started from the main source file. */
721 in_main_input_context (void)
723 struct tinst_level
*tl
= outermost_tinst_level();
726 return filename_cmp (main_input_filename
,
727 LOCATION_FILE (tl
->locus
)) == 0;
729 return filename_cmp (main_input_filename
, LOCATION_FILE (input_location
)) == 0;