#include "parser.h" #include "util.h" #include #include "symbol.h" #include "error_log.h" Token_stream::Token_stream(const std::vector& tokens) : tokens(tokens) { // Invalid token will representively live at EOF invalid_token.type = Token_t::INVALID; if (!empty()) { invalid_token.pos = tokens.back().pos; invalid_token.pos.colno += 1; } } const Token* Token_stream::peek() const { if (empty()) return &invalid_token; return &tokens[index]; } const Token* Token_stream::peek(index_t depth) const { uint64_t i = index + depth; if (i >= tokens.size()) return &invalid_token; return &tokens[i]; } const Token* Token_stream::pop() { const Token* t = peek(); if (t->type != Token_t::INVALID) ++index; return t; } void Token_stream::expect(Token_t token_type) { const Token* t = peek(); if (t->type != token_type) { bey_error(Error_t::EXPECTED_TOKEN, t->pos, token_type); } // Continue making progress pop(); } bool Parser::parse_next_file(Token_stream& ts, Symbol_table* scope, String_buffer& string_buffer, String_handle filename) { AST::File* file = new AST::File(ts.peek()->pos, filename); file->file_scope = Symbol_table::create_table(scope); // Parse import statements while (ts.peek(0)->type == Token_t::IMPORT && ts.peek(1)->type == Token_t::STRING_LIT) { ts.pop(); const Token* source_file_token = ts.pop(); String_handle relative_path = source_file_token->_string; String_handle absolute_path = get_absolute_path(relative_path, string_buffer); file->imports.push_back(absolute_path); ts.expect((Token_t) ';'); } // Top level decls AST::Top_level *head = nullptr; AST::Top_level *p = nullptr; while (!ts.empty()) { Position pos = ts.peek()->pos; AST::Top_level* tl = try_parse_top_level(ts, file->file_scope); if (tl == nullptr) { bey_error(Error_t::EXPECTED_DECLARATION, pos); break; } insert_into_linked_list(&head, &p, tl); } file->contents = head; insert_into_linked_list(&head_file, ¤t_file, file); // Parsing is only successful if we had no errors. return bey_error_count == 0; } AST::Top_level* Parser::try_parse_top_level(Token_stream& ts, Symbol_table* scope) { // VarDecl = Identifier ':' (Type ['=' Expression] | '=' Expression) if (ts.peek(0)->type == Token_t::IDENTIFIER && ts.peek(1)->type == (Token_t) ':' && (ts.peek(2)->type == (Token_t) '=' || get_type_kind(ts, 2) != std::nullopt)) { AST::Top_level* tl = create_top_level(ts.peek()->pos, AST::Top_level_t::VAR_DECL); tl->_var = parse_var_decl(ts, scope, Var_decl_flags::REQUIRE_EXPLICIT_TYPE); return tl; } // FuncDecl = Identifier ':' '(' ParameterList ')' if (ts.peek(0)->type == Token_t::IDENTIFIER && ts.peek(1)->type == (Token_t) ':' && (ts.peek(2)->type == (Token_t) '(')) { AST::Top_level* tl = create_top_level(ts.peek()->pos, AST::Top_level_t::FUNC_DECL); tl->_func = parse_func_decl(ts, scope); return tl; } // TypeDecl = 'type' Identifier ':' '=' Type if (ts.peek(0)->type == Token_t::TYPE && ts.peek(1)->type == Token_t::IDENTIFIER && ts.peek(2)->type == (Token_t) ':' && ts.peek(3)->type == (Token_t) '=' && get_type_kind(ts, 4) != std::nullopt) { AST::Top_level* tl = create_top_level(ts.peek()->pos, AST::Top_level_t::TYPE_DECL); tl->_type_decl = parse_type_decl(ts, scope); return tl; } return nullptr; } // @Cleanup: This is going to need to be cleaned up in some way... // atm the syntax of a variable declaration is super tightly coupled throughout the parser. We should have // some kind of look-ahead function to 'peek' ahead and see if we are dealing with a valid variable // declaration (sort of like get_type_kind). AST::Var_decl* Parser::parse_var_decl(Token_stream& ts, Symbol_table* scope, int flags /* = 0*/) { AST::Var_decl* node = create_var_decl(ts.peek()->pos); AST::Type* type = nullptr; AST::Exp* value = nullptr; AST::Ident* identifier = parse_ident(ts); ts.expect((Token_t) ':'); // If our variable decl looks either like: // 1) : = ... // 2) : // * (AND NOT: : = ...) // Then we need to try and parse if (ts.peek()->type != (Token_t) '=' || (flags & Var_decl_flags::REQUIRE_EXPLICIT_TYPE) != 0) { type = try_parse_type(ts, scope); if (type == nullptr) { // error : expecting type const Token* t = ts.peek(); bey_error(Error_t::EXPECTED_TYPE, t->pos); // TODO: May need to pop off n number of tokens // to continue parsing cleanly. Currently unsure // on how n would be computed. } } const Token* t; if ((t = ts.peek())->type == (Token_t) '=') { ts.pop(); if ((flags & Var_decl_flags::DISALLOW_ASSIGNMENT_EXPRESSION) != 0) { bey_error(Error_t::UNEXPECTED_ASSIGNMENT_EXPRESSION, t->pos); } if ((flags & Var_decl_flags::DO_NOT_PARSE_ASSIGNMENT_EXPRESSION) == 0) { value = parse_not_null_exp(ts); } } if ((flags & Var_decl_flags::DO_NOT_PARSE_SEMI_COLON) == 0) { ts.expect((Token_t) ';'); } node->type = type; node->var_name = identifier; node->value = value; return node; } AST::Func_decl* Parser::parse_func_decl(Token_stream& ts, Symbol_table* scope) { AST::Func_decl* node = create_func_decl(ts.peek()->pos); node->func_name = parse_ident(ts); ts.expect((Token_t) ':'); node->param_list = parse_func_param_list(ts, scope); AST::Type* return_type = try_parse_type(ts, scope); node->return_type = return_type ? return_type : &AST::predeclared_types::_void; // #37: If a ending semi-colon was not injected, // this consitutes a parsing error. { const Token* t = ts.peek(); if (t->type == (Token_t) ';' && ts.pop() && (t->flags & Token_flags::INJECTED) == 0) { bey_error(Error_t::EXPECTED_STATEMENT_OR_STATEMENT_BLOCK, t->pos); } } // Functions need a statement block. node->body = parse_stmt_block(ts, scope); return node; } AST::Var_decl* Parser::parse_func_param_list(Token_stream& ts, Symbol_table* scope) { ts.expect((Token_t) '('); AST::Var_decl *head = nullptr; AST::Var_decl *p = nullptr; // Loop until we see a ')' token or we run // out of tokens. const Token* t; while ((t = ts.peek())->type != (Token_t) ')' && t->type != Token_t::INVALID) { AST::Var_decl* param = parse_var_decl(ts, scope, Var_decl_flags::REQUIRE_EXPLICIT_TYPE | Var_decl_flags::DISALLOW_ASSIGNMENT_EXPRESSION | Var_decl_flags::DO_NOT_PARSE_SEMI_COLON ); insert_into_linked_list(&head, &p, param); // If the next up token is not ')', then we should expect a ',' if (ts.peek()->type != (Token_t) ')') { ts.expect((Token_t) ','); const Token* t = ts.peek(); if (t->type == (Token_t) ')') { bey_error(Error_t::EXPECTED_PARAMETER_DECLARATOR, t->pos); } } } ts.expect((Token_t) ')'); return head; } AST::Type_decl* Parser::parse_type_decl(Token_stream& ts, Symbol_table* scope) { AST::Type_decl* type_decl = create_type_decl(ts.peek()->pos); ts.expect(Token_t::TYPE); type_decl->type_name = parse_ident(ts); ts.expect((Token_t) ':'); ts.expect((Token_t) '='); type_decl->type = try_parse_type(ts, scope); ts.expect((Token_t) ';'); return type_decl; } AST::Stmt* Parser::parse_stmt(Token_stream& ts, Symbol_table* scope, bool stop_on_scope_close /* = false */) { using namespace AST; Stmt* head = nullptr; Stmt* p = nullptr; bool stop_parsing = false; const Token *t, *nt; BEGIN_IGNORE_SWITCH_DIRECTIVE; while((t = ts.peek())->type != (Token_t)'}' && t->type != Token_t::INVALID && !stop_parsing) { Stmt* simple_stmt = nullptr; nt = ts.peek(1); if (t->type == Token_t::IF) { ts.pop(); Stmt* if_stmt = create_stmt(t->pos, Stmt_t::IF); if_stmt->_conditional.condition = parse_not_null_exp(ts); if_stmt->_conditional.body = parse_stmt_block(ts, scope); insert_into_linked_list(&head, &p, if_stmt); // Elif while ((t = ts.peek())->type == Token_t::ELIF) { ts.pop(); Stmt* elif_stmt = create_stmt(t->pos, Stmt_t::ELIF); elif_stmt->_conditional.condition = parse_not_null_exp(ts); elif_stmt->_conditional.body = parse_stmt_block(ts, scope); insert_into_linked_list(&head, &p, elif_stmt); } // Else if ((t = ts.peek())->type == Token_t::ELSE) { ts.pop(); Stmt* else_stmt = create_stmt(t->pos, Stmt_t::ELSE); else_stmt->_conditional.body = parse_stmt_block(ts, scope); insert_into_linked_list(&head, &p, else_stmt); } } else if (t->type == Token_t::RETURN) { ts.pop(); Stmt* stmt = create_stmt(t->pos, Stmt_t::RETURN); stmt->_unary_exp = parse_exp(ts); ts.expect((Token_t) ';'); insert_into_linked_list(&head, &p, stmt); } else if (t->type == Token_t::BREAK) { ts.pop(); Stmt* stmt = create_stmt(t->pos, Stmt_t::BREAK); ts.expect((Token_t) ';'); insert_into_linked_list(&head, &p, stmt); } else if(t->type == Token_t::CONTINUE) { ts.pop(); Stmt* stmt = create_stmt(t->pos, Stmt_t::CONTINUE); ts.expect((Token_t) ';'); insert_into_linked_list(&head, &p, stmt); } else if (t->type == Token_t::FOR) { Stmt* for_stmt = parse_for_stmt(ts, scope); insert_into_linked_list(&head, &p, for_stmt); } else if (t->type == Token_t::IDENTIFIER && nt->type == (Token_t) ':') { Stmt* stmt = create_stmt(t->pos, Stmt_t::VAR_DECl); stmt->_var_decl = parse_var_decl(ts, scope, Var_decl_flags::DO_NOT_PARSE_SEMI_COLON); ts.expect((Token_t) ';'); insert_into_linked_list(&head, &p, stmt); } else if (t->type == Token_t::TYPE) { Stmt* stmt = create_stmt(t->pos, Stmt_t::TYPE_DECL); stmt->_type_decl = parse_type_decl(ts, scope); insert_into_linked_list(&head, &p, stmt); } else if ((simple_stmt = try_parse_simple_stmt(ts))) { ts.expect((Token_t) ';'); insert_into_linked_list(&head, &p, simple_stmt); } else if (t->type == (Token_t) '{') { ts.pop(); Stmt* stmt = create_stmt(t->pos, Stmt_t::BLOCK); stmt->_block.scope = Symbol_table::create_table(scope); stmt->_block.list = parse_stmt(ts, stmt->_block.scope); ts.expect((Token_t) '}'); if (ts.peek()->type == (Token_t) ';') ts.pop(); insert_into_linked_list(&head, &p, stmt); // @NOTE : this switch will typically only be turned on when // calling through Parser::parse_stmt_block, since we want parsing // to return back to the calling code once we detect end of scope. // // The exception is ofc for (anonymous?) scopes. if (stop_on_scope_close) { stop_parsing = true; } } // We have encountered a token we did not expect // for in this context... we will need to stop parsing // and throw an error. else { std::stringstream s; bey_error(Error_t::EXPECTED_VALID_STATEMENT_TOKEN, t->pos, t->type); // Pop the token off. ts.pop(); stop_parsing = true; } } END_IGNORE_SWITCH_DIRECTIVE; return head; } AST::Stmt* Parser::parse_for_stmt(Token_stream& ts, Symbol_table* scope) { using namespace AST; const Token* t = ts.pop(); bool expect_closing_paren = false; Position opening_paren_pos; if (ts.peek()->type == (Token_t) '(') { expect_closing_paren = true; opening_paren_pos = ts.pop()->pos; } Stmt* for_stmt = nullptr; Stmt** for_stmt_body = nullptr; // Range for / vanilla for if (ts.peek(0)->type == Token_t::IDENTIFIER && ts.peek(1)->type == (Token_t) ':') { // Parse a var decl up-to (& including) the '=' token. Var_decl* stmt = parse_var_decl(ts, scope, Var_decl_flags::DO_NOT_PARSE_SEMI_COLON | Var_decl_flags::DO_NOT_PARSE_ASSIGNMENT_EXPRESSION ); /* Range for: for elem := range elems { ... } */ if (ts.peek()->type == Token_t::RANGE) { const Token* exp_token = ts.pop(); for_stmt = create_stmt(t->pos, Stmt_t::RANGE_FOR); Exp* exp = create_exp(exp_token->pos, Exp_t::RANGE); exp->_unary = parse_not_null_exp(ts); stmt->value = exp; for_stmt->_range_for.init = stmt; for_stmt_body = &(for_stmt->_range_for.body); } /* Vanilla for: for i := 0; i < 10; ++i { ... } */ else { for_stmt = create_stmt(t->pos, Stmt_t::VANILLA_FOR); stmt->value = parse_not_null_exp(ts); for_stmt->_vanilla_for.init = stmt; ts.expect((Token_t) ';'); for_stmt->_vanilla_for.condition = parse_not_null_exp(ts); ts.expect((Token_t) ';'); // #58: Vanilla for statements require non-null post statements Position pos = ts.peek()->pos; if ((for_stmt->_vanilla_for.post = try_parse_simple_stmt(ts)) == nullptr) { bey_error(Error_t::EXPECTED_VALID_POST_CONDITION, pos); } for_stmt_body = &(for_stmt->_vanilla_for.body); } } /* Conditional for: for a < 10 { ... } */ else { for_stmt = create_stmt(t->pos, Stmt_t::CONDITIONAL_FOR); for_stmt->_conditional.condition = parse_not_null_exp(ts); for_stmt_body = &(for_stmt->_conditional.body); } // match closing parenthesis if needed if (ts.peek()->type == (Token_t) ')' && (t = ts.pop())) { if (!expect_closing_paren) { bey_error(Error_t::UNEXPECTED_ENCLOSING_R_PAREN, t->pos); } } else if(expect_closing_paren) { bey_error(Error_t::EXPECTED_ENCLOSING_R_PAREN, opening_paren_pos); } // Finally, parse the statement body (*for_stmt_body) = parse_stmt_block(ts, scope); return for_stmt; } AST::Stmt* Parser::try_parse_simple_stmt(Token_stream& ts) { using namespace AST; const Token* t = ts.peek(); Exp* exp; if (t->type == Token_t::INCREMENT) { ts.pop(); Stmt* stmt = create_stmt(t->pos, Stmt_t::INCREMENT); stmt->_unary_exp = parse_not_null_exp(ts); return stmt; } else if (t->type == Token_t::DECREMENT) { ts.pop(); Stmt* stmt = create_stmt(t->pos, Stmt_t::DECREMENT); stmt->_unary_exp = parse_not_null_exp(ts); return stmt; } // Try and parse a expression else if ((exp = parse_exp(ts)) != nullptr) { // Re-peek after parsing expression t = ts.peek(); Stmt* stmt = nullptr; Stmt* assignment_operator = parse_assignment_operator_statement(ts, exp); if (assignment_operator) { stmt = assignment_operator; } // Otherwise, we just have a plain-old expression statement. else { stmt = create_stmt(t->pos, Stmt_t::EXPRESSION); stmt->_unary_exp = exp; } return stmt; } else { // TODO: Do we include a blank statement? } return nullptr; } AST::Stmt* Parser::parse_assignment_operator_statement(Token_stream& ts, AST::Exp* lhs) { using namespace AST; Stmt* stmt = nullptr; const Token* t = ts.peek(); BEGIN_IGNORE_SWITCH_DIRECTIVE; switch (t->type) { case (Token_t) '=': stmt = create_stmt(t->pos, Stmt_t::ASSIGNMENT); break; case Token_t::PLUS_EQUALS: stmt = create_stmt(t->pos, Stmt_t::PLUS_EQUALS); break; case Token_t::MINUS_EQUALS: stmt = create_stmt(t->pos, Stmt_t::MINUS_EQUALS); break; case Token_t::TIMES_EQUALS: stmt = create_stmt(t->pos, Stmt_t::TIMES_EQUALS); break; case Token_t::DIVIDE_EQUALS: stmt = create_stmt(t->pos, Stmt_t::DIVIDE_EQUALS); break; case Token_t::BITWISE_LSHIFT_EQUALS: stmt = create_stmt(t->pos, Stmt_t::BITWISE_LSHIFT_EQUALS); break; case Token_t::BITWISE_RSHIFT_EQUALS: stmt = create_stmt(t->pos, Stmt_t::BITWISE_RSHIFT_EQUALS); break; case Token_t::BITWISE_AND_EQUALS: stmt = create_stmt(t->pos, Stmt_t::BITWISE_AND_EQUALS); break; case Token_t::BITWISE_OR_EQUALS: stmt = create_stmt(t->pos, Stmt_t::BITWISE_OR_EQUALS); break; case Token_t::BITWISE_XOR_EQUALS: stmt = create_stmt(t->pos, Stmt_t::BITWISE_XOR_EQUALS); break; case Token_t::REMAINDER_EQUALS: stmt = create_stmt(t->pos, Stmt_t::REMAINDER_EQUALS); break; default: // no assignment operator found! stmt = nullptr; } END_IGNORE_SWITCH_DIRECTIVE; // If a assignment operator was found, need to parse rhs. if (stmt != nullptr) { // pop off the assignment operator first ts.pop(); // Then assign lhs/rhs stmt->_assignment.lhs = lhs; stmt->_assignment.rhs = parse_not_null_exp(ts); } return stmt; } AST::Stmt* Parser::parse_stmt_block(Token_stream& ts, Symbol_table* scope) { // #37: If a ending semi-colon was not injected, // this consitutes a parsing error. const Token* t; if ((t = ts.peek())->type == (Token_t) ';' && ts.pop() && (t->flags & Token_flags::INJECTED) == 0) { bey_error(Error_t::EXPECTED_STATEMENT_OR_STATEMENT_BLOCK, t->pos); } // Statement blocks require an opening '{'. // NOTE: the '{' token is not consumed here. It's consumed in // parse_stmt when identifying this program point is a statement block. if ((t = ts.peek())->type != (Token_t) '{') { bey_error(Error_t::EXPECTED_TOKEN, t->pos, (Token_t) '{'); } // When parsing the block, we will want to stop parsing (at the current level) // when we see '}' so whatever calling code can handle what comes next. return parse_stmt(ts, scope, /* stop_on_scope_close = */ true); } AST::Ident* Parser::parse_ident(Token_stream& ts) { AST::Ident* ident = create_ident(ts.peek()->pos); if (ts.peek()->type == Token_t::IDENTIFIER) { const Token* t = ts.pop(); ident->name = t->_string; } else { // Uh oh... we where expecting a identifier! ts.expect(Token_t::IDENTIFIER); } return ident; } std::optional Parser::get_type_kind(Token_stream& ts, int depth /* = 0*/) { // IntegerType = 'int' if (ts.peek(depth)->type == Token_t::INT) return AST::Type_t::INT; // StringType = 'string' if (ts.peek(depth)->type == Token_t::STRING) return AST::Type_t::STRING; // DoubleType = 'double' if (ts.peek(depth)->type == Token_t::DOUBLE) return AST::Type_t::DOUBLE; // BoolType = 'bool' if (ts.peek(depth)->type == Token_t::BOOL) return AST::Type_t::BOOL; // ArrayType = '[' Expression ']' if (ts.peek(depth)->type == (Token_t) '[') return AST::Type_t::ARRAY; // TypeName = Identifier if (ts.peek(depth)->type == Token_t::IDENTIFIER) return AST::Type_t::TYPE_NAME; // StructType = 'struct' '{' [VariableDeclarations] '}' if (ts.peek(depth)->type == Token_t::STRUCT) return AST::Type_t::STRUCT; return {}; } AST::Type* Parser::try_parse_type(Token_stream& ts, Symbol_table* scope) { if (auto kind = get_type_kind(ts)) { switch (*kind) { case AST::Type_t::ARRAY: { AST::Type* type = create_type(ts.peek()->pos, AST::Type_t::ARRAY); ts.expect((Token_t) '['); AST::Exp* array_length = parse_not_null_exp(ts); ts.expect((Token_t) ']'); AST::Type* element_type = try_parse_type(ts, scope); type->_array.length = array_length; type->_array.element_type = element_type; return type; } case AST::Type_t::TYPE_NAME: { AST::Type* type = create_type(ts.peek()->pos, AST::Type_t::TYPE_NAME); type->_type_name = parse_ident(ts); return type; } case AST::Type_t::STRUCT: { AST::Type* type = create_type(ts.peek()->pos, AST::Type_t::STRUCT); ts.expect(Token_t::STRUCT); ts.expect((Token_t) '{'); AST::Var_decl *head = nullptr, *p = nullptr; const Token* t; while ((t = ts.peek())->type != (Token_t) '}' && t->type != Token_t::INVALID) { AST::Var_decl* field = parse_var_decl(ts, scope, Var_decl_flags::REQUIRE_EXPLICIT_TYPE | Var_decl_flags::DISALLOW_ASSIGNMENT_EXPRESSION ); insert_into_linked_list(&head, &p, field); } ts.expect((Token_t) '}'); type->_struct.scope = Symbol_table::create_table(scope); type->_struct.fields = head; return type; } case AST::Type_t::INT: ts.pop(); return &AST::predeclared_types::_int; case AST::Type_t::STRING: ts.pop(); return &AST::predeclared_types::_string; case AST::Type_t::DOUBLE: ts.pop(); return &AST::predeclared_types::_double; case AST::Type_t::BOOL: ts.pop(); return &AST::predeclared_types::_bool; case AST::Type_t::VOID: // @Note : we should never reach this point. return nullptr; } } // No type found return nullptr; } AST::Exp* Parser::parse_exp(Token_stream& ts, int priority /* = -1*/) { using namespace AST; AST::Exp* top_level = nullptr; const Token* t; bool stop_parsing = false; // Stop parsing expressions if: while((t = ts.peek())->type != (Token_t)';' && // 1) End of the expression t->type != Token_t::INVALID && // 2) Out of tokens! !stop_parsing) // 3) We have been told to stop parsing at this scope // either due to a error or we need to jump out of this scope { // Get the priority of the next operator. If the next operator's // priority than our current, we must break out and build our AST // s.t. it obeys the precedence rules. // NOTE: if there is no next operator (op_priority == -1), we do // not break out. int op_priority = get_operator_priority(t); if (op_priority != -1 && op_priority <= priority) { break; } // Let's try to discover the type we are dealing with. BEGIN_IGNORE_SWITCH_DIRECTIVE; switch (t->type) { // Literals case Token_t::INT_LIT: { if (top_level) bey_error(Error_t::EXPECTED_BINARY_OPERATOR_OR_SEMI_COLON, top_level->pos); ts.pop(); top_level = create_exp(t->pos, Exp_t::INT_LIT); top_level->_int = t->_int; break; } case Token_t::DOUBLE_LIT: { if (top_level) bey_error(Error_t::EXPECTED_BINARY_OPERATOR_OR_SEMI_COLON, top_level->pos); ts.pop(); top_level = create_exp(t->pos, Exp_t::DOUBLE_LIT); top_level->_double = t->_double; break; } case Token_t::STRING_LIT: { if (top_level) bey_error(Error_t::EXPECTED_BINARY_OPERATOR_OR_SEMI_COLON, top_level->pos); ts.pop(); top_level = create_exp(t->pos, Exp_t::STRING_LIT); top_level->_string = t->_string; break; } case Token_t::FALSE: case Token_t::TRUE: { if (top_level) bey_error(Error_t::EXPECTED_BINARY_OPERATOR_OR_SEMI_COLON, top_level->pos); ts.pop(); top_level = create_exp(t->pos, Exp_t::BOOLEAN_LIT); top_level->_bool = t->type == Token_t::TRUE ? true : false; break; } // identifiers / function calls case Token_t::IDENTIFIER: { if (top_level) bey_error(Error_t::EXPECTED_BINARY_OPERATOR_OR_SEMI_COLON, top_level->pos); // Are we dealing with a func_call? if (ts.peek(1)->type == (Token_t) '(') { top_level = parse_func_call(ts); } else { // No need to pop - parse_ident will pop the token off for us. top_level = create_exp(t->pos, Exp_t::IDENTIFIER); top_level->_ident = parse_ident(ts); } break; } // Brackets case (Token_t) '(': { if (top_level) bey_error(Error_t::EXPECTED_BINARY_OPERATOR_OR_SEMI_COLON, top_level->pos); ts.pop(); top_level = parse_exp(ts, /*priority = */ -1); ts.expect((Token_t) ')'); break; } // Indexing case (Token_t) '[': top_level = parse_indexing(ts, top_level); break; // Struct access case (Token_t) '.': top_level = parse_selector(ts, top_level); break; // Operators case Token_t::EQUAL: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::EQUAL, top_level, op_priority); break; case Token_t::NOT_EQUAL: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::NOT_EQUAL, top_level, op_priority); break; case (Token_t) '!': ts.pop(); top_level = parse_unary_exp(ts, t, Exp_t::LOGICAL_NOT, op_priority); break; case (Token_t) '~': ts.pop(); top_level = parse_unary_exp(ts, t, Exp_t::BITWISE_NOT, op_priority); break; case Token_t::LOGICAL_AND: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::LOGICAL_AND, top_level, op_priority); break; case (Token_t) '&': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::BITWISE_AND, top_level, op_priority); break; case Token_t::LOGICAL_OR: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::LOGICAL_OR, top_level, op_priority); break; case (Token_t) '|': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::BITWISE_OR, top_level, op_priority); break; case Token_t::BITWISE_LSHIFT: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::BITWISE_LSHIFT, top_level, op_priority); break; case Token_t::LESS_EQUAL_THAN: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::LESS_EQUAL_THAN, top_level, op_priority); break; case (Token_t) '<': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::LESS_THAN, top_level, op_priority); break; case Token_t::BITWISE_RSHIFT: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::BITWISE_RSHIFT, top_level, op_priority); break; case Token_t::GREATER_EQUAL_THAN: ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::GREATER_EQUAL_THAN, top_level, op_priority); break; case (Token_t) '>': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::GREATER_THAN, top_level, op_priority); break; case (Token_t) '^': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::BITWISE_XOR, top_level, op_priority); break; case (Token_t) '%': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::REMAINDER, top_level, op_priority); break; case (Token_t) '+': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::PLUS, top_level, op_priority); break; case (Token_t) '-': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::MINUS, top_level, op_priority); break; case (Token_t) '*': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::TIMES, top_level, op_priority); break; case (Token_t) '/': ts.pop(); top_level = parse_binary_exp(ts, t, Exp_t::DIVIDE, top_level, op_priority); break; // Particular Tokens indicate that we need to stop parsing // at the current depth: case Token_t::PLUS_EQUALS: case Token_t::MINUS_EQUALS: case Token_t::TIMES_EQUALS: case Token_t::DIVIDE_EQUALS: case Token_t::BITWISE_LSHIFT_EQUALS: case Token_t::BITWISE_RSHIFT_EQUALS: case Token_t::BITWISE_AND_EQUALS: case Token_t::BITWISE_OR_EQUALS: case Token_t::BITWISE_XOR_EQUALS: case Token_t::REMAINDER_EQUALS: case (Token_t) '=': case (Token_t) '{': case (Token_t) ',': case (Token_t) ')': case (Token_t) ']': { stop_parsing = true; break; } // We have encountered a token we did not expect // for a expression... we will need to stop parsing // and throw an error. default: stop_parsing = true; bey_error(Error_t::EXPECTED_VALID_EXPRESSION, t->pos, t->type); break; } END_IGNORE_SWITCH_DIRECTIVE; } return top_level; } AST::Exp* Parser::parse_not_null_exp(Token_stream& ts) { using namespace AST; const Token* temp = ts.peek(); Exp* exp = parse_exp(ts); if (exp == nullptr) { bey_error(Error_t::EXPECTED_VALID_EXPRESSION, temp->pos, temp->type); } return exp; } AST::Exp* Parser::parse_binary_exp(Token_stream& ts, const Token* operator_token, AST::Exp_t exp_kind, AST::Exp* lhs, int priority) { using namespace AST; // If no lhs exists, throw a error but continue to parse. if (lhs == nullptr) { Position lhs_pos = operator_token->pos; lhs_pos.colno-=1; bey_error(Error_t::EXPECTED_VALID_L_BRANCH, lhs_pos); } Exp* exp = create_exp(operator_token->pos, exp_kind); exp->_binary.lhs = lhs; exp->_binary.rhs = parse_exp(ts, priority); // If no rhs exists, throw a error but continue to parse. if (exp->_binary.rhs == nullptr) { Position rhs_pos = operator_token->pos; rhs_pos.colno+=1; bey_error(Error_t::EXPECTED_VALID_R_BRANCH, rhs_pos); } return exp; } AST::Exp* Parser::parse_unary_exp(Token_stream& ts, const Token* operator_token, AST::Exp_t exp_kind, int priority) { using namespace AST; Exp* exp = create_exp(operator_token->pos, exp_kind); exp->_unary = parse_exp(ts, priority); if (exp->_unary == nullptr) bey_error(Error_t::EXPECTED_VALID_SUB_EXPRESSION, operator_token->pos); return exp; } AST::Exp* Parser::parse_func_call(Token_stream& ts) { using namespace AST; Exp* exp = create_exp(ts.peek()->pos, Exp_t::FUNCTION_CALL); exp->_func_call.func_name = parse_ident(ts); ts.expect((Token_t) '('); Exp *head = nullptr; Exp *p = nullptr; // Loop until we see a ')' token or we reach the end // of the expression / file. const Token* t; while ((t = ts.peek())->type != (Token_t) ')' && t->type != (Token_t) ';' && t->type != Token_t::INVALID) { insert_into_linked_list(&head, &p, parse_not_null_exp(ts)); // If the next up token is not ')', then we should expect a ',' if (ts.peek()->type != (Token_t) ')') { ts.expect((Token_t) ','); const Token* t = ts.peek(); if (t->type == (Token_t) ')') { bey_error(Error_t::EXPECTED_ARGUMENT, t->pos); } } } ts.expect((Token_t) ')'); exp->_func_call.arg_list = head; return exp; } AST::Exp* Parser::parse_indexing(Token_stream& ts, AST::Exp* lhs) { using namespace AST; // If no lhs exists, throw a error but continue to parse. if (lhs == nullptr) { bey_error(Error_t::EXPECTED_VALID_LHS_EXPRESSION, ts.peek()->pos); } ts.expect((Token_t) '['); Exp* exp = create_exp(ts.peek()->pos, Exp_t::INDEX); exp->_index.node = lhs; exp->_index.index = parse_not_null_exp(ts); ts.expect((Token_t) ']'); return exp; } AST::Exp* Parser::parse_selector(Token_stream& ts, AST::Exp* lhs) { using namespace AST; Position selector_pos = ts.peek()->pos; // If no lhs exists, throw a error but continue to parse. if (lhs == nullptr) { bey_error(Error_t::EXPECTED_VALID_LHS_EXPRESSION, selector_pos); } Exp* exp = create_exp(selector_pos, Exp_t::SELECTOR); ts.expect((Token_t) '.'); exp->_selector.node = lhs; exp->_selector.field = parse_ident(ts); return exp; }