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; }