|
111
|
1 /* Declarations for the parser for C and Objective-C.
|
|
131
|
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
|
|
111
|
3
|
|
|
4 Parser actions based on the old Bison parser; structure somewhat
|
|
|
5 influenced by and fragments based on the C++ parser.
|
|
|
6
|
|
|
7 This file is part of GCC.
|
|
|
8
|
|
|
9 GCC is free software; you can redistribute it and/or modify it under
|
|
|
10 the terms of the GNU General Public License as published by the Free
|
|
|
11 Software Foundation; either version 3, or (at your option) any later
|
|
|
12 version.
|
|
|
13
|
|
|
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
17 for more details.
|
|
|
18
|
|
|
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/>. */
|
|
|
22
|
|
|
23 #ifndef GCC_C_PARSER_H
|
|
|
24 #define GCC_C_PARSER_H
|
|
|
25
|
|
|
26 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
|
|
|
27 and the C parser. Unlike the C++ lexer, the parser structure
|
|
|
28 stores the lexer information instead of using a separate structure.
|
|
|
29 Identifiers are separated into ordinary identifiers, type names,
|
|
|
30 keywords and some other Objective-C types of identifiers, and some
|
|
|
31 look-ahead is maintained.
|
|
|
32
|
|
|
33 ??? It might be a good idea to lex the whole file up front (as for
|
|
|
34 C++). It would then be possible to share more of the C and C++
|
|
|
35 lexer code, if desired. */
|
|
|
36
|
|
|
37 /* More information about the type of a CPP_NAME token. */
|
|
|
38 enum c_id_kind {
|
|
|
39 /* An ordinary identifier. */
|
|
|
40 C_ID_ID,
|
|
|
41 /* An identifier declared as a typedef name. */
|
|
|
42 C_ID_TYPENAME,
|
|
|
43 /* An identifier declared as an Objective-C class name. */
|
|
|
44 C_ID_CLASSNAME,
|
|
|
45 /* An address space identifier. */
|
|
|
46 C_ID_ADDRSPACE,
|
|
|
47 /* Not an identifier. */
|
|
|
48 C_ID_NONE
|
|
|
49 };
|
|
|
50
|
|
|
51 /* A single C token after string literal concatenation and conversion
|
|
|
52 of preprocessing tokens to tokens. */
|
|
|
53 struct GTY (()) c_token {
|
|
|
54 /* The kind of token. */
|
|
|
55 ENUM_BITFIELD (cpp_ttype) type : 8;
|
|
|
56 /* If this token is a CPP_NAME, this value indicates whether also
|
|
|
57 declared as some kind of type. Otherwise, it is C_ID_NONE. */
|
|
|
58 ENUM_BITFIELD (c_id_kind) id_kind : 8;
|
|
|
59 /* If this token is a keyword, this value indicates which keyword.
|
|
|
60 Otherwise, this value is RID_MAX. */
|
|
|
61 ENUM_BITFIELD (rid) keyword : 8;
|
|
|
62 /* If this token is a CPP_PRAGMA, this indicates the pragma that
|
|
|
63 was seen. Otherwise it is PRAGMA_NONE. */
|
|
|
64 ENUM_BITFIELD (pragma_kind) pragma_kind : 8;
|
|
|
65 /* The location at which this token was found. */
|
|
|
66 location_t location;
|
|
|
67 /* The value associated with this token, if any. */
|
|
|
68 tree value;
|
|
|
69 /* Token flags. */
|
|
|
70 unsigned char flags;
|
|
|
71
|
|
|
72 source_range get_range () const
|
|
|
73 {
|
|
|
74 return get_range_from_loc (line_table, location);
|
|
|
75 }
|
|
|
76
|
|
|
77 location_t get_finish () const
|
|
|
78 {
|
|
|
79 return get_range ().m_finish;
|
|
|
80 }
|
|
|
81 };
|
|
|
82
|
|
|
83 /* The parser. */
|
|
|
84 struct c_parser;
|
|
|
85
|
|
|
86 /* Possibly kinds of declarator to parse. */
|
|
|
87 enum c_dtr_syn {
|
|
|
88 /* A normal declarator with an identifier. */
|
|
|
89 C_DTR_NORMAL,
|
|
|
90 /* An abstract declarator (maybe empty). */
|
|
|
91 C_DTR_ABSTRACT,
|
|
|
92 /* A parameter declarator: may be either, but after a type name does
|
|
|
93 not redeclare a typedef name as an identifier if it can
|
|
|
94 alternatively be interpreted as a typedef name; see DR#009,
|
|
|
95 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
|
|
|
96 following DR#249. For example, given a typedef T, "int T" and
|
|
|
97 "int *T" are valid parameter declarations redeclaring T, while
|
|
|
98 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
|
|
|
99 abstract declarators rather than involving redundant parentheses;
|
|
|
100 the same applies with attributes inside the parentheses before
|
|
|
101 "T". */
|
|
|
102 C_DTR_PARM
|
|
|
103 };
|
|
|
104
|
|
|
105 /* The binary operation precedence levels, where 0 is a dummy lowest level
|
|
|
106 used for the bottom of the stack. */
|
|
|
107 enum c_parser_prec {
|
|
|
108 PREC_NONE,
|
|
|
109 PREC_LOGOR,
|
|
|
110 PREC_LOGAND,
|
|
|
111 PREC_BITOR,
|
|
|
112 PREC_BITXOR,
|
|
|
113 PREC_BITAND,
|
|
|
114 PREC_EQ,
|
|
|
115 PREC_REL,
|
|
|
116 PREC_SHIFT,
|
|
|
117 PREC_ADD,
|
|
|
118 PREC_MULT,
|
|
|
119 NUM_PRECS
|
|
|
120 };
|
|
|
121
|
|
|
122 enum c_lookahead_kind {
|
|
|
123 /* Always treat unknown identifiers as typenames. */
|
|
|
124 cla_prefer_type,
|
|
|
125
|
|
|
126 /* Could be parsing a nonabstract declarator. Only treat an identifier
|
|
|
127 as a typename if followed by another identifier or a star. */
|
|
|
128 cla_nonabstract_decl,
|
|
|
129
|
|
|
130 /* Never treat identifiers as typenames. */
|
|
|
131 cla_prefer_id
|
|
|
132 };
|
|
|
133
|
|
|
134
|
|
|
135 extern c_token * c_parser_peek_token (c_parser *parser);
|
|
|
136 extern c_token * c_parser_peek_2nd_token (c_parser *parser);
|
|
|
137 extern c_token * c_parser_peek_nth_token (c_parser *parser, unsigned int n);
|
|
|
138 extern bool c_parser_require (c_parser *parser, enum cpp_ttype type,
|
|
|
139 const char *msgid,
|
|
|
140 location_t matching_location = UNKNOWN_LOCATION,
|
|
|
141 bool type_is_unique=true);
|
|
|
142 extern bool c_parser_error (c_parser *parser, const char *gmsgid);
|
|
|
143 extern void c_parser_consume_token (c_parser *parser);
|
|
|
144 extern void c_parser_skip_until_found (c_parser *parser, enum cpp_ttype type,
|
|
|
145 const char *msgid,
|
|
|
146 location_t = UNKNOWN_LOCATION);
|
|
|
147 extern bool c_parser_next_token_starts_declspecs (c_parser *parser);
|
|
|
148 bool c_parser_next_tokens_start_declaration (c_parser *parser);
|
|
|
149 bool c_token_starts_typename (c_token *token);
|
|
|
150
|
|
|
151 /* Abstraction to avoid defining c_parser here which messes up gengtype
|
|
|
152 output wrt ObjC due to vec<c_token> routines being put in gtype-c.h
|
|
|
153 but not gtype-objc.h. */
|
|
|
154 extern c_token * c_parser_tokens_buf (c_parser *parser, unsigned n);
|
|
|
155 extern bool c_parser_error (c_parser *parser);
|
|
|
156 extern void c_parser_set_error (c_parser *parser, bool);
|
|
|
157
|
|
131
|
158 /* A bit of a hack to have this here. It would be better in a c-decl.h. */
|
|
|
159 extern bool old_style_parameter_scope (void);
|
|
|
160
|
|
111
|
161 /* Return true if the next token from PARSER has the indicated
|
|
|
162 TYPE. */
|
|
|
163
|
|
|
164 static inline bool
|
|
|
165 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
|
|
|
166 {
|
|
|
167 return c_parser_peek_token (parser)->type == type;
|
|
|
168 }
|
|
|
169
|
|
|
170 /* Return true if the next token from PARSER does not have the
|
|
|
171 indicated TYPE. */
|
|
|
172
|
|
|
173 static inline bool
|
|
|
174 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
|
|
|
175 {
|
|
|
176 return !c_parser_next_token_is (parser, type);
|
|
|
177 }
|
|
|
178
|
|
|
179 /* Return true if the next token from PARSER is the indicated
|
|
|
180 KEYWORD. */
|
|
|
181
|
|
|
182 static inline bool
|
|
|
183 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
|
|
|
184 {
|
|
|
185 return c_parser_peek_token (parser)->keyword == keyword;
|
|
|
186 }
|
|
|
187
|
|
|
188 extern struct c_declarator *
|
|
|
189 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
|
|
|
190 bool *seen_id);
|
|
|
191 extern void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
|
|
|
192 bool, bool, bool, enum c_lookahead_kind);
|
|
131
|
193 extern struct c_type_name *c_parser_type_name (c_parser *, bool = false);
|
|
111
|
194
|
|
|
195 #endif
|
