/*** Parse an input statement ***/
Input* Parser::parseInput()
{
if(!hasTokens() || peekToken().getType() != T_INPUT)
throw ParserSyntaxException(getToken(), "Expected \"input\" statement.");
Token tok = getToken();
// Check if a getText symbol is present
bool getText = false;
if(hasTokens() && peekToken().getType() == T_TEXT)
{
getToken();
getText = true;
}
// Remove the colon
if(!hasTokens() || peekToken().getType() != T_COLON)
throw ParserSyntaxException(getToken(), "Expected ':'.");
std::auto_ptr<Input> result(new Input(getText));
result->setLineNumber(tok.getLineNumber());
result->setColumnNumber(tok.getColumnNumber());
do
{
getToken();
// Parse an expression
result->addExpression(parseExpression());
}
while(hasTokens() && peekToken().getType() == T_COMMA);
return result.release();
}
Object* Parser::parseSubExpression2()
{
bool negateResult = false;
Token negToken;
if(hasTokens() && (peekToken().getType() == T_MINUS || peekToken().getType() == T_PLUS))
{
if(peekToken().getType() == T_MINUS)
negateResult = true;
negToken = getToken();
}
std::auto_ptr<Object> result;
if(hasTokens() && peekToken().getType() == T_HASH)
{
Token lengthToken = getToken();
std::auto_ptr<Object> sub(parseSubExpression1());
result.reset(new Length(sub.release()));
result->setLineNumber(lengthToken.getLineNumber());
result->setColumnNumber(lengthToken.getColumnNumber());
}
else
result.reset(parseSubExpression1());
if(negateResult)
{
result.reset(new Negate(result.release()));
result->setLineNumber(negToken.getLineNumber());
result->setColumnNumber(negToken.getColumnNumber());
}
return result.release();
}
/*** Parse an intern statement ***/
Intern* Parser::parseIntern()
{
if(!hasTokens() || peekToken().getType() != T_INTERN)
throw new ParserSyntaxException(getToken(), "Expected \"intern\" command!");
Token tok = getToken();
if(!hasTokens() || peekToken().getType() != T_COLON)
throw new ParserSyntaxException(getToken(), "Expected \":\"!");
getToken();
// Loop through, storing variable names
std::auto_ptr<Intern> result(new Intern());
result->setLineNumber(tok.getLineNumber());
result->setColumnNumber(tok.getColumnNumber());
while(hasTokens() && peekToken().getType() == T_IDENTIFIER)
{
result->addIdentifier(getToken().getLexeme());
if(!hasTokens() || peekToken().getType() != T_COMMA)
break;
getToken();
}
return result.release();
}
/*** Parse an output statement***/
Output* Parser::parseOutput()
{
if(!hasTokens() || peekToken().getType() != T_OUTPUT)
throw ParserSyntaxException(getToken(), "Expected \"output\" statement.");
Token tok = getToken();
// Check if a no-line-feed symbol is present
bool lineFeed = true;
if(hasTokens() && peekToken().getType() == T_NLF)
{
getToken();
lineFeed = false;
}
// Remove the colon
if(!hasTokens() || peekToken().getType() != T_COLON)
throw ParserSyntaxException(getToken(), "Expected ':'.");
std::auto_ptr<Output> result(new Output(lineFeed));
result->setLineNumber(tok.getLineNumber());
result->setColumnNumber(tok.getColumnNumber());
do
{
getToken();
// Parse an expression
result->addExpression(parseExpression());
}
while(hasTokens() && peekToken().getType() == T_COMMA);
return result.release();
}
void parseLine(const char **strptr)
{
if (peekToken(*strptr) == END)
return;
char firstCmdName[MAX_CMD_SIZE + 1];
char temp[MAX_CMD_SIZE + 1];
Token next = peekToken(*strptr, firstCmdName);
switch (next) {
case SETENV:
parseSetenv(strptr);
cmdCounter++;
break;
case PRINTENV:
parsePrintenv(strptr);
cmdCounter++;
break;
case EXIT:
closeUnclosedFd();
exit(0);
break;
case IDENTIFIER:
parseMultiCmd(strptr);
if (getPath(temp, firstCmdName))
cmdCounter++;
break;
case END:
break;
default:
PARSE_ASSERT(0);
}
PARSE_ASSERT(getToken(NULL, strptr) == END);
}
// We are pasting if
// 1. we are preceding a pasting operator within this stream
// or
// 2. the entire macro is preceding a pasting operator (lastTokenPastes)
// and we are also on the last token
bool TPpContext::TokenStream::peekTokenizedPasting(bool lastTokenPastes)
{
// 1. preceding ##?
size_t savePos = currentPos;
// skip white space
while (peekToken(' '))
++currentPos;
if (peekToken(PpAtomPaste)) {
currentPos = savePos;
return true;
}
// 2. last token and we've been told after this there will be a ##
if (! lastTokenPastes)
return false;
// Getting here means the last token will be pasted, after this
// Are we at the last non-whitespace token?
savePos = currentPos;
bool moreTokens = false;
do {
if (atEnd())
break;
if (!peekToken(' ')) {
moreTokens = true;
break;
}
++currentPos;
} while (true);
currentPos = savePos;
return !moreTokens;
}
CAssemblerCommand* Parser::parseLabel()
{
updateFileInfo();
const Token& start = peekToken(0);
if (peekToken(0).type == TokenType::Identifier &&
peekToken(1).type == TokenType::Colon)
{
const std::wstring name = peekToken(0).getStringValue();
eatTokens(2);
if (initializingMacro)
macroLabels.insert(name);
if (Global.symbolTable.isValidSymbolName(name) == false)
{
printError(start,L"Invalid label name");
return nullptr;
}
return new CAssemblerLabel(name);
}
return nullptr;
}
/*** Parse from zero-level ***/
void Parser::parse()
{
if(hasTokens() && peekToken().getType() == T_EOL)
parseSeparation();
while(hasTokens())
{
// if(peekToken().getType() == T_PROC)
// parseProcedureDefinition();
// else if(peekToken().getType() == T_FUN)
// parseFunctionDefinition();
// else
if(peekToken().getType() == T_PROC)
{
parseProcedure();
parseSeparation();
}
else if(peekToken().getType() == T_FUN)
{
parseFunction();
parseSeparation();
}
else
{
list->pushNode(parseStatement());
parseSeparation();
}
}
// VariableManager manager;
}
/*** Parse a separation ***/
void Parser::parseSeparation()
{
if(!hasTokens())
return;
if(peekToken().getType() != T_SEMICOLON && peekToken().getType() != T_EOL)
throw ParserSyntaxException(getToken(), "Expected ';' or EOL to separate statements!");
while(hasTokens() && (peekToken().getType() == T_EOL || peekToken().getType() == T_SEMICOLON))
getToken();
}
/*** Parse an if statement ***/
If* Parser::parseIf()
{
if(!hasTokens() || peekToken().getType() != T_IF)
throw ParserSyntaxException(getToken(), "Expected \"if\".");
Token tok = getToken();
// Parse the condition
std::auto_ptr<Object> expr(parseExpression());
if(!hasTokens() || peekToken().getType() != T_THEN)
throw ParserSyntaxException(getToken(), "Expected \"then\"!");
getToken();
// Parse any newlines
while(hasTokens() && peekToken().getType() == T_EOL)
getToken();
// Parse if statement body
std::auto_ptr<NodeList> ifStmts(new NodeList());
while(hasTokens() && !(peekToken().getType() == T_ELSE || peekToken().getType() == T_FI))
{
ifStmts->pushNode(parseStatement());
parseSeparation();
}
// Create the new if object
std::auto_ptr<If> result(new If());
result->setLineNumber(tok.getLineNumber());
result->setColumnNumber(tok.getColumnNumber());
// Parse an else statement body if present
if(hasTokens() && peekToken().getType() == T_ELSE)
{
getToken();
std::auto_ptr<NodeList> elseStmts(new NodeList());
// Parse any newlines
while(hasTokens() && peekToken().getType() == T_EOL)
getToken();
while(hasTokens() && peekToken().getType() != T_FI)
{
elseStmts->pushNode(parseStatement());
parseSeparation();
}
result->setElseStatements(elseStmts.release());
}
if(!hasTokens() || peekToken().getType() != T_FI)
throw ParserSyntaxException(getToken(), "Expected \"fi\"!");
getToken();
result->setIfCondition(expr.release());
result->setIfStatements(ifStmts.release());
return result.release();
}
/*** Parse a return statement ***/
Return* Parser::parseReturn()
{
if(!hasTokens() || peekToken().getType() != T_RETURN)
throw ParserSyntaxException(getToken(), "Expected \"return\" command!");
Token tok = getToken();
std::auto_ptr<Return> ret(new Return());
ret->setLineNumber(tok.getLineNumber());
ret->setColumnNumber(tok.getColumnNumber());
if(!hasTokens() || peekToken().getType() == T_EOL)
return ret.release();
std::auto_ptr<Object> expr(parseExpression());
ret->setExpression(expr.release());
return ret.release();
}
bool Parser::parseExpressionList(std::vector<Expression>& list, int min, int max)
{
bool valid = true;
list.clear();
list.reserve(max >= 0 ? max : 32);
const Token& start = peekToken();
Expression exp = parseExpression();
list.push_back(exp);
if (exp.isLoaded() == false)
{
printError(start,L"Parameter failure");
getTokenizer()->skipLookahead();
valid = false;
}
while (peekToken().type == TokenType::Comma)
{
eatToken();
exp = parseExpression();
list.push_back(exp);
if (exp.isLoaded() == false)
{
printError(start,L"Parameter failure");
getTokenizer()->skipLookahead();
valid = false;
}
}
if (list.size() < (size_t) min)
{
printError(start,L"Not enough parameters (min %d)",min);
return false;
}
if (max != -1 && (size_t) max < list.size())
{
printError(start,L"Too many parameters (max %d)",max);
return false;
}
return valid;
}
StringMath::Token StringMath::Lexer::popToken() {
const Token token = peekToken();
if(tokens.size() > 0)
tokens.pop_front();
return token;
}
bool getToken(TokenId token, CurrPtr& curr, EndPtr end)
{
if (peekToken(curr, end) != token)
return false;
getToken(curr, end);
return true;
}
/**
* Parse a key element.
* @param name Name of the parsed key element.
*/
KeyElement *parseKeyElement(String const &name)
{
InfoValue value;
if(peekToken() == "$")
{
// This is a script value.
value.flags |= InfoValue::Script;
nextToken();
}
// A colon means that that the rest of the line is the value of
// the key element.
if(peekToken() == ":")
{
value.text = readToEOL().trimmed();
nextToken();
}
else if(peekToken() == "=")
{
if(value.flags.testFlag(InfoValue::Script))
{
// Parse one script statement.
value = parseScript(1);
value.text = value.text.trimmed();
}
else
{
/**
* Key =
* "This is a long string "
* "that spans multiple lines."
*/
nextToken();
value.text = parseValue();
}
}
else
{
throw SyntaxError("Info::parseKeyElement",
QString("Expected either '=' or ':', but '%1' found instead (on line %2).")
.arg(peekToken()).arg(currentLine));
}
return new KeyElement(name, value);
}
Object* Parser::parseValue()
{
if(!hasTokens())
return 0;
if(peekToken().getType() == T_EMPTY)
{
Object* obj = new Object();
Token tok = getToken();
obj->setLineNumber(tok.getLineNumber());
obj->setColumnNumber(tok.getColumnNumber());
return obj;
}
if(peekToken().getType() == T_UNSIGNEDINT)
return new Integer(getToken());
if(peekToken().getType() == T_UNSIGNEDREAL)
return new Real(getToken());
if(peekToken().getType() == T_YES || peekToken().getType() == T_NO)
return new Logical(getToken());
if(peekToken().getType() == T_STRING)
return new Text(getToken());
if(peekToken().getType() == T_IDENTIFIER)
return new Variable(getToken());
return 0;
}
/*** Parse an assign statement ***/
Assign* Parser::parseAssign()
{
if(!hasTokens() || peekToken().getType() != T_IDENTIFIER)
throw ParserSyntaxException(getToken(), "Expected variable identifier!");
std::auto_ptr<Variable> target(new Variable(getToken().getLexeme()));
if(!hasTokens() || peekToken().getType() != T_ASSIGN)
throw ParserSyntaxException(getToken(), "Expected ':='!");
Token tok = getToken();
std::auto_ptr<Object> expr(parseExpression());
Assign* as = new Assign(target.release(), expr.release());
as->setLineNumber(tok.getLineNumber());
as->setColumnNumber(tok.getColumnNumber());
return as;
}
bool KAbstractObjParserPrivate::parseIndex(index_type &i)
{
if (peekToken().m_token == PT_INTEGER)
{
i = static_cast<uint64_t>(nextToken().m_attribute.asInteger);
return true;
}
return false;
}
Object* Parser::parseSubExpression7()
{
std::auto_ptr<Object> expr1(parseSubExpression6());
while(hasTokens() && (peekToken().getType() == T_SLASHEQ || peekToken().getType() == T_EQUAL))
{
Token tok = getToken();
std::auto_ptr<Object> expr2(parseSubExpression6());
if(tok.getType() == T_SLASHEQ)
expr1.reset(new Unequal(expr1.release(), expr2.release()));
else
expr1.reset(new Equal(expr1.release(), expr2.release()));
expr1->setLineNumber(tok.getLineNumber());
expr1->setColumnNumber(tok.getColumnNumber());
}
return expr1.release();
}
CAssemblerCommand* Parser::handleError()
{
// skip the rest of the line
const Token& token = nextToken();
while (peekToken().line == token.line)
eatToken();
clearError();
return new InvalidCommand();
}
Object* Parser::parseSubExpression5()
{
std::auto_ptr<Object> expr1(parseSubExpression4());
while(hasTokens() && (peekToken().getType() == T_PLUS || peekToken().getType() == T_MINUS))
{
Token tok = getToken();
unsigned char operation = tok.getType();
std::auto_ptr<Object> expr2(parseSubExpression4());
if(operation == T_PLUS)
expr1.reset(new Add(expr1.release(), expr2.release()));
else
expr1.reset(new Subtract(expr1.release(), expr2.release()));
expr1->setLineNumber(tok.getLineNumber());
expr1->setColumnNumber(tok.getColumnNumber());
}
return expr1.release();
}
/*** Parse an end statement ***/
End* Parser::parseEnd()
{
if(!hasTokens() || peekToken().getType() != T_END)
throw ParserSyntaxException(getToken(), "Expected \"end\" command!");
Token tok = getToken();
End* en = new End();
en->setLineNumber(tok.getLineNumber());
en->setColumnNumber(tok.getColumnNumber());
return en;
}
/*** Parse an exit statement ***/
Exit* Parser::parseExit()
{
if(!hasTokens() || peekToken().getType() != T_EXIT)
ParserSyntaxException(getToken(), "Expected \"exit\" command!");
Token tok = getToken();
Exit* ex = new Exit();
ex->setLineNumber(tok.getLineNumber());
ex->setColumnNumber(tok.getColumnNumber());
return ex;
}
// See if the next non-white-space tokens are two consecutive #
bool TPpContext::TokenStream::peekUntokenizedPasting()
{
// don't return early, have to restore this
size_t savePos = currentPos;
// skip white-space
while (peekToken(' '))
++currentPos;
// check for ##
bool pasting = false;
if (peekToken('#')) {
++currentPos;
if (peekToken('#'))
pasting = true;
}
currentPos = savePos;
return pasting;
}
bool Parser::matchToken(TokenType type, bool optional)
{
if (optional)
{
const Token& token = peekToken();
if (token.type == type)
eatToken();
return true;
}
return nextToken().type == type;
}
/**
* Parse a list element, identified by the given name.
*/
ListElement *parseListElement(String const &name)
{
if(peekToken() != "<")
{
throw SyntaxError("Info::parseListElement",
QString("List must begin with a '<', but '%1' found instead (on line %2).")
.arg(peekToken()).arg(currentLine));
}
QScopedPointer<ListElement> element(new ListElement(name));
/// List syntax:
/// list ::= list-identifier '<' [value {',' value}] '>'
/// list-identifier ::= token
// Move past the opening angle bracket.
nextToken();
forever
{
element->add(parseValue());
// List elements are separated explicitly.
String separator = peekToken();
nextToken();
// The closing bracket?
if(separator == ">") break;
// There should be a comma here.
if(separator != ",")
{
throw SyntaxError("Info::parseListElement",
QString("List values must be separated with a comma, but '%1' found instead (on line %2).")
.arg(separator).arg(currentLine));
}
}
return element.take();
}
Object* Parser::parseSubExpression6()
{
std::auto_ptr<Object> expr1(parseSubExpression5());
while(hasTokens() && (peekToken().getType() == T_LESS || peekToken().getType() == T_GREAT || peekToken().getType() == T_LESSEQ || peekToken().getType() == T_GREATEQ))
{
Token tok = getToken();
unsigned char operation = tok.getType();
std::auto_ptr<Object> expr2(parseSubExpression5());
if(operation == T_LESS)
expr1.reset(new Less(expr1.release(), expr2.release()));
else if(operation == T_GREAT)
expr1.reset(new Greater(expr1.release(), expr2.release()));
else if(operation == T_LESSEQ)
expr1.reset(new LessEq(expr1.release(), expr2.release()));
else
expr1.reset(new GreatEq(expr1.release(), expr2.release()));
expr1->setLineNumber(tok.getLineNumber());
expr1->setColumnNumber(tok.getColumnNumber());
}
return expr1.release();
}
Object* Parser::parseSubExpression4()
{
std::auto_ptr<Object> expr1(parseSubExpression3());
while(hasTokens() && (peekToken().getType() == T_MULTIPLY || peekToken().getType() == T_DIVIDE || peekToken().getType() == T_INTDIVIDE || peekToken().getType() == T_REMAINDER))
{
Token tok = getToken();
unsigned char operation = tok.getType();
std::auto_ptr<Object> expr2(parseSubExpression3());
if(operation == T_MULTIPLY)
expr1.reset(new Multiply(expr1.release(), expr2.release()));
else if(operation == T_DIVIDE)
expr1.reset(new Divide(expr1.release(), expr2.release()));
else if(operation == T_INTDIVIDE)
expr1.reset(new IntDivide(expr1.release(), expr2.release()));
else
expr1.reset(new Remainder(expr1.release(), expr2.release()));
expr1->setLineNumber(tok.getLineNumber());
expr1->setColumnNumber(tok.getColumnNumber());
}
return expr1.release();
}
bool KAbstractObjParserPrivate::parseFloat(float &f)
{
switch (peekToken().m_token)
{
case PT_FLOAT:
f = nextToken().m_attribute.asFloat;
break;
case PT_INTEGER:
f = static_cast<float>(nextToken().m_attribute.asInteger);
break;
default:
return false;
}
return true;
}
void parseMultiCmd(const char **strptr)
{
parseCmd(strptr);
Token nextToken = peekToken(*strptr);
switch (nextToken) {
case IDENTIFIER:
parseMultiCmd(strptr);
break;
case END:
break;
default:
PARSE_ASSERT(0);
}
}
