OSDN Git Service

a838e4bcbbfc166fe8515e126801aa2f31108937
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / parse.h
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 Set_iota_traverse;
11 class Lex;
12 class Gogo;
13 class Named_object;
14 class Type;
15 class Typed_identifier;
16 class Typed_identifier_list;
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     Range_clause()
65       : 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   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     Type_switch()
83       : found(false), name(), location(UNKNOWN_LOCATION), expr(NULL)
84     { }
85   };
86
87   // A variable defined in an enclosing function referenced by the
88   // current function.
89   class Enclosing_var
90   {
91    public:
92     Enclosing_var(Named_object* var, Named_object* in_function,
93                   unsigned int index)
94       : var_(var), in_function_(in_function), index_(index)
95     { }
96
97     // We put these in a vector, so we need a default constructor.
98     Enclosing_var()
99       : var_(NULL), in_function_(NULL), index_(-1U)
100     { }
101
102     Named_object*
103     var() const
104     { return this->var_; }
105
106     Named_object*
107     in_function() const
108     { return this->in_function_; }
109
110     unsigned int
111     index() const
112     { return this->index_; }
113
114    private:
115     // The variable which is being referred to.
116     Named_object* var_;
117     // The function where the variable is defined.
118     Named_object* in_function_;
119     // The index of the field in this function's closure struct for
120     // this variable.
121     unsigned int index_;
122   };
123
124   // We store Enclosing_var entries in a set, so we need a comparator.
125   struct Enclosing_var_comparison
126   {
127     bool
128     operator()(const Enclosing_var&, const Enclosing_var&);
129   };
130
131   // A set of Enclosing_var entries.
132   typedef std::set<Enclosing_var, Enclosing_var_comparison> Enclosing_vars;
133
134   // Used to detect duplicate parameter/result names.
135   typedef std::map<std::string, const Typed_identifier*> Names;
136
137   // Peek at the current token from the lexer.
138   const Token*
139   peek_token();
140
141   // Consume the current token, return the next one.
142   const Token*
143   advance_token();
144
145   // Push a token back on the input stream.
146   void
147   unget_token(const Token&);
148
149   // The location of the current token.
150   Location
151   location();
152
153   // For break and continue we keep a stack of statements with
154   // associated labels (if any).  The top of the stack is used for a
155   // break or continue statement with no label.
156   typedef std::vector<std::pair<Statement*, Label*> > Bc_stack;
157
158   // Map from type switch variables to the variables they mask, so
159   // that a use of the type switch variable can become a use of the
160   // real variable.
161   typedef Unordered_map(Named_object*, Named_object*) Type_switch_vars;
162
163   // Parser nonterminals.
164   void identifier_list(Typed_identifier_list*);
165   Expression_list* expression_list(Expression*, bool may_be_sink);
166   bool qualified_ident(std::string*, Named_object**);
167   Type* type();
168   bool type_may_start_here();
169   Type* type_name(bool issue_error);
170   Type* array_type(bool may_use_ellipsis);
171   Type* map_type();
172   Type* struct_type();
173   void field_decl(Struct_field_list*);
174   Type* pointer_type();
175   Type* channel_type();
176   void check_signature_names(const Typed_identifier_list*, Names*);
177   Function_type* signature(Typed_identifier*, Location);
178   bool parameters(Typed_identifier_list**, bool* is_varargs);
179   Typed_identifier_list* parameter_list(bool* is_varargs);
180   void parameter_decl(bool, Typed_identifier_list*, bool*, bool*);
181   bool result(Typed_identifier_list**);
182   Location block();
183   Type* interface_type();
184   void method_spec(Typed_identifier_list*);
185   void declaration();
186   bool declaration_may_start_here();
187   void decl(void (Parse::*)(void*), void*);
188   void list(void (Parse::*)(void*), void*, bool);
189   void const_decl();
190   void const_spec(Type**, Expression_list**);
191   void type_decl();
192   void type_spec(void*);
193   void var_decl();
194   void var_spec(void*);
195   void init_vars(const Typed_identifier_list*, Type*, Expression_list*,
196                  bool is_coloneq, Location);
197   bool init_vars_from_call(const Typed_identifier_list*, Type*, Expression*,
198                            bool is_coloneq, Location);
199   bool init_vars_from_map(const Typed_identifier_list*, Type*, Expression*,
200                           bool is_coloneq, Location);
201   bool init_vars_from_receive(const Typed_identifier_list*, Type*,
202                               Expression*, bool is_coloneq, Location);
203   bool init_vars_from_type_guard(const Typed_identifier_list*, Type*,
204                                  Expression*, bool is_coloneq,
205                                  Location);
206   Named_object* init_var(const Typed_identifier&, Type*, Expression*,
207                          bool is_coloneq, bool type_from_init, bool* is_new);
208   Named_object* create_dummy_global(Type*, Expression*, Location);
209   void simple_var_decl_or_assignment(const std::string&, Location,
210                                      Range_clause*, Type_switch*);
211   void function_decl();
212   Typed_identifier* receiver();
213   Expression* operand(bool may_be_sink);
214   Expression* enclosing_var_reference(Named_object*, Named_object*,
215                                       Location);
216   Expression* composite_lit(Type*, int depth, Location);
217   Expression* function_lit();
218   Expression* create_closure(Named_object* function, Enclosing_vars*,
219                              Location);
220   Expression* primary_expr(bool may_be_sink, bool may_be_composite_lit,
221                            bool* is_type_switch);
222   Expression* selector(Expression*, bool* is_type_switch);
223   Expression* index(Expression*);
224   Expression* call(Expression*);
225   Expression* expression(Precedence, bool may_be_sink,
226                          bool may_be_composite_lit, bool* is_type_switch);
227   bool expression_may_start_here();
228   Expression* unary_expr(bool may_be_sink, bool may_be_composite_lit,
229                          bool* is_type_switch);
230   Expression* qualified_expr(Expression*, Location);
231   Expression* id_to_expression(const std::string&, Location);
232   void statement(Label*);
233   bool statement_may_start_here();
234   void labeled_stmt(const std::string&, Location);
235   Expression* simple_stat(bool, bool*, Range_clause*, Type_switch*);
236   bool simple_stat_may_start_here();
237   void statement_list();
238   bool statement_list_may_start_here();
239   void expression_stat(Expression*);
240   void send_stmt(Expression*);
241   void inc_dec_stat(Expression*);
242   void assignment(Expression*, Range_clause*);
243   void tuple_assignment(Expression_list*, Range_clause*);
244   void send();
245   void go_or_defer_stat();
246   void return_stat();
247   void if_stat();
248   void switch_stat(Label*);
249   Statement* expr_switch_body(Label*, Expression*, Location);
250   void expr_case_clause(Case_clauses*, bool* saw_default);
251   Expression_list* expr_switch_case(bool*);
252   Statement* type_switch_body(Label*, const Type_switch&, Location);
253   void type_case_clause(Named_object*, Type_case_clauses*, bool* saw_default);
254   void type_switch_case(std::vector<Type*>*, bool*);
255   void select_stat(Label*);
256   void comm_clause(Select_clauses*, bool* saw_default);
257   bool comm_case(bool*, Expression**, Expression**, Expression**,
258                  std::string*, std::string*, bool*);
259   bool send_or_recv_stmt(bool*, Expression**, Expression**, Expression**,
260                          std::string*, std::string*);
261   void for_stat(Label*);
262   void for_clause(Expression**, Block**);
263   void range_clause_decl(const Typed_identifier_list*, Range_clause*);
264   void range_clause_expr(const Expression_list*, Range_clause*);
265   void push_break_statement(Statement*, Label*);
266   void push_continue_statement(Statement*, Label*);
267   void pop_break_statement();
268   void pop_continue_statement();
269   Statement* find_bc_statement(const Bc_stack*, const std::string&);
270   void break_stat();
271   void continue_stat();
272   void goto_stat();
273   void package_clause();
274   void import_decl();
275   void import_spec(void*);
276
277   void reset_iota();
278   int iota_value();
279   void increment_iota();
280
281   // Skip past an error looking for a semicolon or OP.  Return true if
282   // all is well, false if we found EOF.
283   bool
284   skip_past_error(Operator op);
285
286   // Verify that an expression is not a sink, and return either the
287   // expression or an error.
288   Expression*
289   verify_not_sink(Expression*);
290
291   // Return the statement associated with a label in a Bc_stack, or
292   // NULL.
293   Statement*
294   find_bc_statement(const Bc_stack*, const std::string&) const;
295
296   // Mark a variable as used.
297   void
298   mark_var_used(Named_object*);
299
300   // The lexer output we are parsing.
301   Lex* lex_;
302   // The current token.
303   Token token_;
304   // A token pushed back on the input stream.
305   Token unget_token_;
306   // Whether unget_token_ is valid.
307   bool unget_token_valid_;
308   // Whether the function we are parsing had errors in the signature.
309   bool is_erroneous_function_;
310   // The code we are generating.
311   Gogo* gogo_;
312   // A stack of statements for which break may be used.
313   Bc_stack* break_stack_;
314   // A stack of statements for which continue may be used.
315   Bc_stack* continue_stack_;
316   // The current iota value.
317   int iota_;
318   // References from the local function to variables defined in
319   // enclosing functions.
320   Enclosing_vars enclosing_vars_;
321   // Map from type switch variables to real variables.
322   Type_switch_vars type_switch_vars_;
323 };
324
325
326 #endif // !defined(GO_PARSE_H)