/*** 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; }