github.com/ronhuafeng/gofrontend@v0.0.0-20220715151246-ff23266b8bc5/go/parse.h (about)

     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      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(Linemap::unknown_location()),
    84            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      Enclosing_var(Named_object* var, Named_object* in_function,
    94  		  unsigned int index)
    95        : var_(var), in_function_(in_function), index_(index)
    96      { }
    97  
    98      // We put these in a vector, so we need a default constructor.
    99      Enclosing_var()
   100        : var_(NULL), in_function_(NULL), index_(-1U)
   101      { }
   102  
   103      Named_object*
   104      var() const
   105      { return this->var_; }
   106  
   107      Named_object*
   108      in_function() const
   109      { return this->in_function_; }
   110  
   111      unsigned int
   112      index() const
   113      { 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)