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"
31 #include "stringpool.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
< cxx11
)
179 mask
|= D_ASM
| D_EXT
;
180 if (flag_no_gnu_keywords
)
183 /* The Objective-C keywords are all context-dependent. */
186 ridpointers
= ggc_cleared_vec_alloc
<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;
198 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
201 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
202 id
= get_identifier (name
);
203 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
204 C_IS_RESERVED_WORD (id
) = 1;
209 init_cp_pragma (void)
211 c_register_pragma (0, "vtable", handle_pragma_vtable
);
212 c_register_pragma (0, "unit", handle_pragma_unit
);
213 c_register_pragma (0, "interface", handle_pragma_interface
);
214 c_register_pragma (0, "implementation", handle_pragma_implementation
);
215 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
216 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
217 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions
);
220 /* TRUE if a code represents a statement. */
222 bool statement_code_p
[MAX_TREE_CODES
];
224 /* Initialize the C++ front end. This function is very sensitive to
225 the exact order that things are done here. It would be nice if the
226 initialization done by this routine were moved to its subroutines,
227 and the ordering dependencies clarified and reduced. */
231 location_t saved_loc
;
233 static const enum tree_code stmt_codes
[] = {
234 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
235 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
236 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
237 RANGE_FOR_STMT
, WHILE_STMT
, DO_STMT
,
238 BREAK_STMT
, CONTINUE_STMT
, SWITCH_STMT
,
242 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
243 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
244 statement_code_p
[stmt_codes
[i
]] = true;
246 saved_loc
= input_location
;
247 input_location
= BUILTINS_LOCATION
;
251 init_cp_semantics ();
255 current_function_decl
= NULL
;
257 class_type_node
= ridpointers
[(int) RID_CLASS
];
259 cxx_init_decl_processing ();
261 if (c_common_init () == false)
263 input_location
= saved_loc
;
271 input_location
= saved_loc
;
275 /* Return nonzero if S is not considered part of an
276 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
279 interface_strcmp (const char* s
)
281 /* Set the interface/implementation bits for this scope. */
282 struct impl_files
*ifiles
;
285 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
287 const char *t1
= ifiles
->filename
;
290 if (*s1
== 0 || filename_ncmp (s1
, t1
, 1) != 0)
293 while (*s1
!= 0 && filename_ncmp (s1
, t1
, 1) == 0)
300 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
301 if (strchr (s1
, '.') || strchr (t1
, '.'))
304 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
317 /* Parse a #pragma whose sole argument is a string constant.
318 If OPT is true, the argument is optional. */
320 parse_strconst_pragma (const char* name
, int opt
)
325 t
= pragma_lex (&result
);
328 if (pragma_lex (&x
) != CPP_EOF
)
329 warning (0, "junk at end of #pragma %s", name
);
333 if (t
== CPP_EOF
&& opt
)
336 error ("invalid #pragma %s", name
);
337 return error_mark_node
;
341 handle_pragma_vtable (cpp_reader
* /*dfile*/)
343 parse_strconst_pragma ("vtable", 0);
344 sorry ("#pragma vtable no longer supported");
348 handle_pragma_unit (cpp_reader
* /*dfile*/)
350 /* Validate syntax, but don't do anything. */
351 parse_strconst_pragma ("unit", 0);
355 handle_pragma_interface (cpp_reader
* /*dfile*/)
357 tree fname
= parse_strconst_pragma ("interface", 1);
358 struct c_fileinfo
*finfo
;
359 const char *filename
;
361 if (fname
== error_mark_node
)
364 filename
= lbasename (LOCATION_FILE (input_location
));
366 filename
= TREE_STRING_POINTER (fname
);
368 finfo
= get_fileinfo (LOCATION_FILE (input_location
));
370 if (impl_file_chain
== 0)
372 /* If this is zero at this point, then we are
373 auto-implementing. */
374 if (main_input_filename
== 0)
375 main_input_filename
= LOCATION_FILE (input_location
);
378 finfo
->interface_only
= interface_strcmp (filename
);
379 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
380 a definition in another file. */
381 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
382 finfo
->interface_unknown
= 0;
385 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
386 We used to only allow this at toplevel, but that restriction was buggy
387 in older compilers and it seems reasonable to allow it in the headers
388 themselves, too. It only needs to precede the matching #p interface.
390 We don't touch finfo->interface_only or finfo->interface_unknown;
391 the user must specify a matching #p interface for this to have
395 handle_pragma_implementation (cpp_reader
* /*dfile*/)
397 tree fname
= parse_strconst_pragma ("implementation", 1);
398 const char *filename
;
399 struct impl_files
*ifiles
= impl_file_chain
;
401 if (fname
== error_mark_node
)
406 if (main_input_filename
)
407 filename
= main_input_filename
;
409 filename
= LOCATION_FILE (input_location
);
410 filename
= lbasename (filename
);
414 filename
= TREE_STRING_POINTER (fname
);
415 if (cpp_included_before (parse_in
, filename
, input_location
))
416 warning (0, "#pragma implementation for %qs appears after "
417 "file is included", filename
);
420 for (; ifiles
; ifiles
= ifiles
->next
)
422 if (! filename_cmp (ifiles
->filename
, filename
))
427 ifiles
= XNEW (struct impl_files
);
428 ifiles
->filename
= xstrdup (filename
);
429 ifiles
->next
= impl_file_chain
;
430 impl_file_chain
= ifiles
;
434 /* Indicate that this file uses Java-personality exception handling. */
436 handle_pragma_java_exceptions (cpp_reader
* /*dfile*/)
439 if (pragma_lex (&x
) != CPP_EOF
)
440 warning (0, "junk at end of #pragma GCC java_exceptions");
442 choose_personality_routine (lang_java
);
443 pragma_java_exceptions
= true;
446 /* Issue an error message indicating that the lookup of NAME (an
447 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
450 unqualified_name_lookup_error (tree name
)
452 if (IDENTIFIER_OPNAME_P (name
))
454 if (name
!= ansi_opname (ERROR_MARK
))
455 error ("%qD not defined", name
);
459 if (!objc_diagnose_private_ivar (name
))
461 error ("%qD was not declared in this scope", name
);
462 suggest_alternatives_for (location_of (name
), name
);
464 /* Prevent repeated error messages by creating a VAR_DECL with
465 this NAME in the innermost block scope. */
466 if (local_bindings_p ())
469 decl
= build_decl (input_location
,
470 VAR_DECL
, name
, error_mark_node
);
471 DECL_CONTEXT (decl
) = current_function_decl
;
472 push_local_binding (name
, decl
, 0);
473 /* Mark the variable as used so that we do not get warnings
474 about it being unused later. */
475 TREE_USED (decl
) = 1;
479 return error_mark_node
;
482 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
483 used as a function. Returns an appropriate expression for
487 unqualified_fn_lookup_error (tree name
)
489 if (processing_template_decl
)
491 /* In a template, it is invalid to write "f()" or "f(3)" if no
492 declaration of "f" is available. Historically, G++ and most
493 other compilers accepted that usage since they deferred all name
494 lookup until instantiation time rather than doing unqualified
495 name lookup at template definition time; explain to the user what
498 Note that we have the exact wording of the following message in
499 the manual (trouble.texi, node "Name lookup"), so they need to
501 permerror (input_location
, "there are no arguments to %qD that depend on a template "
502 "parameter, so a declaration of %qD must be available",
505 if (!flag_permissive
)
510 inform (input_location
, "(if you use %<-fpermissive%>, G++ will accept your "
511 "code, but allowing the use of an undeclared name is "
519 return unqualified_name_lookup_error (name
);
522 /* Wrapper around build_lang_decl_loc(). Should gradually move to
523 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
524 build_lang_decl(). */
527 build_lang_decl (enum tree_code code
, tree name
, tree type
)
529 return build_lang_decl_loc (input_location
, code
, name
, type
);
532 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
533 DECL_LANG_SPECIFIC info to the result. */
536 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
540 t
= build_decl (loc
, code
, name
, type
);
541 retrofit_lang_decl (t
);
546 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
547 and pushdecl (for functions generated by the back end). */
550 retrofit_lang_decl (tree t
)
552 struct lang_decl
*ld
;
556 if (DECL_LANG_SPECIFIC (t
))
559 if (TREE_CODE (t
) == FUNCTION_DECL
)
560 sel
= 1, size
= sizeof (struct lang_decl_fn
);
561 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
562 sel
= 2, size
= sizeof (struct lang_decl_ns
);
563 else if (TREE_CODE (t
) == PARM_DECL
)
564 sel
= 3, size
= sizeof (struct lang_decl_parm
);
565 else if (LANG_DECL_HAS_MIN (t
))
566 sel
= 0, size
= sizeof (struct lang_decl_min
);
570 ld
= (struct lang_decl
*) ggc_internal_cleared_alloc (size
);
572 ld
->u
.base
.selector
= sel
;
574 DECL_LANG_SPECIFIC (t
) = ld
;
575 if (current_lang_name
== lang_name_cplusplus
576 || decl_linkage (t
) == lk_none
)
577 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
578 else if (current_lang_name
== lang_name_c
)
579 SET_DECL_LANGUAGE (t
, lang_c
);
580 else if (current_lang_name
== lang_name_java
)
581 SET_DECL_LANGUAGE (t
, lang_java
);
585 if (GATHER_STATISTICS
)
587 tree_node_counts
[(int)lang_decl
] += 1;
588 tree_node_sizes
[(int)lang_decl
] += size
;
593 cxx_dup_lang_specific_decl (tree node
)
596 struct lang_decl
*ld
;
598 if (! DECL_LANG_SPECIFIC (node
))
601 if (TREE_CODE (node
) == FUNCTION_DECL
)
602 size
= sizeof (struct lang_decl_fn
);
603 else if (TREE_CODE (node
) == NAMESPACE_DECL
)
604 size
= sizeof (struct lang_decl_ns
);
605 else if (TREE_CODE (node
) == PARM_DECL
)
606 size
= sizeof (struct lang_decl_parm
);
607 else if (LANG_DECL_HAS_MIN (node
))
608 size
= sizeof (struct lang_decl_min
);
612 ld
= (struct lang_decl
*) ggc_internal_alloc (size
);
613 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
614 DECL_LANG_SPECIFIC (node
) = ld
;
616 if (GATHER_STATISTICS
)
618 tree_node_counts
[(int)lang_decl
] += 1;
619 tree_node_sizes
[(int)lang_decl
] += size
;
623 /* Copy DECL, including any language-specific parts. */
626 copy_decl (tree decl
)
630 copy
= copy_node (decl
);
631 cxx_dup_lang_specific_decl (copy
);
635 /* Replace the shared language-specific parts of NODE with a new copy. */
638 copy_lang_type (tree node
)
641 struct lang_type
*lt
;
643 if (! TYPE_LANG_SPECIFIC (node
))
646 if (TYPE_LANG_SPECIFIC (node
)->u
.h
.is_lang_type_class
)
647 size
= sizeof (struct lang_type
);
649 size
= sizeof (struct lang_type_ptrmem
);
650 lt
= (struct lang_type
*) ggc_internal_alloc (size
);
651 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), size
);
652 TYPE_LANG_SPECIFIC (node
) = lt
;
654 if (GATHER_STATISTICS
)
656 tree_node_counts
[(int)lang_type
] += 1;
657 tree_node_sizes
[(int)lang_type
] += size
;
661 /* Copy TYPE, including any language-specific parts. */
664 copy_type (tree type
)
668 copy
= copy_node (type
);
669 copy_lang_type (copy
);
674 cxx_make_type (enum tree_code code
)
676 tree t
= make_node (code
);
678 /* Create lang_type structure. */
679 if (RECORD_OR_UNION_CODE_P (code
)
680 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
683 = (struct lang_type
*) ggc_internal_cleared_alloc
684 (sizeof (struct lang_type
));
686 TYPE_LANG_SPECIFIC (t
) = pi
;
687 pi
->u
.c
.h
.is_lang_type_class
= 1;
689 if (GATHER_STATISTICS
)
691 tree_node_counts
[(int)lang_type
] += 1;
692 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
696 /* Set up some flags that give proper default behavior. */
697 if (RECORD_OR_UNION_CODE_P (code
))
699 struct c_fileinfo
*finfo
= \
700 get_fileinfo (LOCATION_FILE (input_location
));
701 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
702 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
709 make_class_type (enum tree_code code
)
711 tree t
= cxx_make_type (code
);
712 SET_CLASS_TYPE_P (t
, 1);
716 /* Returns true if we are currently in the main source file, or in a
717 template instantiation started from the main source file. */
720 in_main_input_context (void)
722 struct tinst_level
*tl
= outermost_tinst_level();
725 return filename_cmp (main_input_filename
,
726 LOCATION_FILE (tl
->locus
)) == 0;
728 return filename_cmp (main_input_filename
, LOCATION_FILE (input_location
)) == 0;