1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This file is the lexical analyzer for GNU C++. */
26 /* Cause the `yydebug' variable to be defined. */
45 #include "diagnostic.h"
47 #ifdef MULTIBYTE_CHARS
52 extern void yyprint PARAMS ((FILE *, int, YYSTYPE));
54 static int interface_strcmp PARAMS ((const char *));
55 static int *init_cpp_parse PARAMS ((void));
56 static void init_reswords PARAMS ((void));
57 static void init_cp_pragma PARAMS ((void));
59 static tree parse_strconst_pragma PARAMS ((const char *, int));
60 static void handle_pragma_vtable PARAMS ((cpp_reader *));
61 static void handle_pragma_unit PARAMS ((cpp_reader *));
62 static void handle_pragma_interface PARAMS ((cpp_reader *));
63 static void handle_pragma_implementation PARAMS ((cpp_reader *));
64 static void handle_pragma_java_exceptions PARAMS ((cpp_reader *));
65 static void cxx_init PARAMS ((void));
66 static void cxx_finish PARAMS ((void));
67 static void cxx_init_options PARAMS ((void));
68 static void cxx_post_options PARAMS ((void));
70 #ifdef GATHER_STATISTICS
72 static int reduce_cmp PARAMS ((int *, int *));
73 static int token_cmp PARAMS ((int *, int *));
76 static int is_global PARAMS ((tree));
77 static void init_operators PARAMS ((void));
79 /* A constraint that can be tested at compile time. */
81 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
83 #define CONSTRAINT(name, expr) extern int constraint_/**/name [(expr) ? 1 : -1]
88 extern int yychar; /* the lookahead symbol */
89 extern YYSTYPE yylval; /* the semantic value of the */
90 /* lookahead symbol */
92 /* These flags are used by c-lex.c. In C++, they're always off and on,
94 int warn_traditional = 0;
95 int flag_digraphs = 1;
97 /* the declaration found for the last IDENTIFIER token read in.
98 yylex must look this up to detect typedefs, which get token type TYPENAME,
99 so it is left around in case the identifier is not a typedef but is
100 used in a context which makes it a reference to a variable. */
103 /* Array for holding counts of the numbers of tokens seen. */
104 extern int *token_count;
106 /* Functions and data structures for #pragma interface.
108 `#pragma implementation' means that the main file being compiled
109 is considered to implement (provide) the classes that appear in
110 its main body. I.e., if this is file "foo.cc", and class `bar'
111 is defined in "foo.cc", then we say that "foo.cc implements bar".
113 All main input files "implement" themselves automagically.
115 `#pragma interface' means that unless this file (of the form "foo.h"
116 is not presently being included by file "foo.cc", the
117 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
118 of the vtables nor any of the inline functions defined in foo.h
121 There are cases when we want to link files such as "defs.h" and
122 "main.cc". In this case, we give "defs.h" a `#pragma interface',
123 and "main.cc" has `#pragma implementation "defs.h"'. */
127 const char *filename;
128 struct impl_files *next;
131 static struct impl_files *impl_file_chain;
134 /* Return something to represent absolute declarators containing a *.
135 TARGET is the absolute declarator that the * contains.
136 CV_QUALIFIERS is a list of modifiers such as const or volatile
137 to apply to the pointer type, represented as identifiers.
139 We return an INDIRECT_REF whose "contents" are TARGET
140 and whose type is the modifier list. */
143 make_pointer_declarator (cv_qualifiers, target)
144 tree cv_qualifiers, target;
146 if (target && TREE_CODE (target) == IDENTIFIER_NODE
147 && ANON_AGGRNAME_P (target))
148 error ("type name expected before `*'");
149 target = build_nt (INDIRECT_REF, target);
150 TREE_TYPE (target) = cv_qualifiers;
154 /* Return something to represent absolute declarators containing a &.
155 TARGET is the absolute declarator that the & contains.
156 CV_QUALIFIERS is a list of modifiers such as const or volatile
157 to apply to the reference type, represented as identifiers.
159 We return an ADDR_EXPR whose "contents" are TARGET
160 and whose type is the modifier list. */
163 make_reference_declarator (cv_qualifiers, target)
164 tree cv_qualifiers, target;
168 if (TREE_CODE (target) == ADDR_EXPR)
170 error ("cannot declare references to references");
173 if (TREE_CODE (target) == INDIRECT_REF)
175 error ("cannot declare pointers to references");
178 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
179 error ("type name expected before `&'");
181 target = build_nt (ADDR_EXPR, target);
182 TREE_TYPE (target) = cv_qualifiers;
187 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
188 tree target, parms, cv_qualifiers, exception_specification;
190 target = build_nt (CALL_EXPR, target,
191 tree_cons (parms, cv_qualifiers, NULL_TREE),
192 /* The third operand is really RTL. We
193 shouldn't put anything there. */
195 CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
200 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
201 tree call_declarator, cv_qualifiers, exception_specification;
203 CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
204 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
207 int interface_only; /* whether or not current file is only for
208 interface definitions. */
209 int interface_unknown; /* whether or not we know this class
210 to behave according to #pragma interface. */
212 /* Tree code classes. */
214 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
216 static char cplus_tree_code_type[] = {
218 #include "cp-tree.def"
222 /* Table indexed by tree code giving number of expression
223 operands beyond the fixed part of the node structure.
224 Not used for types or decls. */
226 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
228 static int cplus_tree_code_length[] = {
230 #include "cp-tree.def"
234 /* Names of tree components.
235 Used for printing out the tree and error messages. */
236 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
238 static const char *const cplus_tree_code_name[] = {
240 #include "cp-tree.def"
244 /* Each front end provides its own hooks, for toplev.c. */
245 struct lang_hooks lang_hooks = {cxx_init,
251 /* Post-switch processing. */
255 cpp_post_options (parse_in);
261 /* Make identifier nodes long enough for the language-specific slots. */
262 set_identifier_size (sizeof (struct lang_identifier));
264 parse_in = cpp_create_reader (ident_hash, CLK_GNUCXX);
266 /* Default exceptions on. */
268 /* Mark as "unspecified". */
269 flag_bounds_check = -1;
270 /* By default wrap lines at 80 characters. Is getenv ("COLUMNS")
272 diagnostic_line_cutoff (global_dc) = 80;
273 /* By default, emit location information once for every
274 diagnostic message. */
275 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
281 c_common_lang_init ();
283 if (flag_gnu_xref) GNU_xref_begin (input_filename);
284 init_repo (input_filename);
290 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
302 #ifdef GATHER_STATISTICS
304 reduce_count = (int *) xcalloc (sizeof (int), (REDUCE_LENGTH + 1));
306 token_count = (int *) xcalloc (sizeof (int), (TOKEN_LENGTH + 1));
313 /* A mapping from tree codes to operator name information. */
314 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
315 /* Similar, but for assignment operators. */
316 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
318 /* Initialize data structures that keep track of operator names. */
320 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
321 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
322 #include "operators.def"
330 struct operator_name_info_t *oni;
332 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
333 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
334 identifier = get_identifier (buffer); \
335 IDENTIFIER_OPNAME_P (identifier) = 1; \
338 ? &assignment_operator_name_info[(int) CODE] \
339 : &operator_name_info[(int) CODE]); \
340 oni->identifier = identifier; \
342 oni->mangled_name = MANGLING;
344 #include "operators.def"
347 operator_name_info[(int) ERROR_MARK].identifier
348 = get_identifier ("<invalid operator>");
350 /* Handle some special cases. These operators are not defined in
351 the language, but can be produced internally. We may need them
352 for error-reporting. (Eventually, we should ensure that this
353 does not happen. Error messages involving these operators will
354 be confusing to users.) */
356 operator_name_info [(int) INIT_EXPR].name
357 = operator_name_info [(int) MODIFY_EXPR].name;
358 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
359 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
360 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
361 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
362 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
363 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
364 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
365 operator_name_info [(int) ABS_EXPR].name = "abs";
366 operator_name_info [(int) FFS_EXPR].name = "ffs";
367 operator_name_info [(int) BIT_ANDTC_EXPR].name = "&~";
368 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
369 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
370 operator_name_info [(int) IN_EXPR].name = "in";
371 operator_name_info [(int) RANGE_EXPR].name = "...";
372 operator_name_info [(int) CONVERT_EXPR].name = "+";
374 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
376 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
378 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
380 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
382 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
384 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
386 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
390 /* The reserved keyword table. */
394 ENUM_BITFIELD(rid) rid : 16;
395 unsigned int disable : 16;
398 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
400 #define D_EXT 0x01 /* GCC extension */
401 #define D_ASM 0x02 /* in C99, but has a switch to turn it off */
402 #define D_OPNAME 0x04 /* operator names */
404 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
406 static const struct resword reswords[] =
408 { "_Complex", RID_COMPLEX, 0 },
409 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
410 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
411 { "__alignof", RID_ALIGNOF, 0 },
412 { "__alignof__", RID_ALIGNOF, 0 },
413 { "__asm", RID_ASM, 0 },
414 { "__asm__", RID_ASM, 0 },
415 { "__attribute", RID_ATTRIBUTE, 0 },
416 { "__attribute__", RID_ATTRIBUTE, 0 },
417 { "__builtin_va_arg", RID_VA_ARG, 0 },
418 { "__complex", RID_COMPLEX, 0 },
419 { "__complex__", RID_COMPLEX, 0 },
420 { "__const", RID_CONST, 0 },
421 { "__const__", RID_CONST, 0 },
422 { "__extension__", RID_EXTENSION, 0 },
423 { "__func__", RID_C99_FUNCTION_NAME, 0 },
424 { "__imag", RID_IMAGPART, 0 },
425 { "__imag__", RID_IMAGPART, 0 },
426 { "__inline", RID_INLINE, 0 },
427 { "__inline__", RID_INLINE, 0 },
428 { "__label__", RID_LABEL, 0 },
429 { "__null", RID_NULL, 0 },
430 { "__real", RID_REALPART, 0 },
431 { "__real__", RID_REALPART, 0 },
432 { "__restrict", RID_RESTRICT, 0 },
433 { "__restrict__", RID_RESTRICT, 0 },
434 { "__signed", RID_SIGNED, 0 },
435 { "__signed__", RID_SIGNED, 0 },
436 { "__typeof", RID_TYPEOF, 0 },
437 { "__typeof__", RID_TYPEOF, 0 },
438 { "__volatile", RID_VOLATILE, 0 },
439 { "__volatile__", RID_VOLATILE, 0 },
440 { "asm", RID_ASM, D_ASM },
441 { "and", RID_AND, D_OPNAME },
442 { "and_eq", RID_AND_EQ, D_OPNAME },
443 { "auto", RID_AUTO, 0 },
444 { "bitand", RID_BITAND, D_OPNAME },
445 { "bitor", RID_BITOR, D_OPNAME },
446 { "bool", RID_BOOL, 0 },
447 { "break", RID_BREAK, 0 },
448 { "case", RID_CASE, 0 },
449 { "catch", RID_CATCH, 0 },
450 { "char", RID_CHAR, 0 },
451 { "class", RID_CLASS, 0 },
452 { "compl", RID_COMPL, D_OPNAME },
453 { "const", RID_CONST, 0 },
454 { "const_cast", RID_CONSTCAST, 0 },
455 { "continue", RID_CONTINUE, 0 },
456 { "default", RID_DEFAULT, 0 },
457 { "delete", RID_DELETE, 0 },
459 { "double", RID_DOUBLE, 0 },
460 { "dynamic_cast", RID_DYNCAST, 0 },
461 { "else", RID_ELSE, 0 },
462 { "enum", RID_ENUM, 0 },
463 { "explicit", RID_EXPLICIT, 0 },
464 { "export", RID_EXPORT, 0 },
465 { "extern", RID_EXTERN, 0 },
466 { "false", RID_FALSE, 0 },
467 { "float", RID_FLOAT, 0 },
468 { "for", RID_FOR, 0 },
469 { "friend", RID_FRIEND, 0 },
470 { "goto", RID_GOTO, 0 },
472 { "inline", RID_INLINE, 0 },
473 { "int", RID_INT, 0 },
474 { "long", RID_LONG, 0 },
475 { "mutable", RID_MUTABLE, 0 },
476 { "namespace", RID_NAMESPACE, 0 },
477 { "new", RID_NEW, 0 },
478 { "not", RID_NOT, D_OPNAME },
479 { "not_eq", RID_NOT_EQ, D_OPNAME },
480 { "operator", RID_OPERATOR, 0 },
481 { "or", RID_OR, D_OPNAME },
482 { "or_eq", RID_OR_EQ, D_OPNAME },
483 { "private", RID_PRIVATE, 0 },
484 { "protected", RID_PROTECTED, 0 },
485 { "public", RID_PUBLIC, 0 },
486 { "register", RID_REGISTER, 0 },
487 { "reinterpret_cast", RID_REINTCAST, 0 },
488 { "return", RID_RETURN, 0 },
489 { "short", RID_SHORT, 0 },
490 { "signed", RID_SIGNED, 0 },
491 { "sizeof", RID_SIZEOF, 0 },
492 { "static", RID_STATIC, 0 },
493 { "static_cast", RID_STATCAST, 0 },
494 { "struct", RID_STRUCT, 0 },
495 { "switch", RID_SWITCH, 0 },
496 { "template", RID_TEMPLATE, 0 },
497 { "this", RID_THIS, 0 },
498 { "throw", RID_THROW, 0 },
499 { "true", RID_TRUE, 0 },
500 { "try", RID_TRY, 0 },
501 { "typedef", RID_TYPEDEF, 0 },
502 { "typename", RID_TYPENAME, 0 },
503 { "typeid", RID_TYPEID, 0 },
504 { "typeof", RID_TYPEOF, D_ASM|D_EXT },
505 { "union", RID_UNION, 0 },
506 { "unsigned", RID_UNSIGNED, 0 },
507 { "using", RID_USING, 0 },
508 { "virtual", RID_VIRTUAL, 0 },
509 { "void", RID_VOID, 0 },
510 { "volatile", RID_VOLATILE, 0 },
511 { "wchar_t", RID_WCHAR, 0 },
512 { "while", RID_WHILE, 0 },
513 { "xor", RID_XOR, D_OPNAME },
514 { "xor_eq", RID_XOR_EQ, D_OPNAME },
517 #define N_reswords (sizeof reswords / sizeof (struct resword))
519 /* Table mapping from RID_* constants to yacc token numbers.
520 Unfortunately we have to have entries for all the keywords in all
522 const short rid_to_yy[RID_MAX] =
524 /* RID_STATIC */ SCSPEC,
525 /* RID_UNSIGNED */ TYPESPEC,
526 /* RID_LONG */ TYPESPEC,
527 /* RID_CONST */ CV_QUALIFIER,
528 /* RID_EXTERN */ SCSPEC,
529 /* RID_REGISTER */ SCSPEC,
530 /* RID_TYPEDEF */ SCSPEC,
531 /* RID_SHORT */ TYPESPEC,
532 /* RID_INLINE */ SCSPEC,
533 /* RID_VOLATILE */ CV_QUALIFIER,
534 /* RID_SIGNED */ TYPESPEC,
535 /* RID_AUTO */ SCSPEC,
536 /* RID_RESTRICT */ CV_QUALIFIER,
538 /* C extensions. Bounded pointers are not yet in C++ */
540 /* RID_UNBOUNDED */ 0,
541 /* RID_COMPLEX */ TYPESPEC,
544 /* RID_FRIEND */ SCSPEC,
545 /* RID_VIRTUAL */ SCSPEC,
546 /* RID_EXPLICIT */ SCSPEC,
547 /* RID_EXPORT */ EXPORT,
548 /* RID_MUTABLE */ SCSPEC,
559 /* RID_INT */ TYPESPEC,
560 /* RID_CHAR */ TYPESPEC,
561 /* RID_FLOAT */ TYPESPEC,
562 /* RID_DOUBLE */ TYPESPEC,
563 /* RID_VOID */ TYPESPEC,
565 /* RID_STRUCT */ AGGR,
566 /* RID_UNION */ AGGR,
569 /* RID_WHILE */ WHILE,
572 /* RID_SWITCH */ SWITCH,
574 /* RID_DEFAULT */ DEFAULT,
575 /* RID_BREAK */ BREAK,
576 /* RID_CONTINUE */ CONTINUE,
577 /* RID_RETURN */ RETURN_KEYWORD,
579 /* RID_SIZEOF */ SIZEOF,
582 /* RID_ASM */ ASM_KEYWORD,
583 /* RID_TYPEOF */ TYPEOF,
584 /* RID_ALIGNOF */ ALIGNOF,
585 /* RID_ATTRIBUTE */ ATTRIBUTE,
586 /* RID_VA_ARG */ VA_ARG,
587 /* RID_EXTENSION */ EXTENSION,
588 /* RID_IMAGPART */ IMAGPART,
589 /* RID_REALPART */ REALPART,
590 /* RID_LABEL */ LABEL,
592 /* RID_PTREXTENT */ 0,
593 /* RID_PTRVALUE */ 0,
595 /* RID_FUNCTION_NAME */ VAR_FUNC_NAME,
596 /* RID_PRETTY_FUNCTION_NAME */ VAR_FUNC_NAME,
597 /* RID_c99_FUNCTION_NAME */ VAR_FUNC_NAME,
600 /* RID_BOOL */ TYPESPEC,
601 /* RID_WCHAR */ TYPESPEC,
602 /* RID_CLASS */ AGGR,
603 /* RID_PUBLIC */ VISSPEC,
604 /* RID_PRIVATE */ VISSPEC,
605 /* RID_PROTECTED */ VISSPEC,
606 /* RID_TEMPLATE */ TEMPLATE,
607 /* RID_NULL */ CONSTANT,
608 /* RID_CATCH */ CATCH,
609 /* RID_DELETE */ DELETE,
610 /* RID_FALSE */ CXX_FALSE,
611 /* RID_NAMESPACE */ NAMESPACE,
613 /* RID_OPERATOR */ OPERATOR,
615 /* RID_THROW */ THROW,
616 /* RID_TRUE */ CXX_TRUE,
618 /* RID_TYPENAME */ TYPENAME_KEYWORD,
619 /* RID_TYPEID */ TYPEID,
620 /* RID_USING */ USING,
623 /* RID_CONSTCAST */ CONST_CAST,
624 /* RID_DYNCAST */ DYNAMIC_CAST,
625 /* RID_REINTCAST */ REINTERPRET_CAST,
626 /* RID_STATCAST */ STATIC_CAST,
628 /* alternate spellings */
629 /* RID_AND */ ANDAND,
630 /* RID_AND_EQ */ ASSIGN,
632 /* RID_NOT_EQ */ EQCOMPARE,
634 /* RID_OR_EQ */ ASSIGN,
636 /* RID_XOR_EQ */ ASSIGN,
637 /* RID_BITAND */ '&',
643 /* RID_AT_ENCODE */ 0,
645 /* RID_AT_CLASS */ 0,
646 /* RID_AT_ALIAS */ 0,
648 /* RID_AT_PRIVATE */ 0,
649 /* RID_AT_PROTECTED */ 0,
650 /* RID_AT_PUBLIC */ 0,
651 /* RID_AT_PROTOCOL */ 0,
652 /* RID_AT_SELECTOR */ 0,
653 /* RID_AT_INTERFACE */ 0,
654 /* RID_AT_IMPLEMENTATION */ 0
662 int mask = ((flag_operator_names ? 0 : D_OPNAME)
663 | (flag_no_asm ? D_ASM : 0)
664 | (flag_no_gnu_keywords ? D_EXT : 0));
666 /* It is not necessary to register ridpointers as a GC root, because
667 all the trees it points to are permanently interned in the
668 get_identifier hash anyway. */
669 ridpointers = (tree *) xcalloc ((int) RID_MAX, sizeof (tree));
670 for (i = 0; i < N_reswords; i++)
672 id = get_identifier (reswords[i].word);
673 C_RID_CODE (id) = reswords[i].rid;
674 ridpointers [(int) reswords[i].rid] = id;
675 if (! (reswords[i].disable & mask))
676 C_IS_RESERVED_WORD (id) = 1;
683 cpp_register_pragma (parse_in, 0, "vtable", handle_pragma_vtable);
684 cpp_register_pragma (parse_in, 0, "unit", handle_pragma_unit);
686 cpp_register_pragma (parse_in, 0, "interface", handle_pragma_interface);
687 cpp_register_pragma (parse_in, 0, "implementation",
688 handle_pragma_implementation);
690 cpp_register_pragma_space (parse_in, "GCC");
691 cpp_register_pragma (parse_in, "GCC", "interface", handle_pragma_interface);
692 cpp_register_pragma (parse_in, "GCC", "implementation",
693 handle_pragma_implementation);
694 cpp_register_pragma (parse_in, "GCC", "java_exceptions",
695 handle_pragma_java_exceptions);
699 init_parse (filename)
700 const char *filename;
702 decl_printable_name = lang_printable_name;
704 input_filename = "<internal>";
711 init_cplus_expand ();
712 init_cp_semantics ();
716 memcpy (tree_code_type + (int) LAST_C_TREE_CODE,
717 cplus_tree_code_type,
718 (int)LAST_CPLUS_TREE_CODE - (int)LAST_C_TREE_CODE);
719 memcpy (tree_code_length + (int) LAST_C_TREE_CODE,
720 cplus_tree_code_length,
721 (LAST_CPLUS_TREE_CODE - (int)LAST_C_TREE_CODE) * sizeof (int));
722 memcpy (tree_code_name + (int) LAST_C_TREE_CODE,
723 cplus_tree_code_name,
724 (LAST_CPLUS_TREE_CODE - (int)LAST_C_TREE_CODE) * sizeof (char *));
730 current_function_decl = NULL;
732 class_type_node = build_int_2 (class_type, 0);
733 TREE_TYPE (class_type_node) = class_type_node;
734 ridpointers[(int) RID_CLASS] = class_type_node;
736 record_type_node = build_int_2 (record_type, 0);
737 TREE_TYPE (record_type_node) = record_type_node;
738 ridpointers[(int) RID_STRUCT] = record_type_node;
740 union_type_node = build_int_2 (union_type, 0);
741 TREE_TYPE (union_type_node) = union_type_node;
742 ridpointers[(int) RID_UNION] = union_type_node;
744 enum_type_node = build_int_2 (enum_type, 0);
745 TREE_TYPE (enum_type_node) = enum_type_node;
746 ridpointers[(int) RID_ENUM] = enum_type_node;
748 /* Create the built-in __null node. Note that we can't yet call for
749 type_for_size here because integer_type_node and so forth are not
750 set up. Therefore, we don't set the type of these nodes until
751 init_decl_processing. */
752 null_node = build_int_2 (0, 0);
753 ridpointers[RID_NULL] = null_node;
755 token_count = init_cpp_parse ();
756 interface_unknown = 1;
758 return init_c_lex (filename);
764 cpp_finish (parse_in);
765 /* Call to cpp_destroy () omitted for performance reasons. */
766 errorcount += cpp_errors (parse_in);
770 yyprint (file, yychar, yylval)
783 case IDENTIFIER_DEFN:
787 case PRE_PARSED_CLASS_DECL:
789 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
791 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
794 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
795 if (IDENTIFIER_POINTER (t))
796 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
800 if (yylval.ttype == class_type_node)
801 fprintf (file, " `class'");
802 else if (yylval.ttype == record_type_node)
803 fprintf (file, " `struct'");
804 else if (yylval.ttype == union_type_node)
805 fprintf (file, " `union'");
806 else if (yylval.ttype == enum_type_node)
807 fprintf (file, " `enum'");
809 my_friendly_abort (80);
814 if (TREE_CODE (t) == INTEGER_CST)
816 #if HOST_BITS_PER_WIDE_INT == 64
817 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
820 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
827 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
833 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
838 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
839 static int *reduce_count;
845 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
846 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
849 #ifdef GATHER_STATISTICS
855 reduce_count[yyn] += 1;
862 return reduce_count[*q] - reduce_count[*p];
869 return token_count[*q] - token_count[*p];
875 print_parse_statistics ()
877 #ifdef GATHER_STATISTICS
881 int maxlen = REDUCE_LENGTH;
884 if (reduce_count[-1] == 0)
887 if (TOKEN_LENGTH > REDUCE_LENGTH)
888 maxlen = TOKEN_LENGTH;
889 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
891 for (i = 0; i < TOKEN_LENGTH; i++)
893 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
894 for (i = 0; i < TOKEN_LENGTH; i++)
897 if (token_count[idx] == 0)
899 if (token_count[idx] < token_count[-1])
901 fprintf (stderr, "token %d, `%s', count = %d\n",
902 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
904 fprintf (stderr, "\n");
905 for (i = 0; i < REDUCE_LENGTH; i++)
907 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
908 for (i = 0; i < REDUCE_LENGTH; i++)
911 if (reduce_count[idx] == 0)
913 if (reduce_count[idx] < reduce_count[-1])
915 fprintf (stderr, "rule %d, line %d, count = %d\n",
916 idx, yyrline[idx], reduce_count[idx]);
918 fprintf (stderr, "\n");
924 /* Sets the value of the 'yydebug' variable to VALUE.
925 This is a function so we don't have to have YYDEBUG defined
926 in order to build the compiler. */
936 warning ("YYDEBUG not defined.");
940 /* Helper function to load global variables with interface
944 extract_interface_info ()
946 struct c_fileinfo *finfo = 0;
948 if (flag_alt_external_templates)
950 tree til = tinst_for_decl ();
953 finfo = get_fileinfo (TINST_FILE (til));
956 finfo = get_fileinfo (input_filename);
958 interface_only = finfo->interface_only;
959 interface_unknown = finfo->interface_unknown;
961 /* This happens to be a convenient place to put this. */
962 if (flag_gnu_xref) GNU_xref_file (input_filename);
965 /* Return nonzero if S is not considered part of an
966 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
972 /* Set the interface/implementation bits for this scope. */
973 struct impl_files *ifiles;
976 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
978 const char *t1 = ifiles->filename;
981 if (*s1 != *t1 || *s1 == 0)
984 while (*s1 == *t1 && *s1 != 0)
991 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
992 if (strchr (s1, '.') || strchr (t1, '.'))
995 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1006 /* Heuristic to tell whether the user is missing a semicolon
1007 after a struct or enum declaration. Emit an error message
1008 if we know the user has blown it. */
1011 check_for_missing_semicolon (type)
1019 && yychar != IDENTIFIER
1020 && yychar != TYPENAME
1021 && yychar != CV_QUALIFIER
1022 && yychar != SELFNAME)
1023 || yychar == 0 /* EOF */)
1025 if (TYPE_ANONYMOUS_P (type))
1026 error ("semicolon missing after %s declaration",
1027 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
1029 cp_error ("semicolon missing after declaration of `%T'", type);
1030 shadow_tag (build_tree_list (0, type));
1032 /* Could probably also hack cases where class { ... } f (); appears. */
1037 note_got_semicolon (type)
1041 my_friendly_abort (60);
1042 if (CLASS_TYPE_P (type))
1043 CLASSTYPE_GOT_SEMICOLON (type) = 1;
1047 note_list_got_semicolon (declspecs)
1052 for (link = declspecs; link; link = TREE_CHAIN (link))
1054 tree type = TREE_VALUE (link);
1056 note_got_semicolon (type);
1062 /* Parse a #pragma whose sole argument is a string constant.
1063 If OPT is true, the argument is optional. */
1065 parse_strconst_pragma (name, opt)
1073 if (t == CPP_STRING)
1076 if (c_lex (&x) != CPP_EOF)
1077 warning ("junk at end of #pragma %s", name);
1081 if (t == CPP_EOF && opt)
1084 error ("invalid #pragma %s", name);
1089 handle_pragma_vtable (dfile)
1090 cpp_reader *dfile ATTRIBUTE_UNUSED;
1092 parse_strconst_pragma ("vtable", 0);
1093 sorry ("#pragma vtable no longer supported");
1097 handle_pragma_unit (dfile)
1098 cpp_reader *dfile ATTRIBUTE_UNUSED;
1100 /* Validate syntax, but don't do anything. */
1101 parse_strconst_pragma ("unit", 0);
1105 handle_pragma_interface (dfile)
1106 cpp_reader *dfile ATTRIBUTE_UNUSED;
1108 tree fname = parse_strconst_pragma ("interface", 1);
1109 struct c_fileinfo *finfo;
1110 const char *main_filename;
1112 if (fname == (tree)-1)
1114 else if (fname == 0)
1115 main_filename = lbasename (input_filename);
1117 main_filename = TREE_STRING_POINTER (fname);
1119 finfo = get_fileinfo (input_filename);
1121 if (impl_file_chain == 0)
1123 /* If this is zero at this point, then we are
1124 auto-implementing. */
1125 if (main_input_filename == 0)
1126 main_input_filename = input_filename;
1129 interface_only = interface_strcmp (main_filename);
1130 #ifdef MULTIPLE_SYMBOL_SPACES
1131 if (! interface_only)
1133 interface_unknown = 0;
1135 finfo->interface_only = interface_only;
1136 finfo->interface_unknown = interface_unknown;
1139 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1140 We used to only allow this at toplevel, but that restriction was buggy
1141 in older compilers and it seems reasonable to allow it in the headers
1142 themselves, too. It only needs to precede the matching #p interface.
1144 We don't touch interface_only or interface_unknown; the user must specify
1145 a matching #p interface for this to have any effect. */
1148 handle_pragma_implementation (dfile)
1149 cpp_reader *dfile ATTRIBUTE_UNUSED;
1151 tree fname = parse_strconst_pragma ("implementation", 1);
1152 const char *main_filename;
1153 struct impl_files *ifiles = impl_file_chain;
1155 if (fname == (tree)-1)
1160 if (main_input_filename)
1161 main_filename = main_input_filename;
1163 main_filename = input_filename;
1164 main_filename = lbasename (main_filename);
1168 main_filename = TREE_STRING_POINTER (fname);
1169 if (cpp_included (parse_in, main_filename))
1170 warning ("#pragma implementation for %s appears after file is included",
1174 for (; ifiles; ifiles = ifiles->next)
1176 if (! strcmp (ifiles->filename, main_filename))
1181 ifiles = (struct impl_files*) xmalloc (sizeof (struct impl_files));
1182 ifiles->filename = main_filename;
1183 ifiles->next = impl_file_chain;
1184 impl_file_chain = ifiles;
1188 /* Indicate that this file uses Java-personality exception handling. */
1190 handle_pragma_java_exceptions (dfile)
1191 cpp_reader *dfile ATTRIBUTE_UNUSED;
1194 if (c_lex (&x) != CPP_EOF)
1195 warning ("junk at end of #pragma GCC java_exceptions");
1197 choose_personality_routine (lang_java);
1201 do_pending_lang_change ()
1203 for (; pending_lang_change > 0; --pending_lang_change)
1204 push_lang_context (lang_name_c);
1205 for (; pending_lang_change < 0; ++pending_lang_change)
1206 pop_lang_context ();
1209 /* Return true if d is in a global scope. */
1216 switch (TREE_CODE (d))
1221 case OVERLOAD: d = OVL_FUNCTION (d); continue;
1222 case TREE_LIST: d = TREE_VALUE (d); continue;
1224 my_friendly_assert (DECL_P (d), 980629);
1226 return DECL_NAMESPACE_SCOPE_P (d);
1231 do_identifier (token, parsing, args)
1232 register tree token;
1237 int lexing = (parsing == 1);
1240 id = lookup_name (token, 0);
1244 /* Do Koenig lookup if appropriate (inside templates we build lookup
1245 expressions instead).
1247 [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
1248 finds the declaration of a class member function, the associated
1249 namespaces and classes are not considered. */
1251 if (args && !current_template_parms && (!id || is_global (id)))
1252 id = lookup_arg_dependent (token, id, args);
1254 /* Remember that this name has been used in the class definition, as per
1257 maybe_note_name_used_in_class (token, id);
1259 if (id == error_mark_node)
1261 /* lookup_name quietly returns error_mark_node if we're parsing,
1262 as we don't want to complain about an identifier that ends up
1263 being used as a declarator. So we call it again to get the error
1265 id = lookup_name (token, 0);
1266 return error_mark_node;
1269 if (!id || (TREE_CODE (id) == FUNCTION_DECL
1270 && DECL_ANTICIPATED (id)))
1272 if (current_template_parms)
1273 return build_min_nt (LOOKUP_EXPR, token);
1274 else if (IDENTIFIER_OPNAME_P (token))
1276 if (token != ansi_opname (ERROR_MARK))
1277 cp_error ("`%D' not defined", token);
1278 id = error_mark_node;
1280 else if (current_function_decl == 0)
1282 cp_error ("`%D' was not declared in this scope", token);
1283 id = error_mark_node;
1287 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
1288 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
1290 static int undeclared_variable_notice;
1292 cp_error ("`%D' undeclared (first use this function)", token);
1294 if (! undeclared_variable_notice)
1296 error ("(Each undeclared identifier is reported only once for each function it appears in.)");
1297 undeclared_variable_notice = 1;
1300 id = error_mark_node;
1301 /* Prevent repeated error messages. */
1302 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
1303 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
1307 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
1309 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
1310 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1311 && DECL_DEAD_FOR_LOCAL (shadowed))
1312 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1314 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
1317 if (!DECL_ERROR_REPORTED (id))
1319 warning ("name lookup of `%s' changed",
1320 IDENTIFIER_POINTER (token));
1321 cp_warning_at (" matches this `%D' under ISO standard rules",
1323 cp_warning_at (" matches this `%D' under old rules", id);
1324 DECL_ERROR_REPORTED (id) = 1;
1328 else if (!DECL_ERROR_REPORTED (id))
1330 DECL_ERROR_REPORTED (id) = 1;
1331 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (id)))
1333 error ("name lookup of `%s' changed for new ISO `for' scoping",
1334 IDENTIFIER_POINTER (token));
1335 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
1336 id = error_mark_node;
1340 pedwarn ("name lookup of `%s' changed for new ISO `for' scoping",
1341 IDENTIFIER_POINTER (token));
1342 cp_pedwarn_at (" using obsolete binding at `%D'", id);
1346 /* TREE_USED is set in `hack_identifier'. */
1347 if (TREE_CODE (id) == CONST_DECL)
1350 if (IDENTIFIER_CLASS_VALUE (token) == id)
1351 enforce_access (CP_DECL_CONTEXT(id), id);
1352 if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
1353 id = DECL_INITIAL (id);
1356 id = hack_identifier (id, token);
1358 /* We must look up dependent names when the template is
1359 instantiated, not while parsing it. For now, we don't
1360 distinguish between dependent and independent names. So, for
1361 example, we look up all overloaded functions at
1362 instantiation-time, even though in some cases we should just use
1363 the DECL we have here. We also use LOOKUP_EXPRs to find things
1364 like local variables, rather than creating TEMPLATE_DECLs for the
1365 local variables and then finding matching instantiations. */
1366 if (current_template_parms
1367 && (is_overloaded_fn (id)
1368 || (TREE_CODE (id) == VAR_DECL
1369 && CP_DECL_CONTEXT (id)
1370 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
1371 || TREE_CODE (id) == PARM_DECL
1372 || TREE_CODE (id) == RESULT_DECL
1373 || TREE_CODE (id) == USING_DECL))
1374 id = build_min_nt (LOOKUP_EXPR, token);
1380 do_scoped_id (token, parsing)
1385 /* during parsing, this is ::name. Otherwise, it is black magic. */
1388 id = make_node (CPLUS_BINDING);
1389 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
1392 id = BINDING_VALUE (id);
1395 id = IDENTIFIER_GLOBAL_VALUE (token);
1396 if (parsing && yychar == YYEMPTY)
1400 if (processing_template_decl)
1402 id = build_min_nt (LOOKUP_EXPR, token);
1403 LOOKUP_EXPR_GLOBAL (id) = 1;
1406 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
1407 cp_error ("`::%D' undeclared (first use here)", token);
1408 id = error_mark_node;
1409 /* Prevent repeated error messages. */
1410 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
1414 if (TREE_CODE (id) == ADDR_EXPR)
1415 mark_used (TREE_OPERAND (id, 0));
1416 else if (TREE_CODE (id) != OVERLOAD)
1419 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
1421 /* XXX CHS - should we set TREE_USED of the constant? */
1422 id = DECL_INITIAL (id);
1423 /* This is to prevent an enum whose value is 0
1424 from being considered a null pointer constant. */
1425 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
1426 TREE_CONSTANT (id) = 1;
1429 if (processing_template_decl)
1431 if (is_overloaded_fn (id))
1433 id = build_min_nt (LOOKUP_EXPR, token);
1434 LOOKUP_EXPR_GLOBAL (id) = 1;
1437 /* else just use the decl */
1439 return convert_from_reference (id);
1443 identifier_typedecl_value (node)
1447 type = IDENTIFIER_TYPE_VALUE (node);
1448 if (type == NULL_TREE)
1451 if (IDENTIFIER_BINDING (node))
1453 t = IDENTIFIER_VALUE (node);
1454 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
1457 if (IDENTIFIER_NAMESPACE_VALUE (node))
1459 t = IDENTIFIER_NAMESPACE_VALUE (node);
1460 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
1464 /* Will this one ever happen? */
1465 if (TYPE_MAIN_DECL (type))
1466 return TYPE_MAIN_DECL (type);
1468 /* We used to do an internal error of 62 here, but instead we will
1469 handle the return of a null appropriately in the callers. */
1473 #ifdef GATHER_STATISTICS
1474 /* The original for tree_node_kind is in the toplevel tree.c; changes there
1475 need to be brought into here, unless this were actually put into a header
1477 /* Statistics-gathering stuff. */
1498 extern int tree_node_counts[];
1499 extern int tree_node_sizes[];
1503 build_lang_decl (code, name, type)
1504 enum tree_code code;
1510 t = build_decl (code, name, type);
1511 retrofit_lang_decl (t);
1516 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
1517 and pushdecl (for functions generated by the backend). */
1520 retrofit_lang_decl (t)
1523 struct lang_decl *ld;
1526 if (CAN_HAVE_FULL_LANG_DECL_P (t))
1527 size = sizeof (struct lang_decl);
1529 size = sizeof (struct lang_decl_flags);
1531 ld = (struct lang_decl *) ggc_alloc_cleared (size);
1533 DECL_LANG_SPECIFIC (t) = ld;
1534 if (current_lang_name == lang_name_cplusplus)
1535 SET_DECL_LANGUAGE (t, lang_cplusplus);
1536 else if (current_lang_name == lang_name_c)
1537 SET_DECL_LANGUAGE (t, lang_c);
1538 else if (current_lang_name == lang_name_java)
1539 SET_DECL_LANGUAGE (t, lang_java);
1540 else my_friendly_abort (64);
1542 #ifdef GATHER_STATISTICS
1543 tree_node_counts[(int)lang_decl] += 1;
1544 tree_node_sizes[(int)lang_decl] += size;
1549 copy_lang_decl (node)
1553 struct lang_decl *ld;
1555 if (! DECL_LANG_SPECIFIC (node))
1558 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
1559 size = sizeof (struct lang_decl_flags);
1561 size = sizeof (struct lang_decl);
1562 ld = (struct lang_decl *) ggc_alloc (size);
1563 memcpy (ld, DECL_LANG_SPECIFIC (node), size);
1564 DECL_LANG_SPECIFIC (node) = ld;
1567 /* Copy DECL, including any language-specific parts. */
1575 copy = copy_node (decl);
1576 copy_lang_decl (copy);
1581 cp_make_lang_type (code)
1582 enum tree_code code;
1584 register tree t = make_node (code);
1586 /* Set up some flags that give proper default behavior. */
1587 if (IS_AGGR_TYPE_CODE (code))
1589 struct lang_type *pi;
1591 pi = ((struct lang_type *)
1592 ggc_alloc_cleared (sizeof (struct lang_type)));
1594 TYPE_LANG_SPECIFIC (t) = pi;
1595 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
1596 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1598 /* Make sure this is laid out, for ease of use later. In the
1599 presence of parse errors, the normal was of assuring this
1600 might not ever get executed, so we lay it out *immediately*. */
1601 build_pointer_type (t);
1603 #ifdef GATHER_STATISTICS
1604 tree_node_counts[(int)lang_type] += 1;
1605 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1609 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
1610 TYPE_ALIAS_SET is initialized to -1 by default, so we must
1612 TYPE_ALIAS_SET (t) = 0;
1614 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1615 since they can be virtual base types, and we then need a
1616 canonical binfo for them. Ideally, this would be done lazily for
1618 if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM)
1619 TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
1625 make_aggr_type (code)
1626 enum tree_code code;
1628 tree t = cp_make_lang_type (code);
1630 if (IS_AGGR_TYPE_CODE (code))
1631 SET_IS_AGGR_TYPE (t, 1);
1637 compiler_error VPARAMS ((const char *msg, ...))
1642 VA_FIXEDARG (ap, const char *, msg);
1644 vsprintf (buf, msg, ap);
1647 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
1650 /* Return the type-qualifier corresponding to the identifier given by
1654 cp_type_qual_from_rid (rid)
1657 if (rid == ridpointers[(int) RID_CONST])
1658 return TYPE_QUAL_CONST;
1659 else if (rid == ridpointers[(int) RID_VOLATILE])
1660 return TYPE_QUAL_VOLATILE;
1661 else if (rid == ridpointers[(int) RID_RESTRICT])
1662 return TYPE_QUAL_RESTRICT;
1664 my_friendly_abort (0);
1665 return TYPE_UNQUALIFIED;