/*** 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;
}
INode * REParser::parseNodeUnit(std::string::const_iterator & c, const std::string::const_iterator & end)
{
INode * ret = 0;
switch (*c)
{
case '(':
{
++c;
ret = parseNodeOr(c, end, true);
if (ret == 0)
throw std::string("empty brackets");
if (c == end || *c != ')')
throw std::string("Incomplete group, no matching ')'");
++c;
break;
}
case '[':
++c;
if (c == end)
throw std::string("Incomplete character sequence, no matching ']'");
if (*c == ']')
throw std::string("Empty character sequence []");
ret = parseCharSequence(c, end);
++c;
break;
default:
ret = getAFinal(c, end);
}
for (; c != end && (*c == '?' || *c == '*' || *c == '+' || *c == '{'); ++c)
switch (*c)
{
case '?':
ret = new Optional(ret);
break;
case '*':
ret = new Repeat(ret);
break;
case '+':
ret = new And(ret->clone(), new Repeat(ret));
break;
case '{':
++c;
ret = parseRepeat(c, end, ret);
break;
}
return ret;
}
//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;
}
