✨ update new parser

ast/nasal_new_ast.h

@@ -58,6 +58,7 @@ enum class expr_type:u32 {
 class ast_visitor;
 class hash_pair;
 class parameter;
+class slice_vector;
 class multi_define;
 class code_block;
 class if_expr;
@@ -75,6 +76,10 @@ public:
     expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
+    void set_begin(u32 line, u32 column) {
+        nd_loc.begin_line = line;
+        nd_loc.begin_column = column;
+    }
     const span& get_location() const {return nd_loc;}
     expr_type get_type() const {return nd_type;}
     void update_location(const span& location) {
@@ -233,6 +238,10 @@ public:
     parameter(const span& location):
         expr(location, expr_type::ast_param),
         name(nullptr), default_value(nullptr) {}
+    ~parameter();
+    void set_parameter_type(param_type pt) {type = pt;}
+    void set_parameter_name(identifier* node) {name = node;}
+    void set_default_value(expr* node) {default_value = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -246,6 +255,7 @@ public:
     ternary_operator(const span& location):
         expr(location, expr_type::ast_ternary),
         condition(nullptr), left(nullptr), right(nullptr) {}
+    ~ternary_operator();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -277,6 +287,10 @@ public:
     binary_operator(const span& location):
         expr(location, expr_type::ast_binary),
         left(nullptr), right(nullptr) {}
+    ~binary_operator();
+    void set_type(binary_type operator_type) {type = operator_type;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -296,6 +310,9 @@ public:
     unary_operator(const span& location):
         expr(location, expr_type::ast_unary),
         value(nullptr) {}
+    ~unary_operator();
+    void set_type(unary_type operator_type) {type = operator_type;}
+    void set_value(expr* node) {value = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -304,26 +321,36 @@ private:
     std::string field;
 
 public:
-    call_hash(const span& location):
+    call_hash(const span& location, const std::string& name):
         expr(location, expr_type::ast_callh),
-        field("") {}
+        field(name) {}
+    ~call_hash();
     virtual void accept(ast_visitor*) override;
 };
 
 class call_vector:public expr {
 private:
-    std::vector<expr*> calls;
+    std::vector<slice_vector*> calls;
 
 public:
     call_vector(const span& location):
         expr(location, expr_type::ast_callv) {}
+    ~call_vector();
+    void add_slice(slice_vector* node) {calls.push_back(node);}
+    std::vector<slice_vector*>& get_slices() {return calls;}
     virtual void accept(ast_visitor*) override;
 };
 
 class call_function:public expr {
+private:
+    std::vector<expr*> args;
+
 public:
     call_function(const span& location):
         expr(location, expr_type::ast_callf) {}
+    ~call_function();
+    void add_argument(expr* node) {args.push_back(node);}
+    std::vector<expr*>& get_argument() {return args;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -336,6 +363,9 @@ public:
     slice_vector(const span& location):
         expr(location, expr_type::ast_subvec),
         begin(nullptr), end(nullptr) {}
+    ~slice_vector();
+    void set_begin(expr* node) {begin = node;}
+    void set_end(expr* node) {end = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -349,6 +379,7 @@ public:
     definition(const span& location):
         expr(location, expr_type::ast_def),
         variable(nullptr), variables(nullptr), value(nullptr) {}
+    ~definition();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -359,6 +390,7 @@ private:
 public:
     multi_define(const span& location):
         expr(location, expr_type::ast_multi_id) {}
+    ~multi_define();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -371,6 +403,7 @@ public:
     while_expr(const span& location):
         expr(location, expr_type::ast_while),
         condition(nullptr), block(nullptr) {}
+    ~while_expr();
     void set_condition(expr* node) {condition = node;}
     void set_code_block (code_block* node) {block = node;}
     expr* get_condition() {return condition;}
@@ -390,6 +423,7 @@ public:
         expr(location, expr_type::ast_for),
         initializing(nullptr), condition(nullptr),
         step(nullptr), block(nullptr) {}
+    ~for_expr();
     void set_initial(expr* node) {initializing = node;}
     void set_condition(expr* node) {condition = node;}
     void set_step(expr* node) {step = node;}
@@ -432,11 +466,12 @@ private:
     code_block* block;
 
 public:
-    forei_expr(const span& location, forei_loop_type loop_type):
+    forei_expr(const span& location):
         expr(location, expr_type::ast_forei),
-        type(loop_type), iterator(nullptr),
+        type(forei_loop_type::foreach), iterator(nullptr),
         vector_node(nullptr), block(nullptr) {}
     ~forei_expr();
+    void set_type(forei_loop_type ft) {type = ft;}
     void set_iterator(iter_expr* node) {iterator = node;}
     void set_value(expr* node) {vector_node = node;}
     void set_code_block(code_block* node) {block = node;}
@@ -475,6 +510,7 @@ public:
     if_expr(const span& location):
         expr(location, expr_type::ast_if),
         condition(nullptr), block(nullptr) {}
+    ~if_expr();
     void set_condition(expr* node) {condition = node;}
     void set_code_block(code_block* node) {block = node;}
     expr* get_condition() {return condition;}

ast/nasal_new_parse.cpp

@@ -8,15 +8,15 @@ const error& parse::compile(const lexer& lexer) {
     root = new code_block(toks[0].loc);
 
     while(!lookahead(tok::eof)) {
-        root->add_expression(expr());
+        root->add_expression(expression());
         if (lookahead(tok::semi)) {
             match(tok::semi);
-        } else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
+        } else if (need_semi_check(root->get_expressions().back()) && !lookahead(tok::eof)) {
             // the last expression can be recognized without semi
             die(prevspan, "expected \";\"");
         }
     }
-    root.update_span();
+    update_location(root);
     return err;
 }
 
@@ -228,7 +228,7 @@ vector_expr* parse::vec() {
     auto node = new vector_expr(toks[ptr].loc);
     match(tok::lbracket);
     while(!lookahead(tok::rbracket)) {
-        node.add(calc());
+        node->add_element(calc());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::eof)) {
@@ -284,7 +284,7 @@ function* parse::func() {
     if (lookahead(tok::lcurve)) {
         params(node);
     }
-    node->set_code_block(exprs());
+    node->set_code_block(expression_block());
     --in_func;
     update_location(node);
     return node;
@@ -293,23 +293,23 @@ function* parse::func() {
 void parse::params(function* func_node) {
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
-        auto tmp = id();
+        auto param = new parameter(toks[ptr].loc);
+        param->set_parameter_name(id());
         if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
             ast special_arg(toks[ptr].loc, ast_null);
             if (lookahead(tok::eq)) {
                 match(tok::eq);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_default);
-                special_arg.add(calc());
+                param->set_parameter_type(parameter::param_type::default_parameter);
+                param->set_default_value(calc());
             } else {
                 match(tok::ellipsis);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_dynamic);
+                param->set_parameter_type(parameter::param_type::dynamic_parameter);
             }
-            node.add(std::move(special_arg));
         } else {
-            node.add(std::move(tmp));
+            param->set_parameter_type(parameter::param_type::normal_parameter);
         }
+        update_location(param);
+        func_node->add_parameter(param);
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::id)) { // first set of identifier
@@ -318,9 +318,9 @@ void parse::params(function* func_node) {
             break;
         }
     }
-    update_location(node);
+    update_location(func_node);
     match(tok::rcurve, "expected ')' after parameter list");
-    return node;
+    return;
 }
 
 expr* parse::lcurve_expr() {
@@ -383,7 +383,7 @@ code_block* parse::expression_block() {
             node->add_expression(expression());
             if (lookahead(tok::semi)) {
                 match(tok::semi);
-            } else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
+            } else if (need_semi_check(node->get_expressions().back()) && !lookahead(tok::rbrace)) {
                 // the last expression can be recognized without semi
                 die(prevspan, "expected ';'");
             }
@@ -400,7 +400,7 @@ code_block* parse::expression_block() {
 }
 
 expr* parse::calc() {
-    ast node=bitwise_or();
+    auto node = bitwise_or();
     if (lookahead(tok::quesmark)) {
         // trinocular calculation
         ast tmp(toks[ptr].loc, ast_trino);
@@ -428,7 +428,7 @@ expr* parse::calc() {
     return node;
 }
 
-expr* parse::bitwise_or() {
+binary_operator* parse::bitwise_or() {
     ast node=bitwise_xor();
     while(lookahead(tok::btor)) {
         ast tmp(toks[ptr].loc, ast_bitor);
@@ -442,7 +442,7 @@ expr* parse::bitwise_or() {
     return node;
 }
 
-expr* parse::bitwise_xor() {
+binary_operator* parse::bitwise_xor() {
     ast node=bitwise_and();
     while(lookahead(tok::btxor)) {
         ast tmp(toks[ptr].loc, ast_bitxor);
@@ -456,7 +456,7 @@ expr* parse::bitwise_xor() {
     return node;
 }
 
-expr* parse::bitwise_and() {
+binary_operator* parse::bitwise_and() {
     ast node=or_expr();
     while(lookahead(tok::btand)) {
         ast tmp(toks[ptr].loc, ast_bitand);
@@ -470,7 +470,7 @@ expr* parse::bitwise_and() {
     return node;
 }
 
-expr* parse::or_expr() {
+binary_operator* parse::or_expr() {
     ast node=and_expr();
     while(lookahead(tok::opor)) {
         ast tmp(toks[ptr].loc, ast_or);
@@ -484,7 +484,7 @@ expr* parse::or_expr() {
     return node;
 }
 
-expr* parse::and_expr() {
+binary_operator* parse::and_expr() {
     ast node=cmp_expr();
     while(lookahead(tok::opand)) {
         ast tmp(toks[ptr].loc, ast_and);
@@ -498,7 +498,7 @@ expr* parse::and_expr() {
     return node;
 }
 
-expr* parse::cmp_expr() {
+binary_operator* parse::cmp_expr() {
     ast node=additive_expr();
     while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
         // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
@@ -513,7 +513,7 @@ expr* parse::cmp_expr() {
     return node;
 }
 
-expr* parse::additive_expr() {
+binary_operator* parse::additive_expr() {
     ast node=multive_expr();
     while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
         ast tmp(toks[ptr].loc, ast_null);
@@ -534,34 +534,48 @@ expr* parse::additive_expr() {
 }
 
 expr* parse::multive_expr() {
-    ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
+    expr* node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
     while(lookahead(tok::mult) || lookahead(tok::div)) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        if (lookahead(tok::mult)) {
+            tmp->set_type(binary_operator::binary_type::mult);
+        } else {
+            tmp->set_type(binary_operator::binary_type::div);
+        }
+        tmp->set_left(node);
         match(toks[ptr].type);
-        tmp.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-expr* parse::unary() {
-    ast node(toks[ptr].loc,ast_null);
+unary_operator* parse::unary() {
+    auto node = new unary_operator(toks[ptr].loc);
     switch(toks[ptr].type) {
-        case tok::sub:     node.set_type(ast_neg);match(tok::sub);break;
-        case tok::opnot:   node.set_type(ast_lnot);match(tok::opnot);break;
-        case tok::floater: node.set_type(ast_bnot);match(tok::floater);break;
+        case tok::sub:
+            node->set_type(unary_operator::unary_type::negative);
+            match(tok::sub);
+            break;
+        case tok::opnot:
+            node->set_type(unary_operator::unary_type::logical_not);
+            match(tok::opnot);
+            break;
+        case tok::floater:
+            node->set_type(unary_operator::unary_type::bitwise_not);
+            match(tok::floater);
+            break;
         default: break;
     }
-    node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
+    node->set_value((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
     update_location(node);
     return node;
 }
 
 expr* parse::scalar() {
-    ast node(toks[ptr].loc, ast_null);
+    expr* node = nullptr;
     if (lookahead(tok::tknil)) {
         node=nil();
         match(tok::tknil);
@@ -583,7 +597,7 @@ expr* parse::scalar() {
         const auto& loc=toks[ptr].loc;
         match(tok::lcurve);
         node=calc();
-        node.set_begin(loc.begin_line, loc.begin_column);
+        node->set_begin(loc.begin_line, loc.begin_column);
         update_location(node);
         match(tok::rcurve);
     } else if (lookahead(tok::var)) {
@@ -617,19 +631,19 @@ expr* parse::call_scalar() {
         default: break;
     }
     // unreachable
-    return {toks[ptr].loc, ast_nil};
+    return null();
 }
 
-expr* parse::callh() {
-    ast node(toks[ptr].loc, ast_callh);
+call_hash* parse::callh() {
+    const auto& begin_loc = toks[ptr].loc;
     match(tok::dot);
-    node.set_str(toks[ptr].str);
-    node.set_end(toks[ptr].loc.end_line, toks[ptr].loc.end_column);
+    auto node = new call_hash(begin_loc, toks[ptr].str);
+    update_location(node);
     match(tok::id, "expected hashmap key"); // get key
     return node;
 }
 
-expr* parse::callv() {
+call_vector* parse::callv() {
     // panic set for this token is not ','
     // this is the FIRST set of subvec
     // array end with tok::null=0
@@ -639,10 +653,10 @@ expr* parse::callv() {
         tok::func,tok::var,tok::lcurve,tok::floater,
         tok::lbrace,tok::lbracket,tok::colon,tok::null
     };
-    ast node(toks[ptr].loc, ast_callv);
+    auto node = new call_vector(toks[ptr].loc);
     match(tok::lbracket);
     while(!lookahead(tok::rbracket)) {
-        node.add(subvec());
+        node->add_slice(subvec());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::eof)) {
@@ -651,7 +665,7 @@ expr* parse::callv() {
             break;
         }
     }
-    if (node.size()==0) {
+    if (node->get_slices().size()==0) {
         die(thisspan, "expected index value");
     }
     update_location(node);
@@ -659,7 +673,7 @@ expr* parse::callv() {
     return node;
 }
 
-expr* parse::callf() {
+call_function* parse::callf() {
     // panic set for this token is not ','
     // this is the FIRST set of calculation/hashmember
     // array end with tok::null=0
@@ -669,11 +683,11 @@ expr* parse::callf() {
         tok::func,tok::var,tok::lcurve,tok::floater,
         tok::lbrace,tok::lbracket,tok::null
     };
-    ast node(toks[ptr].loc, ast_callf);
+    auto node = new call_function(toks[ptr].loc);
     bool special_call=check_special_call();
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
-        node.add(special_call?pair():calc());
+        node->add_argument(special_call?pair():calc());
         if (lookahead(tok::comma))
             match(tok::comma);
         else if (lookahead(tok::eof))
@@ -686,14 +700,12 @@ expr* parse::callf() {
     return node;
 }
 
-expr* parse::subvec() {
-    ast node=lookahead(tok::colon)?nil():calc();
+slice_vector* parse::subvec() {
+    auto node = new slice_vector(toks[ptr].loc);
+    node->set_begin(lookahead(tok::colon)?nil():calc());
     if (lookahead(tok::colon)) {
-        ast tmp(toks[ptr].loc, ast_subvec);
         match(tok::colon);
-        tmp.add(std::move(node));
-        tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
-        node=std::move(tmp);
+        node->set_end((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
     }
     update_location(node);
     return node;
@@ -804,7 +816,7 @@ expr* parse::multi_assgin() {
 
 expr* parse::loop() {
     ++in_loop;
-    ast node(toks[ptr].loc, ast_null);
+    expr* node = nullptr;
     switch(toks[ptr].type) {
         case tok::rwhile:  node=while_loop(); break;
         case tok::rfor:    node=for_loop();   break;
@@ -816,19 +828,19 @@ expr* parse::loop() {
     return node;
 }
 
-expr* parse::while_loop() {
-    ast node(toks[ptr].loc, ast_while);
+while_expr* parse::while_loop() {
+    auto node = new while_expr(toks[ptr].loc);
     match(tok::rwhile);
     match(tok::lcurve);
-    node.add(calc());
+    node->set_condition(calc());
     match(tok::rcurve);
-    node.add(exprs());
+    node->set_code_block(expression_block());
     update_location(node);
     return node;
 }
 
-expr* parse::for_loop() {
-    ast node(toks[ptr].loc, ast_for);
+for_expr* parse::for_loop() {
+    auto node = new for_expr(toks[ptr].loc);
     match(tok::rfor);
     match(tok::lcurve);
     // first expression
@@ -836,13 +848,13 @@ expr* parse::for_loop() {
         die(thisspan, "expected definition");
     }
     if (lookahead(tok::semi)) {
-        node.add(null());
+        node->set_initial(null());
     } else if (lookahead(tok::var)) {
-        node.add(definition());
+        node->set_initial(definition());
     } else if (lookahead(tok::lcurve)) {
-        node.add(lcurve_expr());
+        node->set_initial(lcurve_expr());
     } else {
-        node.add(calc());
+        node->set_initial(calc());
     }
     match(tok::semi, "expected ';' in for(;;)");
     // conditional expression
@@ -850,9 +862,9 @@ expr* parse::for_loop() {
         die(thisspan, "expected conditional expr");
     }
     if (lookahead(tok::semi)) {
-        node.add(null());
+        node->set_condition(null());
     } else {
-        node.add(calc());
+        node->set_condition(calc());
     }
     match(tok::semi, "expected ';' in for(;;)");
     //after loop expression
@@ -860,21 +872,27 @@ expr* parse::for_loop() {
         die(thisspan, "expected calculation");
     }
     if (lookahead(tok::rcurve)) {
-        node.add(null());
+        node->set_step(null());
     } else {
-        node.add(calc());
+        node->set_step(calc());
     }
     match(tok::rcurve);
-    node.add(exprs());
+    node->set_code_block(expression_block());
     update_location(node);
     return node;
 }
 
-expr* parse::forei_loop() {
-    ast node(toks[ptr].loc, ast_null);
+forei_expr* parse::forei_loop() {
+    auto node = new forei_expr(toks[ptr].loc);
     switch(toks[ptr].type) {
-        case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
-        case tok::foreach: node.set_type(ast_foreach); match(tok::foreach); break;
+        case tok::forindex:
+            node->set_type(forei_expr::forei_loop_type::forindex);
+            match(tok::forindex);
+            break;
+        case tok::foreach: 
+            node->set_type(forei_expr::forei_loop_type::foreach);
+            match(tok::foreach);
+            break;
         default: break;
     }
     match(tok::lcurve);
@@ -883,24 +901,24 @@ expr* parse::forei_loop() {
     if (!lookahead(tok::var) && !lookahead(tok::id)) {
         die(thisspan, "expected iterator");
     }
-    node.add(iter_gen());
+    node->set_iterator(iter_gen());
     match(tok::semi, "expected ';' in foreach/forindex(iter;vector)");
     if (lookahead(tok::eof)) {
         die(thisspan, "expected vector");
     }
-    node.add(calc());
+    node->set_value(calc());
     match(tok::rcurve);
-    node.add(exprs());
+    node->set_code_block(expression_block());
     update_location(node);
     return node;
 }
 
-expr* parse::iter_gen() {
-    ast node(toks[ptr].loc, ast_null);
+iter_expr* parse::iter_gen() {
+    auto node = new iter_expr(toks[ptr].loc);
     if (lookahead(tok::var)) {
         match(tok::var);
         node.set_type(ast_iter);
-        node.add(id());
+        node->set_name(id());
     } else {
         node.set_type(ast_call);
         node.add(id());
@@ -912,38 +930,38 @@ expr* parse::iter_gen() {
     return node;
 }
 
-expr* parse::cond() {
-    ast node(toks[ptr].loc, ast_cond);
+condition_expr* parse::cond() {
+    auto node = new condition_expr(toks[ptr].loc);
 
     // generate if
-    ast ifnode(toks[ptr].loc, ast_if);
+    auto ifnode = new if_expr(toks[ptr].loc);
     match(tok::rif);
     match(tok::lcurve);
-    ifnode.add(calc());
+    ifnode->set_condition(calc());
     match(tok::rcurve);
-    ifnode.add(exprs());
-    ifnode.update_span();
-    node.add(std::move(ifnode));
+    ifnode->set_code_block(expression_block());
+    update_location(ifnode);
+    node->set_if_statement(ifnode);
 
     // generate elsif
     while(lookahead(tok::elsif)) {
-        ast elsifnode(toks[ptr].loc, ast_elsif);
+        auto elsifnode = new if_expr(toks[ptr].loc);
         match(tok::elsif);
         match(tok::lcurve);
-        elsifnode.add(calc());
+        elsifnode->set_condition(calc());
         match(tok::rcurve);
-        elsifnode.add(exprs());
-        elsifnode.update_span();
-        node.add(std::move(elsifnode));
+        elsifnode->set_code_block(expression_block());
+        update_location(elsifnode);
+        node->add_elsif_statement(elsifnode);
     }
 
     // generate else
     if (lookahead(tok::relse)) {
-        ast elsenode(toks[ptr].loc, ast_else);
+        auto elsenode = new if_expr(toks[ptr].loc);
         match(tok::relse);
-        elsenode.add(exprs());
-        elsenode.update_span();
-        node.add(std::move(elsenode));
+        elsenode->set_code_block(expression_block());
+        update_location(elsenode);
+        node->set_else_statement(elsenode);
     }
     update_location(node);
     return node;

ast/nasal_new_parse.h

@@ -105,21 +105,21 @@ private:
     expr* expression();
     code_block* expression_block();
     expr* calc();
-    expr* bitwise_or();
-    expr* bitwise_xor();
-    expr* bitwise_and();
-    expr* or_expr();
-    expr* and_expr();
-    expr* cmp_expr();
-    expr* additive_expr();
+    binary_operator* bitwise_or();
+    binary_operator* bitwise_xor();
+    binary_operator* bitwise_and();
+    binary_operator* or_expr();
+    binary_operator* and_expr();
+    binary_operator* cmp_expr();
+    binary_operator* additive_expr();
     expr* multive_expr();
-    expr* unary();
+    unary_operator* unary();
     expr* scalar();
     expr* call_scalar();
-    expr* callh();
-    expr* callv();
-    expr* callf();
-    expr* subvec();
+    call_hash* callh();
+    call_vector* callv();
+    call_function* callf();
+    slice_vector* subvec();
     expr* definition();
     expr* incurve_def();
     expr* outcurve_def();
@@ -127,11 +127,11 @@ private:
     expr* multi_scalar();
     expr* multi_assgin();
     expr* loop();
-    expr* while_loop();
-    expr* for_loop();
-    expr* forei_loop();
-    expr* iter_gen();
-    expr* cond();
+    while_expr* while_loop();
+    for_expr* for_loop();
+    forei_expr* forei_loop();
+    iter_expr* iter_gen();
+    condition_expr* cond();
     continue_expr* continue_expression();
     break_expr* break_expression();
     return_expr* return_expression();