Statement *ParserContext::parse_statement() { Statement *statement = 0; switch (curtok()->type()) { case tok_while: { statement = parse_while(); break; } case tok_if: { statement = parse_if(); break; } case tok_return: { statement = parse_return(); eat_token(tok_semicolon); break; } case tok_def: { statement = parse_def(); break; } default: { Expression *expression = parse_expression(); if (expression) { statement = new ExpressionStatement(expression); eat_token(tok_semicolon); } else { throw UnexpectedToken("parse_statement", curtok()); } break; } } return statement; }
static struct AstNode *parse_special( struct DomNode *dom, struct ParserState *state) { struct AstNode *result; if ((!err_state() && (result = parse_do_block(dom, state))) || (!err_state() && (result = parse_match(dom, state))) || (!err_state() && (result = parse_if(dom, state))) || (!err_state() && (result = parse_while(dom, state))) || (!err_state() && (result = parse_func_def(dom, state))) || (!err_state() && (result = parse_min_nary(dom, 1, DOM_RES_AND, ast_make_spec_bool_and, state))) || (!err_state() && (result = parse_min_nary(dom, 1, DOM_RES_OR, ast_make_spec_bool_or, state))) || (!err_state() && (result = parse_min_nary(dom, 1, DOM_RES_SET_OF, ast_make_spec_set_of, state))) || (!err_state() && (result = parse_binary(dom, DOM_RES_RANGE_OF, ast_make_spec_range_of, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_ARRAY_OF, ast_make_spec_array_of, state))) || (!err_state() && (result = parse_min_nary(dom, 1, DOM_RES_TUPLE_OF, ast_make_spec_tuple_of, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_POINTER_TO, ast_make_spec_pointer_to, state))) || (!err_state() && (result = parse_min_nary(dom, 1, DOM_RES_FUNCTION, ast_make_spec_function_type, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_TYPE_PRODUCT, ast_make_spec_type_product, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_TYPE_UNION, ast_make_spec_type_union, state))) || (!err_state() && (result = parse_bind(dom, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_PTR, ast_make_spec_ptr, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_PEEK, ast_make_spec_peek, state))) || (!err_state() && (result = parse_binary(dom, DOM_RES_POKE, ast_make_spec_poke, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_BEGIN, ast_make_spec_begin, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_END, ast_make_spec_end, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_INC, ast_make_spec_inc, state))) || (!err_state() && (result = parse_unary(dom, DOM_RES_SUCC, ast_make_spec_succ, state)))) { return result; } else { return NULL; } }
static statement_t* parse_statement(parser_t* p) { statement_t* statement = (statement_t*)malloc(sizeof(statement_t)); token_type_t tok = get_token(p->t); unget_token(p->t); switch (tok) { case TT_IF: statement->type = ST_IF; statement->value = parse_if(p); break; case TT_WHILE: statement->type = ST_WHILE; statement->value = parse_while(p); break; case TT_RETURN: statement->type = ST_RETURN; match(p, TT_RETURN); statement->value = parse_expression(p); break; case TT_PRINT: statement->type = ST_PRINT; match(p, TT_PRINT); statement->value = parse_expression(p); break; default: statement->type = ST_EXPRESSION; statement->value = parse_expression(p); } return statement; }
/* parse_statement Checks the current token to be able to parse the correct statement Parameters: none Return: none */ void parse_statement(Tree &cst){ cst.add_branch_node("statement"); if(!(curr_token -> desc).compare("print")){ parse_print(cst); } else if(!(curr_token -> type).compare("identifier")){ parse_assingment(cst); } else if(types.find(curr_token -> desc) != types.end()){ parse_var_decl(cst); } else if(!(curr_token -> desc).compare("while")){ parse_while(cst); } else if(!(curr_token -> desc).compare("if")){ parse_if(cst); } else if(!(curr_token -> type).compare("open_block")){ parse_block(cst); } else{ std::cout << "Parse Error on line " << curr_token -> line_number << ".\nExpected statement, found " << curr_token -> desc << "\nStatements begin with:\n\tprint\n\tidentifier -- [a-z]\n\t" << "int, string, boolean\n\twhile\n\tif\n\t{" << "\n\nCompilation unsuccessful" << std::endl; exit(EXIT_FAILURE); } cst.kill_all_children(); }
struct instruction *parse_instruction(void) { struct expr *expr; struct instruction *res; switch (lookahead[0]->type) { case WHILE: return parse_while(); case DO: return parse_do(); case IDENTIFIER: case LPAREN: expr = parse_expression(); switch(lookahead[0]->type) { case ASSIGN: return parse_assignment_instr(expr); case EOL: if (expr->exprtype != funcalltype) { if (expr->exprtype == binopexprtype && expr->val.binopexpr.op == EQ) { error(expr->pos, "unexpected =, did you mean <- ?"); exit(1); } else syntaxerror("expected instruction, not expression"); } eat(EOL); res = funcallinstr(expr->val.funcall.fun_ident, expr->val.funcall.args, expr->pos); free(expr); return res; default: next(); syntaxerror("unexpected %s", tok->val); return parse_instruction(); } case RETURN: eat(RETURN); if (lookahead[0]->type == EOL) { eat(EOL); return return_stmt(NULL); } else { expr = parse_expression(); eat(EOL); return return_stmt(expr); } case FOR: return parse_for(); case IF: return parse_if(); case SWITCH: return parse_switch(); case ENDOFFILE: return NULL; default: next(); syntaxerror("expected instruction, not %s", tok->val); return parse_instruction(); } }
/** Parse statement. * * @param parse Parser object. * @return New syntax tree node. */ stree_stat_t *parse_stat(parse_t *parse) { stree_stat_t *stat; stree_vdecl_t *vdecl_s; stree_if_t *if_s; stree_switch_t *switch_s; stree_while_t *while_s; stree_for_t *for_s; stree_raise_t *raise_s; stree_break_t *break_s; stree_return_t *return_s; stree_wef_t *wef_s; stree_exps_t *exp_s; #ifdef DEBUG_PARSE_TRACE printf("Parse statement.\n"); #endif switch (lcur_lc(parse)) { case lc_var: vdecl_s = parse_vdecl(parse); stat = stree_stat_new(st_vdecl); stat->u.vdecl_s = vdecl_s; break; case lc_if: if_s = parse_if(parse); stat = stree_stat_new(st_if); stat->u.if_s = if_s; break; case lc_switch: switch_s = parse_switch(parse); stat = stree_stat_new(st_switch); stat->u.switch_s = switch_s; break; case lc_while: while_s = parse_while(parse); stat = stree_stat_new(st_while); stat->u.while_s = while_s; break; case lc_for: for_s = parse_for(parse); stat = stree_stat_new(st_for); stat->u.for_s = for_s; break; case lc_raise: raise_s = parse_raise(parse); stat = stree_stat_new(st_raise); stat->u.raise_s = raise_s; break; case lc_break: break_s = parse_break(parse); stat = stree_stat_new(st_break); stat->u.break_s = break_s; break; case lc_return: return_s = parse_return(parse); stat = stree_stat_new(st_return); stat->u.return_s = return_s; break; case lc_do: case lc_with: wef_s = parse_wef(parse); stat = stree_stat_new(st_wef); stat->u.wef_s = wef_s; break; default: exp_s = parse_exps(parse); stat = stree_stat_new(st_exps); stat->u.exp_s = exp_s; break; } #ifdef DEBUG_PARSE_TRACE printf("Parsed statement %p\n", stat); #endif return stat; }
bool Parser::parse_statement(StatementList *list) { lexer.identify_keywords(); switch(lexeme()) { case Lexeme::KW_IF: parse_if(list); break; case Lexeme::KW_WHILE: parse_while(list); break; case Lexeme::KW_DO: parse_do(list); parse_terminator(); break; case Lexeme::KW_RETURN: parse_return(list); parse_terminator(); break; case Lexeme::KW_BREAK: parse_break(list); parse_terminator(); break; case Lexeme::KW_CONTINUE: parse_continue(list); parse_terminator(); break; case Lexeme::KW_CONST: step(); parse_local(true, parse_expression(), list); parse_terminator(); break; case Lexeme::BRACET_OPEN: list->append(parse_block<true, false>(Scope::EMPTY)); break; case Lexeme::SEMICOLON: step(); break; case Lexeme::END: case Lexeme::BRACET_CLOSE: return false; default: if(is_expression(lexeme())) { ExpressionNode *node = parse_expression(); if(lexeme() == Lexeme::IDENT && node->is_type_name(document, false)) parse_local(false, node, list); else list->append(node); parse_terminator(); } else return false; } return true; }