1 // parse.h -- Go frontend parser. -*- C++ -*-
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.
10 class Set_iota_traverse;
15 class Typed_identifier;
16 class Typed_identifier_list;
20 class Expression_list;
21 class Struct_field_list;
23 class Type_case_clauses;
43 PRECEDENCE_INVALID = -1,
44 PRECEDENCE_NORMAL = 0,
53 // We use this when parsing the range clause of a for statement.
56 // Set to true if we found a range clause.
58 // The index expression.
60 // The value expression.
62 // The range expression.
66 : found(false), index(NULL), value(NULL), range(NULL)
70 // We use this when parsing the statement at the start of a switch,
71 // in order to recognize type switches.
74 // Set to true if we find a type switch.
78 // The location of the variable.
79 source_location location;
84 : found(false), name(), location(UNKNOWN_LOCATION), expr(NULL)
88 // A variable defined in an enclosing function referenced by the
93 Enclosing_var(Named_object* var, Named_object* in_function,
95 : var_(var), in_function_(in_function), index_(index)
98 // We put these in a vector, so we need a default constructor.
100 : var_(NULL), in_function_(NULL), index_(-1U)
105 { return this->var_; }
109 { return this->in_function_; }
113 { return this->index_; }
116 // The variable which is being referred to.
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
125 // We store Enclosing_var entries in a set, so we need a comparator.
126 struct Enclosing_var_comparison
129 operator()(const Enclosing_var&, const Enclosing_var&);
132 // A set of Enclosing_var entries.
133 typedef std::set<Enclosing_var, Enclosing_var_comparison> Enclosing_vars;
135 // Peek at the current token from the lexer.
139 // Consume the current token, return the next one.
143 // Push a token back on the input stream.
145 unget_token(const Token&);
147 // The location of the current token.
151 // For break and continue we keep a stack of statements with
152 // associated labels (if any). The top of the stack is used for a
153 // break or continue statement with no label.
154 typedef std::vector<std::pair<Statement*, const Label*> > Bc_stack;
156 // Parser nonterminals.
157 void identifier_list(Typed_identifier_list*);
158 Expression_list* expression_list(Expression*, bool may_be_sink);
159 bool qualified_ident(std::string*, Named_object**);
161 bool type_may_start_here();
162 Type* type_name(bool issue_error);
163 Type* array_type(bool may_use_ellipsis);
166 void field_decl(Struct_field_list*);
167 Type* pointer_type();
168 Type* channel_type();
169 Function_type* signature(Typed_identifier*, source_location);
170 Typed_identifier_list* parameters(bool* is_varargs);
171 Typed_identifier_list* parameter_list(bool* is_varargs);
172 void parameter_decl(bool, Typed_identifier_list*, bool*, bool*);
173 Typed_identifier_list* result();
174 source_location block();
175 Type* interface_type();
176 bool method_spec(Typed_identifier_list*);
178 bool declaration_may_start_here();
179 void decl(void (Parse::*)(void*), void*);
180 void list(void (Parse::*)(void*), void*, bool);
182 void const_spec(Type**, Expression_list**);
184 void type_spec(void*);
186 void var_spec(void*);
187 void init_vars(const Typed_identifier_list*, Type*, Expression_list*,
188 bool is_coloneq, source_location);
189 bool init_vars_from_call(const Typed_identifier_list*, Type*, Expression*,
190 bool is_coloneq, source_location);
191 bool init_vars_from_map(const Typed_identifier_list*, Type*, Expression*,
192 bool is_coloneq, source_location);
193 bool init_vars_from_receive(const Typed_identifier_list*, Type*,
194 Expression*, bool is_coloneq, source_location);
195 bool init_vars_from_type_guard(const Typed_identifier_list*, Type*,
196 Expression*, bool is_coloneq,
198 Named_object* init_var(const Typed_identifier&, Type*, Expression*,
199 bool is_coloneq, bool type_from_init, bool* is_new);
200 void simple_var_decl_or_assignment(const std::string&, source_location,
201 Range_clause*, Type_switch*);
202 void function_decl();
203 Typed_identifier* receiver();
204 Expression* operand(bool may_be_sink);
205 Expression* enclosing_var_reference(Named_object*, Named_object*,
207 Expression* composite_lit(Type*, int depth, source_location);
208 Expression* function_lit();
209 Expression* create_closure(Named_object* function, Enclosing_vars*,
211 Expression* primary_expr(bool may_be_sink, bool may_be_composite_lit,
212 bool* is_type_switch);
213 Expression* selector(Expression*, bool* is_type_switch);
214 Expression* index(Expression*);
215 Expression* call(Expression*);
216 Expression* expression(Precedence, bool may_be_sink,
217 bool may_be_composite_lit, bool* is_type_switch);
218 bool expression_may_start_here();
219 Expression* unary_expr(bool may_be_sink, bool may_be_composite_lit,
220 bool* is_type_switch);
221 Expression* qualified_expr(Expression*, source_location);
222 Expression* id_to_expression(const std::string&, source_location);
223 void statement(const Label*);
224 bool statement_may_start_here();
225 void labeled_stmt(const std::string&, source_location);
226 Expression* simple_stat(bool, bool, Range_clause*, Type_switch*);
227 bool simple_stat_may_start_here();
228 void statement_list();
229 bool statement_list_may_start_here();
230 void expression_stat(Expression*);
231 void inc_dec_stat(Expression*);
232 void assignment(Expression*, Range_clause*);
233 void tuple_assignment(Expression_list*, Range_clause*);
235 void go_or_defer_stat();
238 void switch_stat(const Label*);
239 Statement* expr_switch_body(const Label*, Expression*, source_location);
240 void expr_case_clause(Case_clauses*);
241 Expression_list* expr_switch_case(bool*);
242 Statement* type_switch_body(const Label*, const Type_switch&,
244 void type_case_clause(Named_object*, Type_case_clauses*);
245 void type_switch_case(std::vector<Type*>*, bool*);
246 void select_stat(const Label*);
247 void comm_clause(Select_clauses*);
248 bool comm_case(bool*, Expression**, Expression**, std::string*, bool*);
249 bool send_or_recv_expr(bool*, Expression**, Expression**, std::string*);
250 void for_stat(const Label*);
251 void for_clause(Expression**, Block**);
252 void range_clause_decl(const Typed_identifier_list*, Range_clause*);
253 void range_clause_expr(const Expression_list*, Range_clause*);
254 void push_break_statement(Statement*, const Label*);
255 void push_continue_statement(Statement*, const Label*);
256 void pop_break_statement();
257 void pop_continue_statement();
258 Statement* find_bc_statement(const Bc_stack*, const std::string&);
260 void continue_stat();
262 void package_clause();
264 void import_spec(void*);
268 void increment_iota();
270 // Skip past an error looking for a semicolon or OP. Return true if
271 // all is well, false if we found EOF.
273 skip_past_error(Operator op);
275 // Verify that an expression is not a sink, and return either the
276 // expression or an error.
278 verify_not_sink(Expression*);
280 // Return the statement associated with a label in a Bc_stack, or
283 find_bc_statement(const Bc_stack*, const std::string&) const;
285 // The lexer output we are parsing.
287 // The current token.
289 // A token pushed back on the input stream.
291 // Whether unget_token_ is valid.
292 bool unget_token_valid_;
293 // The code we are generating.
295 // A stack of statements for which break may be used.
296 Bc_stack break_stack_;
297 // A stack of statements for which continue may be used.
298 Bc_stack continue_stack_;
299 // The current iota value.
301 // References from the local function to variables defined in
302 // enclosing functions.
303 Enclosing_vars enclosing_vars_;
307 #endif // !defined(GO_PARSE_H)