AstNode* Parser::parseStatement() {
if (isKeyword(currentTokenValue())) {
if (currentTokenValue() == "function") {
return parseFunction();
} else if (currentTokenValue() == "for") {
return parseFor();
} else if (currentTokenValue() == "if") {
return parseIf();
} else if (currentTokenValue() == "while") {
return parseWhile();
} else if (currentTokenValue() == "print") {
return parsePrint();
} else if (currentTokenValue() == "int") {
return parseDeclaration(VT_INT);
} else if (currentTokenValue() == "double") {
return parseDeclaration(VT_DOUBLE);
} else if (currentTokenValue() == "string") {
return parseDeclaration(VT_STRING);
} else if (currentTokenValue() == "return") {
return parseReturn();
} else {
cout << "unhandled keyword " << currentTokenValue() << endl;
assert(false);
return 0;
}
}
if (currentToken() == tLBRACE) {
return parseBlock(true);
}
if ((currentToken() == tIDENT) && isAssignment(lookaheadToken(1))) {
return parseAssignment();
}
return parseExpression();
}
/*** Parse a statement ***/
Node* Parser::parseStatement()
{
if(hasTokens(2) && peekToken().getType() == T_IDENTIFIER && peekToken(2).getType() == T_ASSIGN)
return parseAssign();
if(hasTokens(2) && peekToken().getType() == T_IDENTIFIER && peekToken(2).getType() == T_LPAREN)
return parseCall();
if(hasTokens() && peekToken().getType() == T_CALL)
return parseCall();
if(hasTokens() && peekToken().getType() == T_CASE)
return parseCase();
if(hasTokens() && peekToken().getType() == T_DO)
return parseDo();
if(hasTokens() && peekToken().getType() == T_END)
return parseEnd();
if(hasTokens() && peekToken().getType() == T_EXIT)
return parseExit();
if(hasTokens() && peekToken().getType() == T_FOR)
return parseFor();
if(hasTokens() && peekToken().getType() == T_IF)
return parseIf();
if(hasTokens() && peekToken().getType() == T_INPUT)
return parseInput();
if(hasTokens() && peekToken().getType() == T_OUTPUT)
return parseOutput();
if(hasTokens() && peekToken().getType() == T_REPEAT)
return parseRepeat();
if(hasTokens() && peekToken().getType() == T_RETURN)
return parseReturn();
if(hasTokens(2) && peekToken(1).getType() == T_IDENTIFIER && peekToken(2).getType() == T_LBRACKET)
return parseSliceSelectAssign();
if(hasTokens() && peekToken().getType() == T_WHILE)
return parseWhile();
throw ParserSyntaxException(getToken(), "Invalid statement!");
return 0;
}
void parseBlockExp (Lexer& lex, ExpList& list)
{
switch (lex.current().tok)
{
case tSemicolon:
lex.advance();
break;
case tLet:
list.push_back(parseLet(lex));
lex.eat(tSemicolon);
break;
case tLCurl:
list.push_back(parseBlock(lex));
break;
case tIf:
list.push_back(parseCond(lex));
break;
case tLoop:
list.push_back(parseLoop(lex));
break;
case tFor:
list.push_back(parseFor(lex));
break;
// everthing else does
default:
list.push_back(parseAssign(lex, parseExp(lex)));
if (lex.current() != tSemicolon)
lex.expect(tRCurl);
else
lex.eat(tSemicolon);
break;
}
}
//Core Method
shared_ptr<Statement> Parser::parseStatement()
{
Tag tags[] = { EQ, UNEQ, LT, GT, LE, GE };
auto isRealOp = [&](Tag t){
for (auto i : tags)
{
if (t == i)
{
return true;
}
}
return false;
};
switch (it->tag)
{
//VAR,TYPE,Function call,If,Else,While,For,有的可改变currNode,有的不可
/*case BEGIN:
break;*/
case IDENT://此处默认为赋值表达式，实际上大错特错，如果是 函数调用 何如?
if (advance(BIND))
{
shared_ptr<AssignStmt> assign = parseAssign();
//currNode->addNode(assign);
return assign;
}
else if (advance(OpenBracket))
{
shared_ptr<FuncCall> funcCall = parseFunctionCall();
//currNode->addNode(funcCall);
return funcCall;
}
//暂不支持嵌套函数
/*case FUNCTION:
break;
case PROCEDURE:
break;*/
case IF:
{
shared_ptr<Node> tmp = currNode;
shared_ptr<IfStmt> ifstmt = static_pointer_cast<IfStmt>(parseIf());
currNode = tmp;
//currNode->addNode(ifstmt);
return ifstmt;
}
case WHILE:
{
shared_ptr<Node> tmp = currNode;
shared_ptr<WhileStmt> whStmt = static_pointer_cast<WhileStmt>(parseWhile());
currNode = tmp;
//currNode->addNode(whStmt);
return whStmt;
}
case REPEAT:
{
shared_ptr<Node> tmp = currNode;
shared_ptr<RepeatStmt> repeatStmt = static_pointer_cast<RepeatStmt>(parseRepeat());
currNode = tmp;
//currNode->addNode(repeatStmt);
return repeatStmt;
}
case FOR:
{
shared_ptr<Node> tmp = currNode;
shared_ptr<ForStmt> forStmt = static_pointer_cast<ForStmt>(parseFor());
currNode = tmp;
//currNode->addNode(forStmt);
return forStmt;
}
case CASE:
{
shared_ptr<Node> tmp = currNode;
shared_ptr<CaseStmt> caseStmt = static_pointer_cast<CaseStmt>(parseCase());
currNode = tmp;
//currNode->addNode(caseStmt);
return caseStmt;
}
default:
return NULL;
}
return NULL;
}
