void Parser::parseFactor_p(IdentifierPtr id)
{
if (m_curToken.tokenType() == TokenType::LBracket) {
id->index = parseOptionalIndex();
return;
} else if (match(TokenType::LParen)) {
id->parameters = parseExpressionList();
if (m_errorCode > ErrorCodes::NoError) {
panic(factorFollow, factorFollowSize);
return;
}
if (!match(TokenType::RParen)) {
reportError(ErrorCodes::ExpectedRParen);
panic(factorFollow, factorFollowSize);
return;
}
if (!id->parameters) {
// empty param list
ExpressionsPtr tmp(new Expressions);
id->parameters = tmp;
}
return;
}
// is empty
}
ExpressionsPtr Parser::parseExpressionList_r()
{
if (match(TokenType::Comma)) {
return parseExpressionList();
}
return ExpressionsPtr();
}
void Parser::parseProcedureStatementPrime(SymbolTableEntry* prevEntry){
if(isNext(tc_LPAREN)){
match(tc_LPAREN);
parseExpressionList(prevEntry);
match(tc_RPAREN);
if(m_parserError){
TokenCode synch[] = {tc_END, tc_SEMICOL, tc_ELSE, tc_NONE};
recover(synch);
// if(isNext(tc_RPAREN)){
// match(tc_RPAREN);
// }
}
}
}
SymbolTableEntry* Parser::parseFactorPrime(SymbolTableEntry* prevEntry){
if(isNext(tc_LBRACKET)){
parseVariablePrime(prevEntry);
}
else if(isNext(tc_LPAREN)){
match(tc_LPAREN);
parseExpressionList(prevEntry);
match(tc_RPAREN);
if(m_parserError){
TokenCode synch[] = {tc_RPAREN, tc_END, tc_ADDOP, tc_MULOP, tc_RELOP, tc_THEN, tc_DO, tc_COMMA, tc_RBRACKET, tc_SEMICOL, tc_ELSE, tc_NONE};
recover(synch);
// if(isNext(tc_RPAREN)){
// match(tc_RPAREN);
// }
}
//m_code->generate(cd_CALL, prevEntry, NULL, NULL);
}
return prevEntry;
}
ExpressionsPtr Parser::parseOptionalParameters()
{
if (match(TokenType::LParen)) {
ExpressionsPtr parameters = parseExpressionList();
if (m_errorCode > ErrorCodes::NoError) {
return ExpressionsPtr();
}
if (!match(TokenType::RParen)) {
reportError(ErrorCodes::ExpectedRParen);
return ExpressionsPtr();
}
if (!parameters) {
// empty parameter list
ExpressionsPtr tmp(new Expressions);
parameters = tmp;
}
return parameters;
}
return ExpressionsPtr();
}
bool Parser::checkMacroDefinition()
{
const Token& first = peekToken();
if (first.type != TokenType::Identifier)
return false;
if (!first.stringValueStartsWith(L'.') || first.getStringValue() != L".macro")
return false;
eatToken();
// nested macro definitions are not allowed
if (initializingMacro)
{
printError(first,L"Nested macro definitions not allowed");
while (!atEnd())
{
const Token& token = nextToken();
if (token.type == TokenType::Identifier && token.getStringValue() == L".endmacro")
break;
}
return true;
}
std::vector<Expression> parameters;
if (parseExpressionList(parameters,1,-1) == false)
return false;
// load name
std::wstring macroName;
if (parameters[0].evaluateIdentifier(macroName) == false)
return false;
// duplicate check the macro
ParserMacro ¯o = macros[macroName];
if (macro.name.length() != 0)
{
printError(first,L"Macro \"%s\" already defined",macro.name);
return false;
}
// and register it
macro.name = macroName;
macro.counter = 0;
// load parameters
for (size_t i = 1; i < parameters.size(); i++)
{
std::wstring name;
if (parameters[i].evaluateIdentifier(name) == false)
return false;
macro.parameters.push_back(name);
}
// load macro content
TokenizerPosition start = getTokenizer()->getPosition();
bool valid = false;
while (atEnd() == false)
{
const Token& tok = nextToken();
if (tok.type == TokenType::Identifier && tok.getStringValue() == L".endmacro")
{
valid = true;
break;
}
}
// no .endmacro, not valid
if (valid == false)
return true;
// get content
TokenizerPosition end = getTokenizer()->getPosition().previous();
macro.content = getTokenizer()->getTokens(start,end);
return true;
}
StringMath::Token StringMath::evaluate(const std::string &expressionList) {
lexer.reset(expressionList);
return parseExpressionList();
}
