void Parser::parseBlockBody() {
Token t = lex.peek();
if (t.type == Token::LBRACE) {
lex.consume(Token::LBRACE);
parseStatements();
lex.consume(Token::RBRACE);
} else {
switch (t.type) {
case Token::FLOAT:
case Token::STRING:
case Token::COLOR:
case Token::POINT:
case Token::VECTOR:
case Token::NORMAL:
case Token::MATRIX:
case Token::UNIFORM:
case Token::VARYING:
parseVariableDecl();
break;
case Token::IDENTIFIER:
if (lex.peek(2).type == Token::LPAREN)
parseCallStmt();
else
parseAssignmentStmt();
break;
case Token::SEMI:
lex.consume(Token::SEMI);
break;
case Token::IF:
parseIfStmt();
break;
case Token::FOR:
parseForLoop();
break;
case Token::WHILE:
parseWhileLoop();
break;
case Token::SOLAR:
parseSolarLoop();
break;
case Token::ILLUMINATE:
parseIlluminateLoop();
break;
case Token::ILLUMINANCE:
parseIlluminanceLoop();
break;
case Token::BREAK:
parseBreakStmt();
break;
case Token::CONTINUE:
parseContinueStmt();
break;
case Token::RETURN:
parseReturnStmt();
break;
default:
assert(0 && "Expected a statement!");
}
}
}
static PSmmAstNode parseStatement(PSmmParser parser) {
switch (parser->curToken->kind) {
case tkSmmReturn:
return parseReturnStmt(parser);
case '{':
return (PSmmAstNode)parseBlock(parser, parser->curScope->returnType, false);
case tkSmmIdent: case '(': case '-': case '+': case tkSmmNot:
case tkSmmInt: case tkSmmFloat: case tkSmmBool:
return parseExpressionStmt(parser);
case tkSmmIf: case tkSmmWhile: return parseIfWhileStmt(parser);
case tkSmmErr:
if (findToken(parser, ';')) getNextToken(parser);
return NULL;
case ';':
return NULL; // Just skip empty statements
default:
if (parser->lastErrorLine != parser->curToken->filePos.lineNumber) {
char gotBuf[4];
const char* got = smmTokenToString(parser->curToken, gotBuf);
smmPostMessage(parser->msgs, errSmmGotUnexpectedToken, parser->curToken->filePos, "valid statement", got);
}
getNextToken(parser); // Skip the bad character
if (findToken(parser, ';')) getNextToken(parser);
return &errorNode;
}
}
/***************************************************************
* Function: CodeParser::parseStatement()
* Purpose : Parse the XML code of a statement
* Initial : Maxime Chevalier-Boisvert on November 5, 2008
****************************************************************
Revisions and bug fixes:
*/
Statement* CodeParser::parseStatement(const XML::Element* pElement)
{
// If this is an expression statement
if (pElement->getName() == "ExprStmt")
{
// Parse the expression statement
return parseExprStmt(pElement);
}
// If this is an assignment statement
else if (pElement->getName() == "AssignStmt")
{
// Parse the assignment statement
return parseAssignStmt(pElement);
}
// If this is an if-else statement
else if (pElement->getName() == "IfStmt")
{
// Parse the if-else statement
return parseIfStmt(pElement);
}
// If this is a switch statement
else if (pElement->getName() == "SwitchStmt")
{
// Parse the switch statement
return parseSwitchStmt(pElement);
}
// If this is a for loop statement
else if (pElement->getName() == "ForStmt")
{
// Parse the for loop statement
return parseForStmt(pElement);
}
// If this is a while loop statement
else if (pElement->getName() == "WhileStmt")
{
// Parse the while loop statement
return parseWhileStmt(pElement);
}
// If this a break statement
else if (pElement->getName() == "BreakStmt")
{
// Create and return a break statement object
return new BreakStmt();
}
// If this a continue statement
else if (pElement->getName() == "ContinueStmt")
{
// Create and return a continue statement object
return new ContinueStmt();
}
// If this a return statement
else if (pElement->getName() == "ReturnStmt")
{
// Parse the return statement
return parseReturnStmt(pElement);
}
// Otherwise
else
{
// This is an invalid statement type, throw an exception
throw XML::ParseError("Invalid statement type: \"" + pElement->getName() + "\"", pElement->getTextPos());
}
}
