Branch data Line data Source code
1 : : // parse.h -- Go frontend parser. -*- C++ -*-
2 : :
3 : : // Copyright 2009 The Go Authors. All rights reserved.
4 : : // Use of this source code is governed by a BSD-style
5 : : // license that can be found in the LICENSE file.
6 : :
7 : : #ifndef GO_PARSE_H
8 : : #define GO_PARSE_H
9 : :
10 : : class Lex;
11 : : class Gogo;
12 : : class Named_object;
13 : : class Type;
14 : : class Typed_identifier;
15 : : class Typed_identifier_list;
16 : : class Channel_type;
17 : : class Function_type;
18 : : class Block;
19 : : class Expression;
20 : : class Expression_list;
21 : : class Struct_field_list;
22 : : class Case_clauses;
23 : : class Type_case_clauses;
24 : : class Select_clauses;
25 : : class Statement;
26 : : class Label;
27 : :
28 : : // Parse the program.
29 : :
30 : : class Parse
31 : : {
32 : : public:
33 : : Parse(Lex*, Gogo*);
34 : :
35 : : // Parse a program.
36 : : void
37 : : program();
38 : :
39 : : private:
40 : : // Precedence values.
41 : : enum Precedence
42 : : {
43 : : PRECEDENCE_INVALID = -1,
44 : : PRECEDENCE_NORMAL = 0,
45 : : PRECEDENCE_OROR,
46 : : PRECEDENCE_ANDAND,
47 : : PRECEDENCE_RELOP,
48 : : PRECEDENCE_ADDOP,
49 : : PRECEDENCE_MULOP
50 : : };
51 : :
52 : : // We use this when parsing the range clause of a for statement.
53 : : struct Range_clause
54 : : {
55 : : // Set to true if we found a range clause.
56 : : bool found;
57 : : // The index expression.
58 : : Expression* index;
59 : : // The value expression.
60 : : Expression* value;
61 : : // The range expression.
62 : : Expression* range;
63 : :
64 : 53818 : Range_clause()
65 : 53818 : : found(false), index(NULL), value(NULL), range(NULL)
66 : : { }
67 : : };
68 : :
69 : : // We use this when parsing the statement at the start of a switch,
70 : : // in order to recognize type switches.
71 : 13579 : struct Type_switch
72 : : {
73 : : // Set to true if we find a type switch.
74 : : bool found;
75 : : // The variable name.
76 : : std::string name;
77 : : // The location of the variable.
78 : : Location location;
79 : : // The expression.
80 : : Expression* expr;
81 : :
82 : 13579 : Type_switch()
83 : 13579 : : found(false), name(), location(Linemap::unknown_location()),
84 : 13579 : expr(NULL)
85 : : { }
86 : : };
87 : :
88 : : // A variable defined in an enclosing function referenced by the
89 : : // current function.
90 : : class Enclosing_var
91 : : {
92 : : public:
93 : 43136 : Enclosing_var(Named_object* var, Named_object* in_function,
94 : : unsigned int index)
95 : 43136 : : var_(var), in_function_(in_function), index_(index)
96 : : { }
97 : :
98 : : // We put these in a vector, so we need a default constructor.
99 : 25477 : Enclosing_var()
100 : 25477 : : var_(NULL), in_function_(NULL), index_(-1U)
101 : : { }
102 : :
103 : : Named_object*
104 : 111417 : var() const
105 : 111417 : { return this->var_; }
106 : :
107 : : Named_object*
108 : 25477 : in_function() const
109 : 25477 : { return this->in_function_; }
110 : :
111 : : unsigned int
112 : 94090 : index() const
113 : 94090 : { return this->index_; }
114 : :
115 : : private:
116 : : // The variable which is being referred to.
117 : : Named_object* var_;
118 : : // The function where the variable is defined.
119 : : Named_object* in_function_;
120 : : // The index of the field in this function's closure struct for
121 : : // this variable.
122 : : unsigned int index_;
123 : : };
124 : :
125 : : // We store Enclosing_var entries in a set, so we need a comparator.
126 : : struct Enclosing_var_comparison
127 : : {
128 : : bool
129 : : operator()(const Enclosing_var&, const Enclosing_var&) const;
130 : : };
131 : :
132 : : // A set of Enclosing_var entries.
133 : : typedef std::set<Enclosing_var, Enclosing_var_comparison> Enclosing_vars;
134 : :
135 : : // Used to detect duplicate parameter/result names.
136 : : typedef std::map<std::string, const Typed_identifier*> Names;
137 : :
138 : : // Peek at the current token from the lexer.
139 : : const Token*
140 : : peek_token();
141 : :
142 : : // Consume the current token, return the next one.
143 : : const Token*
144 : : advance_token();
145 : :
146 : : // Push a token back on the input stream.
147 : : void
148 : : unget_token(const Token&);
149 : :
150 : : // The location of the current token.
151 : : Location
152 : : location();
153 : :
154 : : // For break and continue we keep a stack of statements with
155 : : // associated labels (if any). The top of the stack is used for a
156 : : // break or continue statement with no label.
157 : : typedef std::vector<std::pair<Statement*, Label*> > Bc_stack;
158 : :
159 : : // Parser nonterminals.
160 : : void identifier_list(Typed_identifier_list*);
161 : : Expression_list* expression_list(Expression*, bool may_be_sink,
162 : : bool may_be_composite_lit);
163 : : bool qualified_ident(std::string*, Named_object**);
164 : : Type* type();
165 : : bool type_may_start_here();
166 : : Type* type_name(bool issue_error);
167 : : Type* array_type(bool may_use_ellipsis);
168 : : Type* map_type();
169 : : Type* struct_type();
170 : : void field_decl(Struct_field_list*);
171 : : Type* pointer_type();
172 : : Type* channel_type();
173 : : void check_signature_names(const Typed_identifier_list*, Names*);
174 : : Function_type* signature(Typed_identifier*, Location);
175 : : bool parameters(Typed_identifier_list**, bool* is_varargs);
176 : : Typed_identifier_list* parameter_list(bool* is_varargs);
177 : : void parameter_decl(bool, Typed_identifier_list*, bool*, bool*, bool*);
178 : : bool result(Typed_identifier_list**);
179 : : Location block();
180 : : Type* interface_type(bool record);
181 : : void method_spec(Typed_identifier_list*);
182 : : void declaration();
183 : : bool declaration_may_start_here();
184 : : void decl(void (Parse::*)());
185 : : void list(void (Parse::*)(), bool);
186 : : void const_decl();
187 : : void const_spec(int, Type**, Expression_list**);
188 : : void update_references(Expression**);
189 : : void type_decl();
190 : : void type_spec();
191 : : void var_decl();
192 : : void var_spec();
193 : : void init_vars(const Typed_identifier_list*, Type*, Expression_list*,
194 : : bool is_coloneq, std::vector<std::string>*, Location);
195 : : bool init_vars_from_call(const Typed_identifier_list*, Type*, Expression*,
196 : : bool is_coloneq, Location);
197 : : bool init_vars_from_map(const Typed_identifier_list*, Type*, Expression*,
198 : : bool is_coloneq, Location);
199 : : bool init_vars_from_receive(const Typed_identifier_list*, Type*,
200 : : Expression*, bool is_coloneq, Location);
201 : : bool init_vars_from_type_guard(const Typed_identifier_list*, Type*,
202 : : Expression*, bool is_coloneq,
203 : : Location);
204 : : Named_object* init_var(const Typed_identifier&, Type*, Expression*,
205 : : bool is_coloneq, bool type_from_init, bool* is_new,
206 : : Expression_list* vars, Expression_list* vals);
207 : : Named_object* create_dummy_global(Type*, Expression*, Location);
208 : : void finish_init_vars(Expression_list* vars, Expression_list* vals,
209 : : Location);
210 : : void simple_var_decl_or_assignment(const std::string&, Location,
211 : : bool may_be_composite_lit,
212 : : Range_clause*, Type_switch*);
213 : : void function_decl();
214 : : Typed_identifier* receiver();
215 : : Expression* operand(bool may_be_sink, bool *is_parenthesized);
216 : : Expression* enclosing_var_reference(Named_object*, Named_object*,
217 : : bool may_be_sink, Location);
218 : : Expression* composite_lit(Type*, int depth, Location);
219 : : Expression* function_lit();
220 : : Expression* create_closure(Named_object* function, Enclosing_vars*,
221 : : Location);
222 : : Expression* primary_expr(bool may_be_sink, bool may_be_composite_lit,
223 : : bool* is_type_switch, bool* is_parenthesized);
224 : : Expression* selector(Expression*, bool* is_type_switch);
225 : : Expression* index(Expression*);
226 : : Expression* call(Expression*);
227 : : Expression* expression(Precedence, bool may_be_sink,
228 : : bool may_be_composite_lit, bool* is_type_switch,
229 : : bool *is_parenthesized);
230 : : bool expression_may_start_here();
231 : : Expression* unary_expr(bool may_be_sink, bool may_be_composite_lit,
232 : : bool* is_type_switch, bool* is_parenthesized);
233 : : Type* reassociate_chan_direction(Channel_type*, Location);
234 : : Expression* qualified_expr(Expression*, Location);
235 : : Expression* id_to_expression(const std::string&, Location, bool, bool);
236 : : void statement(Label*);
237 : : bool statement_may_start_here();
238 : : void labeled_stmt(const std::string&, Location);
239 : : Expression* simple_stat(bool, bool*, Range_clause*, Type_switch*);
240 : : bool simple_stat_may_start_here();
241 : : void statement_list();
242 : : bool statement_list_may_start_here();
243 : : void expression_stat(Expression*);
244 : : void send_stmt(Expression*, bool may_be_composite_lit);
245 : : void inc_dec_stat(Expression*);
246 : : void assignment(Expression*, bool may_be_composite_lit, Range_clause*);
247 : : void tuple_assignment(Expression_list*, bool may_be_composite_lit,
248 : : Range_clause*);
249 : : void send();
250 : : void go_or_defer_stat();
251 : : void return_stat();
252 : : void if_stat();
253 : : void switch_stat(Label*);
254 : : Statement* expr_switch_body(Label*, Expression*, Location);
255 : : void expr_case_clause(Case_clauses*, bool* saw_default);
256 : : Expression_list* expr_switch_case(bool*);
257 : : Statement* type_switch_body(Label*, const Type_switch&, Location);
258 : : void type_case_clause(const std::string&, Expression*, Type_case_clauses*,
259 : : bool* saw_default, std::vector<Named_object*>*);
260 : : void type_switch_case(std::vector<Type*>*, bool*);
261 : : void select_stat(Label*);
262 : : void comm_clause(Select_clauses*, bool* saw_default);
263 : : bool comm_case(bool*, Expression**, Expression**, Expression**,
264 : : std::string*, std::string*, bool*);
265 : : bool send_or_recv_stmt(bool*, Expression**, Expression**, Expression**,
266 : : std::string*, std::string*);
267 : : void for_stat(Label*);
268 : : void for_clause(Expression**, Block**);
269 : : void range_clause_decl(const Typed_identifier_list*, Range_clause*);
270 : : void range_clause_expr(const Expression_list*, Range_clause*);
271 : : void push_break_statement(Statement*, Label*);
272 : : void push_continue_statement(Statement*, Label*);
273 : : void pop_break_statement();
274 : : void pop_continue_statement();
275 : : Statement* find_bc_statement(const Bc_stack*, const std::string&);
276 : : void break_stat();
277 : : void continue_stat();
278 : : void goto_stat();
279 : : void package_clause();
280 : : void import_decl();
281 : : void import_spec();
282 : :
283 : : // Check for unused compiler directives.
284 : : void check_directives();
285 : :
286 : : // Skip past an error looking for a semicolon or OP. Return true if
287 : : // all is well, false if we found EOF.
288 : : bool
289 : : skip_past_error(Operator op);
290 : :
291 : : // Verify that an expression is not a sink, and return either the
292 : : // expression or an error.
293 : : Expression*
294 : : verify_not_sink(Expression*);
295 : :
296 : : // Return the statement associated with a label in a Bc_stack, or
297 : : // NULL.
298 : : Statement*
299 : : find_bc_statement(const Bc_stack*, const std::string&) const;
300 : :
301 : : // Mark a variable as used.
302 : : void
303 : : mark_var_used(Named_object*);
304 : :
305 : : // The lexer output we are parsing.
306 : : Lex* lex_;
307 : : // The current token.
308 : : Token token_;
309 : : // A token pushed back on the input stream.
310 : : Token unget_token_;
311 : : // Whether unget_token_ is valid.
312 : : bool unget_token_valid_;
313 : : // Whether the function we are parsing had errors in the signature.
314 : : bool is_erroneous_function_;
315 : : // The code we are generating.
316 : : Gogo* gogo_;
317 : : // A stack of statements for which break may be used.
318 : : Bc_stack* break_stack_;
319 : : // A stack of statements for which continue may be used.
320 : : Bc_stack* continue_stack_;
321 : : // References from the local function to variables defined in
322 : : // enclosing functions.
323 : : Enclosing_vars enclosing_vars_;
324 : : };
325 : :
326 : :
327 : : #endif // !defined(GO_PARSE_H)
|
