/* ParsePrecedence() - parse a precedence declaration.
*
* %{left|right|nonassoc} (ident literal?)+
*/
static
void ParsePrecedence(TToken Direction)
{
static int Precedence = 1; /* precedence 0 reserved for $, so start at 1 */
int Associativity = Direction.Type;
int OperatorCount = 0;
TToken Token;
for(;;)
{
Token = InputGetNext();
if(Token.Type == TK_EOF)
SyntaxError(ERROR_EOF_IN_PREC, Token,
"Unexpected EOF encountered while processing precedence directive.\n");
else if(Token.Type == TK_NEWLINE)
break;
else if(Token.Type == TK_OPERATOR)
{
ParseOperator(Precedence, Associativity, Token, 'X');
++OperatorCount;
}
/* can't really happen, but defensive programming */
else
SyntaxError(ERROR_EXPECTING_OPERATOR_DECL, Token,
"Illegal token; expecting an operator declaration.\n");
}
if(OperatorCount == 0)
SyntaxError(ERROR_PREC_WITHOUT_OPERATORS, Direction,
"Precedence directive line contained no operators!\n");
++Precedence;
}
AST* ParseOperatorList(ParserState* parser) {
AST *operators = CreateASTNode(SEM_EMPTY, VALUE_EMPTY);
while(parser->currentToken.type != TOKEN_END) {
AST *op = ParseOperator(parser);
AddASTChild(operators, op);
}
return operators;
}
AST* ParseIfStatement(ParserState* parser) {
Match(parser, TOKEN_IF);
AST* ifNode = CreateASTNode(SEM_IF_STATEMENT, VALUE_EMPTY);
AST* condition = ParseCondition(parser);
Match(parser, TOKEN_THEN);
AST* thenOp = ParseOperator(parser);
AddASTChild(ifNode, condition);
AddASTChild(ifNode, thenOp);
if(parser->currentToken.type == TOKEN_ELSE) {
Match(parser, TOKEN_ELSE);
AST* elseOp = ParseOperator(parser);
AddASTChild(ifNode, elseOp);
}
return ifNode;
}
AST* ParseWhileCycle(ParserState* parser) {
Match(parser, TOKEN_WHILE);
AST* whileNode = CreateASTNode(SEM_WHILE_CYCLE, VALUE_EMPTY);
AST* condition = ParseCondition(parser);
Match(parser, TOKEN_DO);
AST* op = ParseOperator(parser);
AddASTChild(whileNode, condition);
AddASTChild(whileNode, op);
return whileNode;
}
bool Scanner::GetToken(Token *token)
{
if ((token == NULL))
{
return false;
}
Skip();
if (ParseDigit(token))
return true;
if (ParseToken(token))
return true;
if (ParseOperator(token))
return true;
return false;
}
static std::vector<Statement*> ParseStatements(const String& input, bool allowSpaces = false)
{
String string = input;
// Remove spaces since they should be ignored (i.e. variables should not be split)
if (allowSpaces)
string.erase(std::remove(string.begin(), string.end(), ' '), string.end());
string += ";";
Tokenizer tokenizer;
tokenizer.AddEndChars(";");
tokenizer.AddOperatorChars("<=>&|\\/");
tokenizer.AddWhitespaceChars(" \n\r\t");
tokenizer.SetString(string);
Token* lastToken = nullptr;
Token token;
Statement* statement = nullptr;
std::vector<Statement*> statements;
while (tokenizer.Next(token))
{
if (lastToken == nullptr || lastToken->type == Token::Type::END_STATEMENT)
{
statement = new Statement();
statements.push_back(statement);
}
lastToken = &token;
switch (token.type)
{
case Token::Type::IDENTIFIER:
statement->identifiers.push_back(token.token);
break;
case Token::Type::OPERATOR:
statement->operators.push_back(ParseOperator(token.token));
break;
}
}
return statements;
}
