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!");
}
}
}
/* parser */
Program parser( FILE *source )
{
Program program;
program.declarations = parseDeclarations(source);
program.statements = parseStatements(source);
return program;
}
llvm::ArrayRef<StatementPtr> desugarEvalStatement(EvalStatementPtr eval, EnvPtr env)
{
if (eval->evaled)
return eval->value;
else {
SourcePtr source = evalToSource(eval->location, eval->args, env);
parseStatements(source, 0, unsigned(source->size()), eval->value);
eval->evaled = true;
return eval->value;
}
}
ASTNode* parse(MemoryStack* stack, Array<SyntaxError>* errors, char* program)
{
LexerCarriage mainCarriage = initCarriage(program);
ASTNode* result = pushMemory<ASTNode>(stack);
result->nodeType = AST_MAIN;
result->main.statements = { };
parseStatements(stack, &mainCarriage, errors, &result->main.statements);
expectAndEat(&mainCarriage, TOK_EOF, errors);
return result;
}
std::unique_ptr<FunctionAST> Parser::parseFunction (std::shared_ptr<PrototypeAST> prototype) {
/*std::vector<std::unique_ptr<StmtAST>> items;
while (lexer->currentToken != tok_end) {
auto stmt = parseStmt();
items.push_back (stmt);
lexer->getNextToken();
}*/
auto body = parseStatements();
return std::make_unique<FunctionAST>(std::move(body), prototype);
}
void Parser::parseShaderDefinition() {
// Consume the shader type
// NOTE: We've already checked in the caller
// that this is the correct token type, so no need to check
Token shaderType = lex.consume();
// Consume the shader's name
Token shaderName = lex.consume(Token::IDENTIFIER);
// Formal arguments
lex.consume(Token::LPAREN);
parseFormals();
lex.consume(Token::RPAREN);
// Shader body
lex.consume(Token::LBRACE);
parseStatements();
lex.consume(Token::RBRACE);
}
Statements *parseStatements( FILE * source )
{
Token token = scanner(source);
Statement stmt;
Statements *stmts;
switch(token.type){
case Alphabet:
case PrintOp:
stmt = parseStatement(source, token);
stmts = parseStatements(source);
return makeStatementTree(stmt , stmts);
case EOFsymbol:
return NULL;
default:
printf("Syntax Error: Expect statements %s\n", token.tok);
exit(1);
}
}
int main (int argc, char *argv[]) {
FILE *source, *dest;
pair currentPosition;
int numLines, i;
source = sourceIO(argc, argv); // set the source using the correct filepath
dest = destIO(argc, argv); // set the destination filepath
numLines = lineCount(source); // get the number of lines in the source file
source = sourceIO(argc, argv); // resource the input stream;
statement statements[numLines];
parseStatements(source, statements);
fprintf(dest, "# MIPS program automatically generated\n# from PostScript commands in the file %s\n", argv[1]);
fprintf(dest, DATA_SEGMENT);
fprintf(dest, WARN_BEGIN);
fprintf(dest, "main:");
// code generation takes place
for (i = 0; i <= numLines; i++) {
printf("Building move for line %d, %u(%d, %d)\n", i, statements[i].identity, statements[i].pair.x, statements[i].pair.y);
currentPosition = generateNextMove(dest, statements[i], currentPosition);
}
fprintf(dest, "\t\t\tli\t\t$v0,10\n\t\t\tsyscall\n");
fprintf(dest, WARN_END);
// add the horiz and vert methods
fprintf(dest, METHOD_SEGMENT);
// add the diag method
fprintf(dest, DIAG_SEGMENT);
// clean up
fclose(source);
fclose(dest);
}
void parseFile(const QString &p_fileName,
const Soprano::RdfSerialization &p_fileType)
{
parseFileToStatements(p_fileName, p_fileType);
parseStatements();
}
static bool parseStatement(MemoryStack* stack, LexerCarriage* carriage, Array<SyntaxError>* errors, ASTNode* result)
{
if (parseVariableDefinition(stack, carriage, errors, result)) return true;
if (parseFunctionCall(stack, carriage, errors, result)) return true;
if (parseAssignment(stack, carriage, errors, result)) return true;
if (carriage->topToken.type == TOK_IDENTIFIER)
{
Token identifier = carriage->topToken;
parseNextToken(carriage);
if (carriage->topToken.type == TOK_DOUBLE_DOT)
{
parseNextToken(carriage);
if (carriage->topToken.type == TOK_OPEN_BRACKET) // function definition
{
parseNextToken(carriage);
result->nodeType = AST_STATEMENT_FUNCTION_DEFINITION;
result->functionDefinition.lineNumber = carriage->currentLineNumber;
result->functionDefinition.identifier = identifier.identifierValue;
ASTNode arg;
LinkedList<ASTNode> args = {};
if (carriage->topToken.type != TOK_CLOSE_BRACKET)
{
while (true)
{
if (parseVariableDefinition(stack, carriage, errors, &arg))
{
*pushElement(&args, stack) = arg;
if (carriage->topToken.type != TOK_COMMA)
break;
else
parseNextToken(carriage); // pop ,
}
else
{
pushBack(errors, SyntaxError{ SET_EXPRESSION_EXPECTED });
break;
}
};
}
expectAndEat(carriage, TOK_CLOSE_BRACKET, errors);
result->functionDefinition.arguments = args;
if (carriage->topToken.type != TOK_VOID)
{
result->functionDefinition.returnType = pushMemory<ASTNode>(stack);
if (!parseTypeIdentifier(stack, carriage, errors, result->functionDefinition.returnType))
{
// TODO: change this
SyntaxError error = SyntaxError{ SET_UNEXPECTED_TOKEN };
error.unexpectedToken.token = carriage->topToken;
error.unexpectedToken.expecting = TOK_IDENTIFIER;
pushBack(errors, error);
}
}
else
{
parseNextToken(carriage);
result->functionDefinition.returnType = nullptr;
}
result->functionDefinition.body = nullptr;
if (carriage->topToken.type == TOK_ASSIGN)
{
parseNextToken(carriage);
result->functionDefinition.body = pushMemory<ASTNode>(stack);
expectAndEatStatement(stack, carriage, errors, result->functionDefinition.body);
}
return true;
}
else if (carriage->topToken.type == TOK_STRUCT)
{
parseNextToken(carriage);
expectAndEat(carriage, TOK_ASSIGN, errors);
int bracesOpenedAt = carriage->currentLineNumber;
expectAndEat(carriage, TOK_OPEN_BRACES, errors);
result->nodeType = AST_STATEMENT_TYPE_DEFINITION;
result->typeDefinition.lineNumber = carriage->currentLineNumber;
result->typeDefinition.identifier = identifier.identifierValue;
result->typeDefinition.definitions = {};
ASTNode definition;
do
{
if (parseVariableDefinition(stack, carriage, errors, &definition))
*pushElement(&result->typeDefinition.definitions, stack) = definition;
else
break;
} while (true);
if (carriage->topToken.type == TOK_CLOSE_BRACES)
parseNextToken(carriage);
else
{
SyntaxError error = { SET_UNCLOSED_BRACKETS, bracesOpenedAt };
error.unclosedBrackets.closedAt = carriage->currentLineNumber;
error.unclosedBrackets.token = carriage->topToken;
pushBack(errors, error);
}
return true;
}
else
{
// TODO: error
}
}
else
{
// TODO: error
}
}
else if (carriage->topToken.type == TOK_OPEN_BRACES)
{
int openedAt = carriage->currentLineNumber;
parseNextToken(carriage);
result->nodeType = AST_STATEMENTS_BLOCK;
result->statementsBlock.statements = { };
parseStatements(stack, carriage, errors, &result->statementsBlock.statements);
if (carriage->topToken.type == TOK_CLOSE_BRACES)
parseNextToken(carriage);
else
{
SyntaxError error = SyntaxError{ SET_UNCLOSED_BRACKETS, openedAt };
error.unclosedBrackets.closedAt = carriage->currentLineNumber;
error.unclosedBrackets.token = carriage->topToken;
pushBack(errors, error);
}
return true;
}
else if (carriage->topToken.type == TOK_IF)
{
parseNextToken(carriage);
result->nodeType = AST_STATEMENT_IF;
result->ifStatement.condition = pushMemory<ASTNode>(stack);
result->ifStatement.ifCase = pushMemory<ASTNode>(stack);
expectAndEatExpression(stack, carriage, errors, result->ifStatement.condition);
expectAndEatStatement(stack, carriage, errors, result->ifStatement.ifCase);
if (carriage->topToken.type == TOK_ELSE)
{
parseNextToken(carriage);
result->ifStatement.elseCase = pushMemory<ASTNode>(stack);
expectAndEatStatement(stack, carriage, errors, result->ifStatement.elseCase);
}
else
result->ifStatement.elseCase = nullptr;
return true;
}
else if (carriage->topToken.type == TOK_WHILE)
{
parseNextToken(carriage);
result->nodeType = AST_STATEMENT_WHILE;
result->whileStatement.condition = pushMemory<ASTNode>(stack);
result->whileStatement.body = pushMemory<ASTNode>(stack);
expectAndEatExpression(stack, carriage, errors, result->whileStatement.condition);
expectAndEatStatement(stack, carriage, errors, result->whileStatement.body);
return true;
}
return false;
}
