diff --git a/compiler/scripts/update_ast.py b/compiler/scripts/update_ast.py index 17ce85fa..17f0356f 100755 --- a/compiler/scripts/update_ast.py +++ b/compiler/scripts/update_ast.py @@ -135,7 +135,6 @@ "def": "name_", "class": "name_", "enum": "name_", - "union": "name_", "import": "import_token_", "runtimefeature": "runtimefeature_token_", "compins": "name_", @@ -223,7 +222,6 @@ ("stmt*", "function_body"), ("ykdatatype*", "return_type"), ("annotations", "annotations"))), ("class", (("token*", "name"), ("std::vector", "members"), ("annotations", "annotations"))), ("enum", (("token*", "name"), ("std::vector", "members"), ("annotations", "annotations"))), - ("union", (("token*", "name"), ("std::vector", "members"), ("annotations", "annotations"))), # import io [as io] ("import", (("token*", "import_token"), ("std::vector", "import_names"), ("token*", "name"), ("file_info*", "data"))), diff --git a/compiler/scripts/update_tokens.py b/compiler/scripts/update_tokens.py index de6bbe7e..854763b0 100755 --- a/compiler/scripts/update_tokens.py +++ b/compiler/scripts/update_tokens.py @@ -60,7 +60,7 @@ "and", "continue", "for", "try", "as", "def", "from", "while", "assert", "del", "not", - "elif", "if", "or", "defer", "ccode", "runtimefeature", "in", "struct", "macros", "directive"]) + "elif", "if", "or", "defer", "ccode", "runtimefeature", "in", "struct", "macros", "directive", "enum"]) TOKENS = sorted([ "NAME", "AT", "DOUBLE_NUMBER", "FLOAT_NUMBER", "INDENT", "BA_INDENT", "BA_DEDENT", "NEW_LINE", "COLON", "SEMICOLON", "COMMENT", diff --git a/compiler/src/ast/ast.cpp b/compiler/src/ast/ast.cpp index 1e72ed4f..54dc7109 100644 --- a/compiler/src/ast/ast.cpp +++ b/compiler/src/ast/ast.cpp @@ -1,196 +1,201 @@ -// ============================================================================================== -// ╦ ┬┌─┐┌─┐┌┐┌┌─┐┌─┐ Yaksha Programming Language -// ║ ││ ├┤ │││└─┐├┤ is Licensed with GPLv3 + extra terms. Please see below. -// ╩═╝┴└─┘└─┘┘└┘└─┘└─┘ -// Note: libs - MIT license, runtime/3rd - various -// ============================================================================================== -// GPLv3: -// -// Yaksha - Programming Language. -// Copyright (C) 2020 - 2024 Bhathiya Perera -// -// This program is free software: you can redistribute it and/or modify it under the terms -// of the GNU General Public License as published by the Free Software Foundation, -// either version 3 of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -// See the GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License along with this program. -// If not, see https://www.gnu.org/licenses/. -// -// ============================================================================================== -// Additional Terms: -// -// Please note that any commercial use of the programming language's compiler source code -// (everything except compiler/runtime, compiler/libs and compiler/3rd) require a written agreement -// with author of the language (Bhathiya Perera). -// -// If you are using it for an open source project, please give credits. -// Your own project must use GPLv3 license with these additional terms. -// -// You may use programs written in Yaksha/YakshaLisp for any legal purpose -// (commercial, open-source, closed-source, etc) as long as it agrees -// to the licenses of linked runtime libraries (see compiler/runtime/README.md). -// -// ============================================================================================== // ast.cpp // generated by update_ast.py #include "ast/ast.h" using namespace yaksha; // ------- expressions ----- -assign_expr::assign_expr(token *name, token *opr, expr *right, bool promoted, - ykdatatype *promoted_data_type) - : name_(name), opr_(opr), right_(right), promoted_(promoted), - promoted_data_type_(promoted_data_type) {} -void assign_expr::accept(expr_visitor *v) { v->visit_assign_expr(this); } -ast_type assign_expr::get_type() { return ast_type::EXPR_ASSIGN; } -token *assign_expr::locate() { return name_; } -expr *ast_pool::c_assign_expr(token *name, token *opr, expr *right, - bool promoted, ykdatatype *promoted_data_type) { +assign_expr::assign_expr(token* name, token* opr, expr* right, bool promoted, ykdatatype* promoted_data_type) + : name_(name), opr_(opr), right_(right), promoted_(promoted), promoted_data_type_(promoted_data_type) {} +void assign_expr::accept(expr_visitor *v) { + v->visit_assign_expr(this); +} +ast_type assign_expr::get_type() { + return ast_type::EXPR_ASSIGN; +} +token* assign_expr::locate() { + return name_; +} +expr *ast_pool::c_assign_expr(token* name, token* opr, expr* right, bool promoted, ykdatatype* promoted_data_type) { auto o = new assign_expr(name, opr, right, promoted, promoted_data_type); cleanup_expr_.push_back(o); return o; } -assign_arr_expr::assign_arr_expr(expr *assign_oper, token *opr, expr *right) +assign_arr_expr::assign_arr_expr(expr* assign_oper, token* opr, expr* right) : assign_oper_(assign_oper), opr_(opr), right_(right) {} void assign_arr_expr::accept(expr_visitor *v) { v->visit_assign_arr_expr(this); } -ast_type assign_arr_expr::get_type() { return ast_type::EXPR_ASSIGN_ARR; } -token *assign_arr_expr::locate() { return opr_; } -expr *ast_pool::c_assign_arr_expr(expr *assign_oper, token *opr, expr *right) { +ast_type assign_arr_expr::get_type() { + return ast_type::EXPR_ASSIGN_ARR; +} +token* assign_arr_expr::locate() { + return opr_; +} +expr *ast_pool::c_assign_arr_expr(expr* assign_oper, token* opr, expr* right) { auto o = new assign_arr_expr(assign_oper, opr, right); cleanup_expr_.push_back(o); return o; } -assign_member_expr::assign_member_expr(expr *set_oper, token *opr, expr *right) +assign_member_expr::assign_member_expr(expr* set_oper, token* opr, expr* right) : set_oper_(set_oper), opr_(opr), right_(right) {} void assign_member_expr::accept(expr_visitor *v) { v->visit_assign_member_expr(this); } -ast_type assign_member_expr::get_type() { return ast_type::EXPR_ASSIGN_MEMBER; } -token *assign_member_expr::locate() { return opr_; } -expr *ast_pool::c_assign_member_expr(expr *set_oper, token *opr, expr *right) { +ast_type assign_member_expr::get_type() { + return ast_type::EXPR_ASSIGN_MEMBER; +} +token* assign_member_expr::locate() { + return opr_; +} +expr *ast_pool::c_assign_member_expr(expr* set_oper, token* opr, expr* right) { auto o = new assign_member_expr(set_oper, opr, right); cleanup_expr_.push_back(o); return o; } -binary_expr::binary_expr(expr *left, token *opr, expr *right) +binary_expr::binary_expr(expr* left, token* opr, expr* right) : left_(left), opr_(opr), right_(right) {} -void binary_expr::accept(expr_visitor *v) { v->visit_binary_expr(this); } -ast_type binary_expr::get_type() { return ast_type::EXPR_BINARY; } -token *binary_expr::locate() { return opr_; } -expr *ast_pool::c_binary_expr(expr *left, token *opr, expr *right) { +void binary_expr::accept(expr_visitor *v) { + v->visit_binary_expr(this); +} +ast_type binary_expr::get_type() { + return ast_type::EXPR_BINARY; +} +token* binary_expr::locate() { + return opr_; +} +expr *ast_pool::c_binary_expr(expr* left, token* opr, expr* right) { auto o = new binary_expr(left, opr, right); cleanup_expr_.push_back(o); return o; } -curly_call_expr::curly_call_expr(expr *dt_expr, token *curly_open, - std::vector values, - token *curly_close) - : dt_expr_(dt_expr), curly_open_(curly_open), values_(std::move(values)), - curly_close_(curly_close) {} +curly_call_expr::curly_call_expr(expr* dt_expr, token* curly_open, std::vector values, token* curly_close) + : dt_expr_(dt_expr), curly_open_(curly_open), values_(std::move(values)), curly_close_(curly_close) {} void curly_call_expr::accept(expr_visitor *v) { v->visit_curly_call_expr(this); } -ast_type curly_call_expr::get_type() { return ast_type::EXPR_CURLY_CALL; } -token *curly_call_expr::locate() { return curly_open_; } -expr *ast_pool::c_curly_call_expr(expr *dt_expr, token *curly_open, - std::vector values, - token *curly_close) { - auto o = - new curly_call_expr(dt_expr, curly_open, std::move(values), curly_close); +ast_type curly_call_expr::get_type() { + return ast_type::EXPR_CURLY_CALL; +} +token* curly_call_expr::locate() { + return curly_open_; +} +expr *ast_pool::c_curly_call_expr(expr* dt_expr, token* curly_open, std::vector values, token* curly_close) { + auto o = new curly_call_expr(dt_expr, curly_open, std::move(values), curly_close); cleanup_expr_.push_back(o); return o; } -fncall_expr::fncall_expr(expr *name, token *paren_token, - std::vector args) +fncall_expr::fncall_expr(expr* name, token* paren_token, std::vector args) : name_(name), paren_token_(paren_token), args_(std::move(args)) {} -void fncall_expr::accept(expr_visitor *v) { v->visit_fncall_expr(this); } -ast_type fncall_expr::get_type() { return ast_type::EXPR_FNCALL; } -token *fncall_expr::locate() { return name_->locate(); } -expr *ast_pool::c_fncall_expr(expr *name, token *paren_token, - std::vector args) { +void fncall_expr::accept(expr_visitor *v) { + v->visit_fncall_expr(this); +} +ast_type fncall_expr::get_type() { + return ast_type::EXPR_FNCALL; +} +token* fncall_expr::locate() { + return name_->locate(); +} +expr *ast_pool::c_fncall_expr(expr* name, token* paren_token, std::vector args) { auto o = new fncall_expr(name, paren_token, std::move(args)); cleanup_expr_.push_back(o); return o; } -get_expr::get_expr(expr *lhs, token *dot, token *item) +get_expr::get_expr(expr* lhs, token* dot, token* item) : lhs_(lhs), dot_(dot), item_(item) {} -void get_expr::accept(expr_visitor *v) { v->visit_get_expr(this); } -ast_type get_expr::get_type() { return ast_type::EXPR_GET; } -token *get_expr::locate() { return dot_; } -expr *ast_pool::c_get_expr(expr *lhs, token *dot, token *item) { +void get_expr::accept(expr_visitor *v) { + v->visit_get_expr(this); +} +ast_type get_expr::get_type() { + return ast_type::EXPR_GET; +} +token* get_expr::locate() { + return dot_; +} +expr *ast_pool::c_get_expr(expr* lhs, token* dot, token* item) { auto o = new get_expr(lhs, dot, item); cleanup_expr_.push_back(o); return o; } -grouping_expr::grouping_expr(expr *expression) : expression_(expression) {} -void grouping_expr::accept(expr_visitor *v) { v->visit_grouping_expr(this); } -ast_type grouping_expr::get_type() { return ast_type::EXPR_GROUPING; } -token *grouping_expr::locate() { return expression_->locate(); } -expr *ast_pool::c_grouping_expr(expr *expression) { +grouping_expr::grouping_expr(expr* expression) + : expression_(expression) {} +void grouping_expr::accept(expr_visitor *v) { + v->visit_grouping_expr(this); +} +ast_type grouping_expr::get_type() { + return ast_type::EXPR_GROUPING; +} +token* grouping_expr::locate() { + return expression_->locate(); +} +expr *ast_pool::c_grouping_expr(expr* expression) { auto o = new grouping_expr(expression); cleanup_expr_.push_back(o); return o; } -literal_expr::literal_expr(token *literal_token) +literal_expr::literal_expr(token* literal_token) : literal_token_(literal_token) {} -void literal_expr::accept(expr_visitor *v) { v->visit_literal_expr(this); } -ast_type literal_expr::get_type() { return ast_type::EXPR_LITERAL; } -token *literal_expr::locate() { return literal_token_; } -expr *ast_pool::c_literal_expr(token *literal_token) { +void literal_expr::accept(expr_visitor *v) { + v->visit_literal_expr(this); +} +ast_type literal_expr::get_type() { + return ast_type::EXPR_LITERAL; +} +token* literal_expr::locate() { + return literal_token_; +} +expr *ast_pool::c_literal_expr(token* literal_token) { auto o = new literal_expr(literal_token); cleanup_expr_.push_back(o); return o; } -logical_expr::logical_expr(expr *left, token *opr, expr *right) +logical_expr::logical_expr(expr* left, token* opr, expr* right) : left_(left), opr_(opr), right_(right) {} -void logical_expr::accept(expr_visitor *v) { v->visit_logical_expr(this); } -ast_type logical_expr::get_type() { return ast_type::EXPR_LOGICAL; } -token *logical_expr::locate() { return opr_; } -expr *ast_pool::c_logical_expr(expr *left, token *opr, expr *right) { +void logical_expr::accept(expr_visitor *v) { + v->visit_logical_expr(this); +} +ast_type logical_expr::get_type() { + return ast_type::EXPR_LOGICAL; +} +token* logical_expr::locate() { + return opr_; +} +expr *ast_pool::c_logical_expr(expr* left, token* opr, expr* right) { auto o = new logical_expr(left, opr, right); cleanup_expr_.push_back(o); return o; } -macro_call_expr::macro_call_expr(token *path, token *name, - token *not_symbol_tok, token *paren_token, - std::vector args, - token *close_paren_token) - : path_(path), name_(name), not_symbol_tok_(not_symbol_tok), - paren_token_(paren_token), args_(std::move(args)), - close_paren_token_(close_paren_token) {} +macro_call_expr::macro_call_expr(token* path, token* name, token* not_symbol_tok, token* paren_token, std::vector args, token* close_paren_token) + : path_(path), name_(name), not_symbol_tok_(not_symbol_tok), paren_token_(paren_token), args_(std::move(args)), close_paren_token_(close_paren_token) {} void macro_call_expr::accept(expr_visitor *v) { v->visit_macro_call_expr(this); } -ast_type macro_call_expr::get_type() { return ast_type::EXPR_MACRO_CALL; } -token *macro_call_expr::locate() { return name_; } -expr *ast_pool::c_macro_call_expr(token *path, token *name, - token *not_symbol_tok, token *paren_token, - std::vector args, - token *close_paren_token) { - auto o = new macro_call_expr(path, name, not_symbol_tok, paren_token, - std::move(args), close_paren_token); +ast_type macro_call_expr::get_type() { + return ast_type::EXPR_MACRO_CALL; +} +token* macro_call_expr::locate() { + return name_; +} +expr *ast_pool::c_macro_call_expr(token* path, token* name, token* not_symbol_tok, token* paren_token, std::vector args, token* close_paren_token) { + auto o = new macro_call_expr(path, name, not_symbol_tok, paren_token, std::move(args), close_paren_token); cleanup_expr_.push_back(o); return o; } -set_expr::set_expr(expr *lhs, token *dot, token *item) +set_expr::set_expr(expr* lhs, token* dot, token* item) : lhs_(lhs), dot_(dot), item_(item) {} -void set_expr::accept(expr_visitor *v) { v->visit_set_expr(this); } -ast_type set_expr::get_type() { return ast_type::EXPR_SET; } -token *set_expr::locate() { return dot_; } -expr *ast_pool::c_set_expr(expr *lhs, token *dot, token *item) { +void set_expr::accept(expr_visitor *v) { + v->visit_set_expr(this); +} +ast_type set_expr::get_type() { + return ast_type::EXPR_SET; +} +token* set_expr::locate() { + return dot_; +} +expr *ast_pool::c_set_expr(expr* lhs, token* dot, token* item) { auto o = new set_expr(lhs, dot, item); cleanup_expr_.push_back(o); return o; } -square_bracket_access_expr::square_bracket_access_expr(expr *name, - token *sqb_token, - expr *index_expr) +square_bracket_access_expr::square_bracket_access_expr(expr* name, token* sqb_token, expr* index_expr) : name_(name), sqb_token_(sqb_token), index_expr_(index_expr) {} void square_bracket_access_expr::accept(expr_visitor *v) { v->visit_square_bracket_access_expr(this); @@ -198,15 +203,15 @@ void square_bracket_access_expr::accept(expr_visitor *v) { ast_type square_bracket_access_expr::get_type() { return ast_type::EXPR_SQUARE_BRACKET_ACCESS; } -token *square_bracket_access_expr::locate() { return sqb_token_; } -expr *ast_pool::c_square_bracket_access_expr(expr *name, token *sqb_token, - expr *index_expr) { +token* square_bracket_access_expr::locate() { + return sqb_token_; +} +expr *ast_pool::c_square_bracket_access_expr(expr* name, token* sqb_token, expr* index_expr) { auto o = new square_bracket_access_expr(name, sqb_token, index_expr); cleanup_expr_.push_back(o); return o; } -square_bracket_set_expr::square_bracket_set_expr(expr *name, token *sqb_token, - expr *index_expr) +square_bracket_set_expr::square_bracket_set_expr(expr* name, token* sqb_token, expr* index_expr) : name_(name), sqb_token_(sqb_token), index_expr_(index_expr) {} void square_bracket_set_expr::accept(expr_visitor *v) { v->visit_square_bracket_set_expr(this); @@ -214,317 +219,400 @@ void square_bracket_set_expr::accept(expr_visitor *v) { ast_type square_bracket_set_expr::get_type() { return ast_type::EXPR_SQUARE_BRACKET_SET; } -token *square_bracket_set_expr::locate() { return sqb_token_; } -expr *ast_pool::c_square_bracket_set_expr(expr *name, token *sqb_token, - expr *index_expr) { +token* square_bracket_set_expr::locate() { + return sqb_token_; +} +expr *ast_pool::c_square_bracket_set_expr(expr* name, token* sqb_token, expr* index_expr) { auto o = new square_bracket_set_expr(name, sqb_token, index_expr); cleanup_expr_.push_back(o); return o; } -unary_expr::unary_expr(token *opr, expr *right) : opr_(opr), right_(right) {} -void unary_expr::accept(expr_visitor *v) { v->visit_unary_expr(this); } -ast_type unary_expr::get_type() { return ast_type::EXPR_UNARY; } -token *unary_expr::locate() { return opr_; } -expr *ast_pool::c_unary_expr(token *opr, expr *right) { +unary_expr::unary_expr(token* opr, expr* right) + : opr_(opr), right_(right) {} +void unary_expr::accept(expr_visitor *v) { + v->visit_unary_expr(this); +} +ast_type unary_expr::get_type() { + return ast_type::EXPR_UNARY; +} +token* unary_expr::locate() { + return opr_; +} +expr *ast_pool::c_unary_expr(token* opr, expr* right) { auto o = new unary_expr(opr, right); cleanup_expr_.push_back(o); return o; } -variable_expr::variable_expr(token *name) : name_(name) {} -void variable_expr::accept(expr_visitor *v) { v->visit_variable_expr(this); } -ast_type variable_expr::get_type() { return ast_type::EXPR_VARIABLE; } -token *variable_expr::locate() { return name_; } -expr *ast_pool::c_variable_expr(token *name) { +variable_expr::variable_expr(token* name) + : name_(name) {} +void variable_expr::accept(expr_visitor *v) { + v->visit_variable_expr(this); +} +ast_type variable_expr::get_type() { + return ast_type::EXPR_VARIABLE; +} +token* variable_expr::locate() { + return name_; +} +expr *ast_pool::c_variable_expr(token* name) { auto o = new variable_expr(name); cleanup_expr_.push_back(o); return o; } // ------- statements ----- -block_stmt::block_stmt(std::vector statements) +block_stmt::block_stmt(std::vector statements) : statements_(std::move(statements)) {} -void block_stmt::accept(stmt_visitor *v) { v->visit_block_stmt(this); } -ast_type block_stmt::get_type() { return ast_type::STMT_BLOCK; } -token *block_stmt::locate() { return statements_[0]->locate(); } -stmt *ast_pool::c_block_stmt(std::vector statements) { +void block_stmt::accept(stmt_visitor *v) { + v->visit_block_stmt(this); +} +ast_type block_stmt::get_type() { + return ast_type::STMT_BLOCK; +} +token* block_stmt::locate() { + return statements_[0]->locate(); +} +stmt *ast_pool::c_block_stmt(std::vector statements) { auto o = new block_stmt(std::move(statements)); cleanup_stmt_.push_back(o); return o; } -break_stmt::break_stmt(token *break_token) : break_token_(break_token) {} -void break_stmt::accept(stmt_visitor *v) { v->visit_break_stmt(this); } -ast_type break_stmt::get_type() { return ast_type::STMT_BREAK; } -token *break_stmt::locate() { return break_token_; } -stmt *ast_pool::c_break_stmt(token *break_token) { +break_stmt::break_stmt(token* break_token) + : break_token_(break_token) {} +void break_stmt::accept(stmt_visitor *v) { + v->visit_break_stmt(this); +} +ast_type break_stmt::get_type() { + return ast_type::STMT_BREAK; +} +token* break_stmt::locate() { + return break_token_; +} +stmt *ast_pool::c_break_stmt(token* break_token) { auto o = new break_stmt(break_token); cleanup_stmt_.push_back(o); return o; } -ccode_stmt::ccode_stmt(token *ccode_keyword, token *code_str) +ccode_stmt::ccode_stmt(token* ccode_keyword, token* code_str) : ccode_keyword_(ccode_keyword), code_str_(code_str) {} -void ccode_stmt::accept(stmt_visitor *v) { v->visit_ccode_stmt(this); } -ast_type ccode_stmt::get_type() { return ast_type::STMT_CCODE; } -token *ccode_stmt::locate() { return ccode_keyword_; } -stmt *ast_pool::c_ccode_stmt(token *ccode_keyword, token *code_str) { +void ccode_stmt::accept(stmt_visitor *v) { + v->visit_ccode_stmt(this); +} +ast_type ccode_stmt::get_type() { + return ast_type::STMT_CCODE; +} +token* ccode_stmt::locate() { + return ccode_keyword_; +} +stmt *ast_pool::c_ccode_stmt(token* ccode_keyword, token* code_str) { auto o = new ccode_stmt(ccode_keyword, code_str); cleanup_stmt_.push_back(o); return o; } -cfor_stmt::cfor_stmt(token *for_keyword, token *open_paren, expr *init_expr, - token *semi1, expr *comparison, token *semi2, - expr *operation, token *close_paren, stmt *for_body) - : for_keyword_(for_keyword), open_paren_(open_paren), init_expr_(init_expr), - semi1_(semi1), comparison_(comparison), semi2_(semi2), - operation_(operation), close_paren_(close_paren), for_body_(for_body) {} -void cfor_stmt::accept(stmt_visitor *v) { v->visit_cfor_stmt(this); } -ast_type cfor_stmt::get_type() { return ast_type::STMT_CFOR; } -token *cfor_stmt::locate() { return for_keyword_; } -stmt *ast_pool::c_cfor_stmt(token *for_keyword, token *open_paren, - expr *init_expr, token *semi1, expr *comparison, - token *semi2, expr *operation, token *close_paren, - stmt *for_body) { - auto o = new cfor_stmt(for_keyword, open_paren, init_expr, semi1, comparison, - semi2, operation, close_paren, for_body); +cfor_stmt::cfor_stmt(token* for_keyword, token* open_paren, expr* init_expr, token* semi1, expr* comparison, token* semi2, expr* operation, token* close_paren, stmt* for_body) + : for_keyword_(for_keyword), open_paren_(open_paren), init_expr_(init_expr), semi1_(semi1), comparison_(comparison), semi2_(semi2), operation_(operation), close_paren_(close_paren), for_body_(for_body) {} +void cfor_stmt::accept(stmt_visitor *v) { + v->visit_cfor_stmt(this); +} +ast_type cfor_stmt::get_type() { + return ast_type::STMT_CFOR; +} +token* cfor_stmt::locate() { + return for_keyword_; +} +stmt *ast_pool::c_cfor_stmt(token* for_keyword, token* open_paren, expr* init_expr, token* semi1, expr* comparison, token* semi2, expr* operation, token* close_paren, stmt* for_body) { + auto o = new cfor_stmt(for_keyword, open_paren, init_expr, semi1, comparison, semi2, operation, close_paren, for_body); cleanup_stmt_.push_back(o); return o; } -class_stmt::class_stmt(token *name, std::vector members, - annotations annotations) +class_stmt::class_stmt(token* name, std::vector members, annotations annotations) : name_(name), members_(std::move(members)), annotations_(annotations) {} -void class_stmt::accept(stmt_visitor *v) { v->visit_class_stmt(this); } -ast_type class_stmt::get_type() { return ast_type::STMT_CLASS; } -token *class_stmt::locate() { return name_; } -stmt *ast_pool::c_class_stmt(token *name, std::vector members, - annotations annotations) { +void class_stmt::accept(stmt_visitor *v) { + v->visit_class_stmt(this); +} +ast_type class_stmt::get_type() { + return ast_type::STMT_CLASS; +} +token* class_stmt::locate() { + return name_; +} +stmt *ast_pool::c_class_stmt(token* name, std::vector members, annotations annotations) { auto o = new class_stmt(name, std::move(members), annotations); cleanup_stmt_.push_back(o); return o; } -compins_stmt::compins_stmt(token *name, ykdatatype *data_type, token *meta1, - ykdatatype *meta2, void *meta3) - : name_(name), data_type_(data_type), meta1_(meta1), meta2_(meta2), - meta3_(meta3) {} -void compins_stmt::accept(stmt_visitor *v) { v->visit_compins_stmt(this); } -ast_type compins_stmt::get_type() { return ast_type::STMT_COMPINS; } -token *compins_stmt::locate() { return name_; } -stmt *ast_pool::c_compins_stmt(token *name, ykdatatype *data_type, token *meta1, - ykdatatype *meta2, void *meta3) { +compins_stmt::compins_stmt(token* name, ykdatatype* data_type, token* meta1, ykdatatype* meta2, void* meta3) + : name_(name), data_type_(data_type), meta1_(meta1), meta2_(meta2), meta3_(meta3) {} +void compins_stmt::accept(stmt_visitor *v) { + v->visit_compins_stmt(this); +} +ast_type compins_stmt::get_type() { + return ast_type::STMT_COMPINS; +} +token* compins_stmt::locate() { + return name_; +} +stmt *ast_pool::c_compins_stmt(token* name, ykdatatype* data_type, token* meta1, ykdatatype* meta2, void* meta3) { auto o = new compins_stmt(name, data_type, meta1, meta2, meta3); cleanup_stmt_.push_back(o); return o; } -const_stmt::const_stmt(token *name, ykdatatype *data_type, expr *expression, - bool is_global) - : name_(name), data_type_(data_type), expression_(expression), - is_global_(is_global) {} -void const_stmt::accept(stmt_visitor *v) { v->visit_const_stmt(this); } -ast_type const_stmt::get_type() { return ast_type::STMT_CONST; } -token *const_stmt::locate() { return name_; } -stmt *ast_pool::c_const_stmt(token *name, ykdatatype *data_type, - expr *expression, bool is_global) { +const_stmt::const_stmt(token* name, ykdatatype* data_type, expr* expression, bool is_global) + : name_(name), data_type_(data_type), expression_(expression), is_global_(is_global) {} +void const_stmt::accept(stmt_visitor *v) { + v->visit_const_stmt(this); +} +ast_type const_stmt::get_type() { + return ast_type::STMT_CONST; +} +token* const_stmt::locate() { + return name_; +} +stmt *ast_pool::c_const_stmt(token* name, ykdatatype* data_type, expr* expression, bool is_global) { auto o = new const_stmt(name, data_type, expression, is_global); cleanup_stmt_.push_back(o); return o; } -continue_stmt::continue_stmt(token *continue_token) +continue_stmt::continue_stmt(token* continue_token) : continue_token_(continue_token) {} -void continue_stmt::accept(stmt_visitor *v) { v->visit_continue_stmt(this); } -ast_type continue_stmt::get_type() { return ast_type::STMT_CONTINUE; } -token *continue_stmt::locate() { return continue_token_; } -stmt *ast_pool::c_continue_stmt(token *continue_token) { +void continue_stmt::accept(stmt_visitor *v) { + v->visit_continue_stmt(this); +} +ast_type continue_stmt::get_type() { + return ast_type::STMT_CONTINUE; +} +token* continue_stmt::locate() { + return continue_token_; +} +stmt *ast_pool::c_continue_stmt(token* continue_token) { auto o = new continue_stmt(continue_token); cleanup_stmt_.push_back(o); return o; } -def_stmt::def_stmt(token *name, std::vector params, - stmt *function_body, ykdatatype *return_type, - annotations annotations) - : name_(name), params_(std::move(params)), function_body_(function_body), - return_type_(return_type), annotations_(annotations) {} -void def_stmt::accept(stmt_visitor *v) { v->visit_def_stmt(this); } -ast_type def_stmt::get_type() { return ast_type::STMT_DEF; } -token *def_stmt::locate() { return name_; } -stmt *ast_pool::c_def_stmt(token *name, std::vector params, - stmt *function_body, ykdatatype *return_type, - annotations annotations) { - auto o = new def_stmt(name, std::move(params), function_body, return_type, - annotations); +def_stmt::def_stmt(token* name, std::vector params, stmt* function_body, ykdatatype* return_type, annotations annotations) + : name_(name), params_(std::move(params)), function_body_(function_body), return_type_(return_type), annotations_(annotations) {} +void def_stmt::accept(stmt_visitor *v) { + v->visit_def_stmt(this); +} +ast_type def_stmt::get_type() { + return ast_type::STMT_DEF; +} +token* def_stmt::locate() { + return name_; +} +stmt *ast_pool::c_def_stmt(token* name, std::vector params, stmt* function_body, ykdatatype* return_type, annotations annotations) { + auto o = new def_stmt(name, std::move(params), function_body, return_type, annotations); cleanup_stmt_.push_back(o); return o; } -defer_stmt::defer_stmt(token *defer_keyword, expr *expression, - stmt *del_statement) - : defer_keyword_(defer_keyword), expression_(expression), - del_statement_(del_statement) {} -void defer_stmt::accept(stmt_visitor *v) { v->visit_defer_stmt(this); } -ast_type defer_stmt::get_type() { return ast_type::STMT_DEFER; } -token *defer_stmt::locate() { return defer_keyword_; } -stmt *ast_pool::c_defer_stmt(token *defer_keyword, expr *expression, - stmt *del_statement) { +defer_stmt::defer_stmt(token* defer_keyword, expr* expression, stmt* del_statement) + : defer_keyword_(defer_keyword), expression_(expression), del_statement_(del_statement) {} +void defer_stmt::accept(stmt_visitor *v) { + v->visit_defer_stmt(this); +} +ast_type defer_stmt::get_type() { + return ast_type::STMT_DEFER; +} +token* defer_stmt::locate() { + return defer_keyword_; +} +stmt *ast_pool::c_defer_stmt(token* defer_keyword, expr* expression, stmt* del_statement) { auto o = new defer_stmt(defer_keyword, expression, del_statement); cleanup_stmt_.push_back(o); return o; } -del_stmt::del_stmt(token *del_keyword, expr *expression) +del_stmt::del_stmt(token* del_keyword, expr* expression) : del_keyword_(del_keyword), expression_(expression) {} -void del_stmt::accept(stmt_visitor *v) { v->visit_del_stmt(this); } -ast_type del_stmt::get_type() { return ast_type::STMT_DEL; } -token *del_stmt::locate() { return del_keyword_; } -stmt *ast_pool::c_del_stmt(token *del_keyword, expr *expression) { +void del_stmt::accept(stmt_visitor *v) { + v->visit_del_stmt(this); +} +ast_type del_stmt::get_type() { + return ast_type::STMT_DEL; +} +token* del_stmt::locate() { + return del_keyword_; +} +stmt *ast_pool::c_del_stmt(token* del_keyword, expr* expression) { auto o = new del_stmt(del_keyword, expression); cleanup_stmt_.push_back(o); return o; } -directive_stmt::directive_stmt(token *directive_token, - std::vector values, - token *directive_type, token *directive_val) - : directive_token_(directive_token), values_(std::move(values)), - directive_type_(directive_type), directive_val_(directive_val) {} -void directive_stmt::accept(stmt_visitor *v) { v->visit_directive_stmt(this); } -ast_type directive_stmt::get_type() { return ast_type::STMT_DIRECTIVE; } -token *directive_stmt::locate() { return directive_token_; } -stmt *ast_pool::c_directive_stmt(token *directive_token, - std::vector values, - token *directive_type, token *directive_val) { - auto o = new directive_stmt(directive_token, std::move(values), - directive_type, directive_val); +directive_stmt::directive_stmt(token* directive_token, std::vector values, token* directive_type, token* directive_val) + : directive_token_(directive_token), values_(std::move(values)), directive_type_(directive_type), directive_val_(directive_val) {} +void directive_stmt::accept(stmt_visitor *v) { + v->visit_directive_stmt(this); +} +ast_type directive_stmt::get_type() { + return ast_type::STMT_DIRECTIVE; +} +token* directive_stmt::locate() { + return directive_token_; +} +stmt *ast_pool::c_directive_stmt(token* directive_token, std::vector values, token* directive_type, token* directive_val) { + auto o = new directive_stmt(directive_token, std::move(values), directive_type, directive_val); cleanup_stmt_.push_back(o); return o; } -enum_stmt::enum_stmt(token *name, std::vector members, - annotations annotations) +enum_stmt::enum_stmt(token* name, std::vector members, annotations annotations) : name_(name), members_(std::move(members)), annotations_(annotations) {} -void enum_stmt::accept(stmt_visitor *v) { v->visit_enum_stmt(this); } -ast_type enum_stmt::get_type() { return ast_type::STMT_ENUM; } -token *enum_stmt::locate() { return name_; } -stmt *ast_pool::c_enum_stmt(token *name, std::vector members, - annotations annotations) { +void enum_stmt::accept(stmt_visitor *v) { + v->visit_enum_stmt(this); +} +ast_type enum_stmt::get_type() { + return ast_type::STMT_ENUM; +} +token* enum_stmt::locate() { + return name_; +} +stmt *ast_pool::c_enum_stmt(token* name, std::vector members, annotations annotations) { auto o = new enum_stmt(name, std::move(members), annotations); cleanup_stmt_.push_back(o); return o; } -expression_stmt::expression_stmt(expr *expression) : expression_(expression) {} +expression_stmt::expression_stmt(expr* expression) + : expression_(expression) {} void expression_stmt::accept(stmt_visitor *v) { v->visit_expression_stmt(this); } -ast_type expression_stmt::get_type() { return ast_type::STMT_EXPRESSION; } -token *expression_stmt::locate() { return expression_->locate(); } -stmt *ast_pool::c_expression_stmt(expr *expression) { +ast_type expression_stmt::get_type() { + return ast_type::STMT_EXPRESSION; +} +token* expression_stmt::locate() { + return expression_->locate(); +} +stmt *ast_pool::c_expression_stmt(expr* expression) { auto o = new expression_stmt(expression); cleanup_stmt_.push_back(o); return o; } -foreach_stmt::foreach_stmt(token *for_keyword, token *name, - ykdatatype *data_type, token *in_keyword, - expr *expression, stmt *for_body, - ykdatatype *expr_datatype) - : for_keyword_(for_keyword), name_(name), data_type_(data_type), - in_keyword_(in_keyword), expression_(expression), for_body_(for_body), - expr_datatype_(expr_datatype) {} -void foreach_stmt::accept(stmt_visitor *v) { v->visit_foreach_stmt(this); } -ast_type foreach_stmt::get_type() { return ast_type::STMT_FOREACH; } -token *foreach_stmt::locate() { return for_keyword_; } -stmt *ast_pool::c_foreach_stmt(token *for_keyword, token *name, - ykdatatype *data_type, token *in_keyword, - expr *expression, stmt *for_body, - ykdatatype *expr_datatype) { - auto o = new foreach_stmt(for_keyword, name, data_type, in_keyword, - expression, for_body, expr_datatype); +foreach_stmt::foreach_stmt(token* for_keyword, token* name, ykdatatype* data_type, token* in_keyword, expr* expression, stmt* for_body, ykdatatype* expr_datatype) + : for_keyword_(for_keyword), name_(name), data_type_(data_type), in_keyword_(in_keyword), expression_(expression), for_body_(for_body), expr_datatype_(expr_datatype) {} +void foreach_stmt::accept(stmt_visitor *v) { + v->visit_foreach_stmt(this); +} +ast_type foreach_stmt::get_type() { + return ast_type::STMT_FOREACH; +} +token* foreach_stmt::locate() { + return for_keyword_; +} +stmt *ast_pool::c_foreach_stmt(token* for_keyword, token* name, ykdatatype* data_type, token* in_keyword, expr* expression, stmt* for_body, ykdatatype* expr_datatype) { + auto o = new foreach_stmt(for_keyword, name, data_type, in_keyword, expression, for_body, expr_datatype); cleanup_stmt_.push_back(o); return o; } -forendless_stmt::forendless_stmt(token *for_keyword, stmt *for_body) +forendless_stmt::forendless_stmt(token* for_keyword, stmt* for_body) : for_keyword_(for_keyword), for_body_(for_body) {} void forendless_stmt::accept(stmt_visitor *v) { v->visit_forendless_stmt(this); } -ast_type forendless_stmt::get_type() { return ast_type::STMT_FORENDLESS; } -token *forendless_stmt::locate() { return for_keyword_; } -stmt *ast_pool::c_forendless_stmt(token *for_keyword, stmt *for_body) { +ast_type forendless_stmt::get_type() { + return ast_type::STMT_FORENDLESS; +} +token* forendless_stmt::locate() { + return for_keyword_; +} +stmt *ast_pool::c_forendless_stmt(token* for_keyword, stmt* for_body) { auto o = new forendless_stmt(for_keyword, for_body); cleanup_stmt_.push_back(o); return o; } -if_stmt::if_stmt(token *if_keyword, expr *expression, stmt *if_branch, - token *else_keyword, stmt *else_branch) - : if_keyword_(if_keyword), expression_(expression), if_branch_(if_branch), - else_keyword_(else_keyword), else_branch_(else_branch) {} -void if_stmt::accept(stmt_visitor *v) { v->visit_if_stmt(this); } -ast_type if_stmt::get_type() { return ast_type::STMT_IF; } -token *if_stmt::locate() { return if_keyword_; } -stmt *ast_pool::c_if_stmt(token *if_keyword, expr *expression, stmt *if_branch, - token *else_keyword, stmt *else_branch) { - auto o = - new if_stmt(if_keyword, expression, if_branch, else_keyword, else_branch); +if_stmt::if_stmt(token* if_keyword, expr* expression, stmt* if_branch, token* else_keyword, stmt* else_branch) + : if_keyword_(if_keyword), expression_(expression), if_branch_(if_branch), else_keyword_(else_keyword), else_branch_(else_branch) {} +void if_stmt::accept(stmt_visitor *v) { + v->visit_if_stmt(this); +} +ast_type if_stmt::get_type() { + return ast_type::STMT_IF; +} +token* if_stmt::locate() { + return if_keyword_; +} +stmt *ast_pool::c_if_stmt(token* if_keyword, expr* expression, stmt* if_branch, token* else_keyword, stmt* else_branch) { + auto o = new if_stmt(if_keyword, expression, if_branch, else_keyword, else_branch); cleanup_stmt_.push_back(o); return o; } -import_stmt::import_stmt(token *import_token, std::vector import_names, - token *name, file_info *data) - : import_token_(import_token), import_names_(std::move(import_names)), - name_(name), data_(data) {} -void import_stmt::accept(stmt_visitor *v) { v->visit_import_stmt(this); } -ast_type import_stmt::get_type() { return ast_type::STMT_IMPORT; } -token *import_stmt::locate() { return import_token_; } -stmt *ast_pool::c_import_stmt(token *import_token, - std::vector import_names, token *name, - file_info *data) { +import_stmt::import_stmt(token* import_token, std::vector import_names, token* name, file_info* data) + : import_token_(import_token), import_names_(std::move(import_names)), name_(name), data_(data) {} +void import_stmt::accept(stmt_visitor *v) { + v->visit_import_stmt(this); +} +ast_type import_stmt::get_type() { + return ast_type::STMT_IMPORT; +} +token* import_stmt::locate() { + return import_token_; +} +stmt *ast_pool::c_import_stmt(token* import_token, std::vector import_names, token* name, file_info* data) { auto o = new import_stmt(import_token, std::move(import_names), name, data); cleanup_stmt_.push_back(o); return o; } -let_stmt::let_stmt(token *name, ykdatatype *data_type, expr *expression) +let_stmt::let_stmt(token* name, ykdatatype* data_type, expr* expression) : name_(name), data_type_(data_type), expression_(expression) {} -void let_stmt::accept(stmt_visitor *v) { v->visit_let_stmt(this); } -ast_type let_stmt::get_type() { return ast_type::STMT_LET; } -token *let_stmt::locate() { return name_; } -stmt *ast_pool::c_let_stmt(token *name, ykdatatype *data_type, - expr *expression) { +void let_stmt::accept(stmt_visitor *v) { + v->visit_let_stmt(this); +} +ast_type let_stmt::get_type() { + return ast_type::STMT_LET; +} +token* let_stmt::locate() { + return name_; +} +stmt *ast_pool::c_let_stmt(token* name, ykdatatype* data_type, expr* expression) { auto o = new let_stmt(name, data_type, expression); cleanup_stmt_.push_back(o); return o; } -nativeconst_stmt::nativeconst_stmt(token *name, ykdatatype *data_type, - token *ccode_keyword, token *code_str, - bool is_global) - : name_(name), data_type_(data_type), ccode_keyword_(ccode_keyword), - code_str_(code_str), is_global_(is_global) {} +nativeconst_stmt::nativeconst_stmt(token* name, ykdatatype* data_type, token* ccode_keyword, token* code_str, bool is_global) + : name_(name), data_type_(data_type), ccode_keyword_(ccode_keyword), code_str_(code_str), is_global_(is_global) {} void nativeconst_stmt::accept(stmt_visitor *v) { v->visit_nativeconst_stmt(this); } -ast_type nativeconst_stmt::get_type() { return ast_type::STMT_NATIVECONST; } -token *nativeconst_stmt::locate() { return name_; } -stmt *ast_pool::c_nativeconst_stmt(token *name, ykdatatype *data_type, - token *ccode_keyword, token *code_str, - bool is_global) { - auto o = - new nativeconst_stmt(name, data_type, ccode_keyword, code_str, is_global); +ast_type nativeconst_stmt::get_type() { + return ast_type::STMT_NATIVECONST; +} +token* nativeconst_stmt::locate() { + return name_; +} +stmt *ast_pool::c_nativeconst_stmt(token* name, ykdatatype* data_type, token* ccode_keyword, token* code_str, bool is_global) { + auto o = new nativeconst_stmt(name, data_type, ccode_keyword, code_str, is_global); cleanup_stmt_.push_back(o); return o; } -pass_stmt::pass_stmt(token *pass_token) : pass_token_(pass_token) {} -void pass_stmt::accept(stmt_visitor *v) { v->visit_pass_stmt(this); } -ast_type pass_stmt::get_type() { return ast_type::STMT_PASS; } -token *pass_stmt::locate() { return pass_token_; } -stmt *ast_pool::c_pass_stmt(token *pass_token) { +pass_stmt::pass_stmt(token* pass_token) + : pass_token_(pass_token) {} +void pass_stmt::accept(stmt_visitor *v) { + v->visit_pass_stmt(this); +} +ast_type pass_stmt::get_type() { + return ast_type::STMT_PASS; +} +token* pass_stmt::locate() { + return pass_token_; +} +stmt *ast_pool::c_pass_stmt(token* pass_token) { auto o = new pass_stmt(pass_token); cleanup_stmt_.push_back(o); return o; } -return_stmt::return_stmt(token *return_keyword, expr *expression, - ykdatatype *result_type) - : return_keyword_(return_keyword), expression_(expression), - result_type_(result_type) {} -void return_stmt::accept(stmt_visitor *v) { v->visit_return_stmt(this); } -ast_type return_stmt::get_type() { return ast_type::STMT_RETURN; } -token *return_stmt::locate() { return return_keyword_; } -stmt *ast_pool::c_return_stmt(token *return_keyword, expr *expression, - ykdatatype *result_type) { +return_stmt::return_stmt(token* return_keyword, expr* expression, ykdatatype* result_type) + : return_keyword_(return_keyword), expression_(expression), result_type_(result_type) {} +void return_stmt::accept(stmt_visitor *v) { + v->visit_return_stmt(this); +} +ast_type return_stmt::get_type() { + return ast_type::STMT_RETURN; +} +token* return_stmt::locate() { + return return_keyword_; +} +stmt *ast_pool::c_return_stmt(token* return_keyword, expr* expression, ykdatatype* result_type) { auto o = new return_stmt(return_keyword, expression, result_type); cleanup_stmt_.push_back(o); return o; } -runtimefeature_stmt::runtimefeature_stmt(token *runtimefeature_token, - token *feature) +runtimefeature_stmt::runtimefeature_stmt(token* runtimefeature_token, token* feature) : runtimefeature_token_(runtimefeature_token), feature_(feature) {} void runtimefeature_stmt::accept(stmt_visitor *v) { v->visit_runtimefeature_stmt(this); @@ -532,99 +620,97 @@ void runtimefeature_stmt::accept(stmt_visitor *v) { ast_type runtimefeature_stmt::get_type() { return ast_type::STMT_RUNTIMEFEATURE; } -token *runtimefeature_stmt::locate() { return runtimefeature_token_; } -stmt *ast_pool::c_runtimefeature_stmt(token *runtimefeature_token, - token *feature) { +token* runtimefeature_stmt::locate() { + return runtimefeature_token_; +} +stmt *ast_pool::c_runtimefeature_stmt(token* runtimefeature_token, token* feature) { auto o = new runtimefeature_stmt(runtimefeature_token, feature); cleanup_stmt_.push_back(o); return o; } -union_stmt::union_stmt(token *name, std::vector members, - annotations annotations) - : name_(name), members_(std::move(members)), annotations_(annotations) {} -void union_stmt::accept(stmt_visitor *v) { v->visit_union_stmt(this); } -ast_type union_stmt::get_type() { return ast_type::STMT_UNION; } -token *union_stmt::locate() { return name_; } -stmt *ast_pool::c_union_stmt(token *name, std::vector members, - annotations annotations) { - auto o = new union_stmt(name, std::move(members), annotations); - cleanup_stmt_.push_back(o); - return o; +while_stmt::while_stmt(token* while_keyword, expr* expression, stmt* while_body) + : while_keyword_(while_keyword), expression_(expression), while_body_(while_body) {} +void while_stmt::accept(stmt_visitor *v) { + v->visit_while_stmt(this); +} +ast_type while_stmt::get_type() { + return ast_type::STMT_WHILE; +} +token* while_stmt::locate() { + return while_keyword_; } -while_stmt::while_stmt(token *while_keyword, expr *expression, stmt *while_body) - : while_keyword_(while_keyword), expression_(expression), - while_body_(while_body) {} -void while_stmt::accept(stmt_visitor *v) { v->visit_while_stmt(this); } -ast_type while_stmt::get_type() { return ast_type::STMT_WHILE; } -token *while_stmt::locate() { return while_keyword_; } -stmt *ast_pool::c_while_stmt(token *while_keyword, expr *expression, - stmt *while_body) { +stmt *ast_pool::c_while_stmt(token* while_keyword, expr* expression, stmt* while_body) { auto o = new while_stmt(while_keyword, expression, while_body); cleanup_stmt_.push_back(o); return o; +}dsl_macro_stmt::dsl_macro_stmt(token* name, token* name2, token* not_symbol_tok, token* curly_open, std::vector internal_soup, token* curly_close) + : name_(name), name2_(name2), not_symbol_tok_(not_symbol_tok), curly_open_(curly_open), internal_soup_(std::move(internal_soup)), curly_close_(curly_close) {} +ast_type dsl_macro_stmt::get_type() { + return ast_type::STMT_DSL_MACRO; } -dsl_macro_stmt::dsl_macro_stmt(token *name, token *name2, token *not_symbol_tok, - token *curly_open, - std::vector internal_soup, - token *curly_close) - : name_(name), name2_(name2), not_symbol_tok_(not_symbol_tok), - curly_open_(curly_open), internal_soup_(std::move(internal_soup)), - curly_close_(curly_close) {} -ast_type dsl_macro_stmt::get_type() { return ast_type::STMT_DSL_MACRO; } -void dsl_macro_stmt::accept(stmt_visitor *v) {} -token *dsl_macro_stmt::locate() { return name_; } -stmt *ast_pool::c_dsl_macro_stmt(token *name, token *name2, - token *not_symbol_tok, token *curly_open, - std::vector internal_soup, - token *curly_close) { - auto o = new dsl_macro_stmt(name, name2, not_symbol_tok, curly_open, - std::move(internal_soup), curly_close); +void dsl_macro_stmt::accept(stmt_visitor *v) { +} +token* dsl_macro_stmt::locate() { + return name_; +} +stmt *ast_pool::c_dsl_macro_stmt(token* name, token* name2, token* not_symbol_tok, token* curly_open, std::vector internal_soup, token* curly_close) { + auto o = new dsl_macro_stmt(name, name2, not_symbol_tok, curly_open, std::move(internal_soup), curly_close); cleanup_stmt_.push_back(o); return o; } -elif_stmt::elif_stmt(token *elif_keyword, expr *expression, stmt *elif_branch) - : elif_keyword_(elif_keyword), expression_(expression), - elif_branch_(elif_branch) {} -ast_type elif_stmt::get_type() { return ast_type::STMT_ELIF; } -void elif_stmt::accept(stmt_visitor *v) {} -token *elif_stmt::locate() { return elif_keyword_; } -stmt *ast_pool::c_elif_stmt(token *elif_keyword, expr *expression, - stmt *elif_branch) { +elif_stmt::elif_stmt(token* elif_keyword, expr* expression, stmt* elif_branch) + : elif_keyword_(elif_keyword), expression_(expression), elif_branch_(elif_branch) {} +ast_type elif_stmt::get_type() { + return ast_type::STMT_ELIF; +} +void elif_stmt::accept(stmt_visitor *v) { +} +token* elif_stmt::locate() { + return elif_keyword_; +} +stmt *ast_pool::c_elif_stmt(token* elif_keyword, expr* expression, stmt* elif_branch) { auto o = new elif_stmt(elif_keyword, expression, elif_branch); cleanup_stmt_.push_back(o); return o; } -macros_stmt::macros_stmt(token *macros_token, token *not_symbol_tok, - token *curly_open, std::vector lisp_code, - token *curly_close) - : macros_token_(macros_token), not_symbol_tok_(not_symbol_tok), - curly_open_(curly_open), lisp_code_(std::move(lisp_code)), - curly_close_(curly_close) {} -ast_type macros_stmt::get_type() { return ast_type::STMT_MACROS; } -void macros_stmt::accept(stmt_visitor *v) {} -token *macros_stmt::locate() { return macros_token_; } -stmt *ast_pool::c_macros_stmt(token *macros_token, token *not_symbol_tok, - token *curly_open, std::vector lisp_code, - token *curly_close) { - auto o = new macros_stmt(macros_token, not_symbol_tok, curly_open, - std::move(lisp_code), curly_close); +macros_stmt::macros_stmt(token* macros_token, token* not_symbol_tok, token* curly_open, std::vector lisp_code, token* curly_close) + : macros_token_(macros_token), not_symbol_tok_(not_symbol_tok), curly_open_(curly_open), lisp_code_(std::move(lisp_code)), curly_close_(curly_close) {} +ast_type macros_stmt::get_type() { + return ast_type::STMT_MACROS; +} +void macros_stmt::accept(stmt_visitor *v) { +} +token* macros_stmt::locate() { + return macros_token_; +} +stmt *ast_pool::c_macros_stmt(token* macros_token, token* not_symbol_tok, token* curly_open, std::vector lisp_code, token* curly_close) { + auto o = new macros_stmt(macros_token, not_symbol_tok, curly_open, std::move(lisp_code), curly_close); cleanup_stmt_.push_back(o); return o; } -token_soup_stmt::token_soup_stmt(std::vector soup) +token_soup_stmt::token_soup_stmt(std::vector soup) : soup_(std::move(soup)) {} -ast_type token_soup_stmt::get_type() { return ast_type::STMT_TOKEN_SOUP; } -void token_soup_stmt::accept(stmt_visitor *v) {} -token *token_soup_stmt::locate() { return soup_[0]; } -stmt *ast_pool::c_token_soup_stmt(std::vector soup) { +ast_type token_soup_stmt::get_type() { + return ast_type::STMT_TOKEN_SOUP; +} +void token_soup_stmt::accept(stmt_visitor *v) { +} +token* token_soup_stmt::locate() { + return soup_[0]; +} +stmt *ast_pool::c_token_soup_stmt(std::vector soup) { auto o = new token_soup_stmt(std::move(soup)); cleanup_stmt_.push_back(o); return o; } // ------- utils ------ ast_pool::~ast_pool() { - for (auto e : cleanup_expr_) { delete e; } - for (auto e : cleanup_stmt_) { delete e; } + for (auto e : cleanup_expr_) { + delete e; + } + for (auto e : cleanup_stmt_) { + delete e; + } cleanup_expr_.clear(); cleanup_stmt_.clear(); } diff --git a/compiler/src/ast/ast.h b/compiler/src/ast/ast.h index a90581e8..d7df41d6 100644 --- a/compiler/src/ast/ast.h +++ b/compiler/src/ast/ast.h @@ -1,41 +1,3 @@ -// ============================================================================================== -// ╦ ┬┌─┐┌─┐┌┐┌┌─┐┌─┐ Yaksha Programming Language -// ║ ││ ├┤ │││└─┐├┤ is Licensed with GPLv3 + extra terms. Please see below. -// ╩═╝┴└─┘└─┘┘└┘└─┘└─┘ -// Note: libs - MIT license, runtime/3rd - various -// ============================================================================================== -// GPLv3: -// -// Yaksha - Programming Language. -// Copyright (C) 2020 - 2024 Bhathiya Perera -// -// This program is free software: you can redistribute it and/or modify it under the terms -// of the GNU General Public License as published by the Free Software Foundation, -// either version 3 of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -// See the GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License along with this program. -// If not, see https://www.gnu.org/licenses/. -// -// ============================================================================================== -// Additional Terms: -// -// Please note that any commercial use of the programming language's compiler source code -// (everything except compiler/runtime, compiler/libs and compiler/3rd) require a written agreement -// with author of the language (Bhathiya Perera). -// -// If you are using it for an open source project, please give credits. -// Your own project must use GPLv3 license with these additional terms. -// -// You may use programs written in Yaksha/YakshaLisp for any legal purpose -// (commercial, open-source, closed-source, etc) as long as it agrees -// to the licenses of linked runtime libraries (see compiler/runtime/README.md). -// -// ============================================================================================== // ast.h // generated by update_ast.py #ifndef AST_H @@ -93,7 +55,6 @@ namespace yaksha { struct return_stmt; struct runtimefeature_stmt; struct token_soup_stmt; - struct union_stmt; struct while_stmt; // Types of expressions and statements enum class ast_type { @@ -140,7 +101,6 @@ namespace yaksha { STMT_RETURN, STMT_RUNTIMEFEATURE, STMT_TOKEN_SOUP, - STMT_UNION, STMT_WHILE }; // ------ expression visitor ------ @@ -190,7 +150,6 @@ namespace yaksha { virtual void visit_pass_stmt(pass_stmt *obj) = 0; virtual void visit_return_stmt(return_stmt *obj) = 0; virtual void visit_runtimefeature_stmt(runtimefeature_stmt *obj) = 0; - virtual void visit_union_stmt(union_stmt *obj) = 0; virtual void visit_while_stmt(while_stmt *obj) = 0; virtual ~stmt_visitor() = default; }; @@ -629,16 +588,6 @@ namespace yaksha { token *locate() override; std::vector soup_; }; - struct union_stmt : stmt { - union_stmt(token *name, std::vector members, - annotations annotations); - void accept(stmt_visitor *v) override; - ast_type get_type() override; - token *locate() override; - token *name_; - std::vector members_; - annotations annotations_; - }; struct while_stmt : stmt { while_stmt(token *while_keyword, expr *expression, stmt *while_body); void accept(stmt_visitor *v) override; @@ -725,8 +674,6 @@ namespace yaksha { ykdatatype *result_type); stmt *c_runtimefeature_stmt(token *runtimefeature_token, token *feature); stmt *c_token_soup_stmt(std::vector soup); - stmt *c_union_stmt(token *name, std::vector members, - annotations annotations); stmt *c_while_stmt(token *while_keyword, expr *expression, stmt *while_body); diff --git a/compiler/src/ast/ast_printer.cpp b/compiler/src/ast/ast_printer.cpp index c82f279f..d431d6b6 100644 --- a/compiler/src/ast/ast_printer.cpp +++ b/compiler/src/ast/ast_printer.cpp @@ -289,5 +289,4 @@ void ast_printer::visit_macro_call_expr(macro_call_expr *obj) { } void ast_printer::visit_cfor_stmt(cfor_stmt *obj) {} void ast_printer::visit_enum_stmt(enum_stmt *obj) {} -void ast_printer::visit_union_stmt(union_stmt *obj) {} void ast_printer::visit_directive_stmt(directive_stmt *obj) {} diff --git a/compiler/src/ast/ast_printer.h b/compiler/src/ast/ast_printer.h index e53f24d3..42a76250 100644 --- a/compiler/src/ast/ast_printer.h +++ b/compiler/src/ast/ast_printer.h @@ -97,7 +97,6 @@ namespace yaksha { void visit_macro_call_expr(macro_call_expr *obj) override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; private: diff --git a/compiler/src/ast/ast_vis.cpp b/compiler/src/ast/ast_vis.cpp index f49d054d..5aa841f3 100644 --- a/compiler/src/ast/ast_vis.cpp +++ b/compiler/src/ast/ast_vis.cpp @@ -396,5 +396,4 @@ void ast_vis::visit_macro_call_expr(macro_call_expr *obj) { } void ast_vis::visit_cfor_stmt(cfor_stmt *obj) {} void ast_vis::visit_enum_stmt(enum_stmt *obj) {} -void ast_vis::visit_union_stmt(union_stmt *obj) {} void ast_vis::visit_directive_stmt(directive_stmt *obj) {} diff --git a/compiler/src/ast/ast_vis.h b/compiler/src/ast/ast_vis.h index f1b5e4a4..a70a98c0 100644 --- a/compiler/src/ast/ast_vis.h +++ b/compiler/src/ast/ast_vis.h @@ -101,7 +101,6 @@ namespace yaksha { void visit_macro_call_expr(macro_call_expr *obj) override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; private: diff --git a/compiler/src/compiler/codegen_json.cpp b/compiler/src/compiler/codegen_json.cpp index b86fdfda..e7787484 100644 --- a/compiler/src/compiler/codegen_json.cpp +++ b/compiler/src/compiler/codegen_json.cpp @@ -569,9 +569,6 @@ void to_json_compiler::visit_runtimefeature_stmt(runtimefeature_stmt *obj) { json_ << "\"feature\": \"" << obj->feature_->token_ << "\"\n"; json_ << "}\n"; } -void to_json_compiler::visit_union_stmt(union_stmt *obj) { - // Placeholder statement - this is not parsed -} void to_json_compiler::visit_while_stmt(while_stmt *obj) { json_ << "{\n"; write_location(obj); diff --git a/compiler/src/compiler/codegen_json.h b/compiler/src/compiler/codegen_json.h index 2876f319..28d2afd9 100644 --- a/compiler/src/compiler/codegen_json.h +++ b/compiler/src/compiler/codegen_json.h @@ -93,7 +93,6 @@ namespace yaksha { void visit_pass_stmt(pass_stmt *obj) override; void visit_return_stmt(return_stmt *obj) override; void visit_runtimefeature_stmt(runtimefeature_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_while_stmt(while_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; ~to_json_compiler() override = default; diff --git a/compiler/src/compiler/const_fold.cpp b/compiler/src/compiler/const_fold.cpp index bf2d7732..4ea436bb 100644 --- a/compiler/src/compiler/const_fold.cpp +++ b/compiler/src/compiler/const_fold.cpp @@ -341,7 +341,6 @@ void const_fold::visit_return_stmt(return_stmt *obj) { void const_fold::visit_runtimefeature_stmt(runtimefeature_stmt *obj) { store_statement(obj); } -void const_fold::visit_union_stmt(union_stmt *obj) { store_statement(obj); } void const_fold::visit_while_stmt(while_stmt *obj) { statement_stack_.back()->emplace_back(wrap(obj)); } diff --git a/compiler/src/compiler/const_fold.h b/compiler/src/compiler/const_fold.h index 7e6e34cf..024244e7 100644 --- a/compiler/src/compiler/const_fold.h +++ b/compiler/src/compiler/const_fold.h @@ -128,7 +128,6 @@ namespace yaksha { void visit_pass_stmt(pass_stmt *obj) override; void visit_return_stmt(return_stmt *obj) override; void visit_runtimefeature_stmt(runtimefeature_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_while_stmt(while_stmt *obj) override; std::vector errors_; diff --git a/compiler/src/compiler/def_class_visitor.cpp b/compiler/src/compiler/def_class_visitor.cpp index d68f9eb2..c1c534bb 100644 --- a/compiler/src/compiler/def_class_visitor.cpp +++ b/compiler/src/compiler/def_class_visitor.cpp @@ -283,7 +283,6 @@ void def_class_visitor::visit_curly_call_expr(curly_call_expr *obj) {} void def_class_visitor::visit_macro_call_expr(macro_call_expr *obj) {} void def_class_visitor::visit_cfor_stmt(cfor_stmt *obj) {} void def_class_visitor::visit_enum_stmt(enum_stmt *obj) {} -void def_class_visitor::visit_union_stmt(union_stmt *obj) {} void def_class_visitor::visit_directive_stmt(directive_stmt *obj) { obj->hits_ = 1;// Always consider this to be used! auto directive_type = obj->directive_type_->token_; diff --git a/compiler/src/compiler/def_class_visitor.h b/compiler/src/compiler/def_class_visitor.h index e251badc..e65d18e8 100644 --- a/compiler/src/compiler/def_class_visitor.h +++ b/compiler/src/compiler/def_class_visitor.h @@ -105,7 +105,6 @@ namespace yaksha { void visit_macro_call_expr(macro_call_expr *obj) override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; std::vector get_all_names(); std::vector function_names_{}; diff --git a/compiler/src/compiler/desugaring_compiler.cpp b/compiler/src/compiler/desugaring_compiler.cpp index 7187147b..516e81cb 100644 --- a/compiler/src/compiler/desugaring_compiler.cpp +++ b/compiler/src/compiler/desugaring_compiler.cpp @@ -444,9 +444,6 @@ void desugaring_compiler::visit_cfor_stmt(cfor_stmt *obj) { void desugaring_compiler::visit_enum_stmt(enum_stmt *obj) { statement_stack_.back()->emplace_back(obj); } -void desugaring_compiler::visit_union_stmt(union_stmt *obj) { - statement_stack_.back()->emplace_back(obj); -} void desugaring_compiler::visit_directive_stmt(directive_stmt *obj) { statement_stack_.back()->emplace_back(obj); } diff --git a/compiler/src/compiler/desugaring_compiler.h b/compiler/src/compiler/desugaring_compiler.h index e8301d7b..547ddd2f 100644 --- a/compiler/src/compiler/desugaring_compiler.h +++ b/compiler/src/compiler/desugaring_compiler.h @@ -110,7 +110,6 @@ namespace yaksha { void visit_while_stmt(while_stmt *obj) override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void desugar_fixed_arr_foreach(foreach_stmt *obj); void desugar_arr_foreach(foreach_stmt *obj); void visit_directive_stmt(directive_stmt *obj) override; diff --git a/compiler/src/compiler/return_checker.cpp b/compiler/src/compiler/return_checker.cpp index b6931c0e..6da516e5 100644 --- a/compiler/src/compiler/return_checker.cpp +++ b/compiler/src/compiler/return_checker.cpp @@ -93,7 +93,6 @@ void return_checker::visit_return_stmt(return_stmt *obj) { found_returns_.push_back(true); } void return_checker::visit_runtimefeature_stmt(runtimefeature_stmt *obj) {} -void return_checker::visit_union_stmt(union_stmt *obj) {} void return_checker::visit_while_stmt(while_stmt *obj) {} bool return_checker::found_return() { if (found_returns_.empty()) { return false; } diff --git a/compiler/src/compiler/return_checker.h b/compiler/src/compiler/return_checker.h index 6320f2f7..895d0903 100644 --- a/compiler/src/compiler/return_checker.h +++ b/compiler/src/compiler/return_checker.h @@ -66,7 +66,6 @@ namespace yaksha { void visit_pass_stmt(pass_stmt *obj) override; void visit_return_stmt(return_stmt *obj) override; void visit_runtimefeature_stmt(runtimefeature_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_while_stmt(while_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; std::vector errors_{}; diff --git a/compiler/src/compiler/to_c_compiler.cpp b/compiler/src/compiler/to_c_compiler.cpp index ac8c4f85..3583cf9d 100644 --- a/compiler/src/compiler/to_c_compiler.cpp +++ b/compiler/src/compiler/to_c_compiler.cpp @@ -1910,7 +1910,6 @@ void to_c_compiler::visit_cfor_stmt(cfor_stmt *obj) { deletions_.pop_delete_stack(); } void to_c_compiler::visit_enum_stmt(enum_stmt *obj) {} -void to_c_compiler::visit_union_stmt(union_stmt *obj) {} void to_c_compiler::visit_directive_stmt(directive_stmt *obj) { // TODO add support for parameters if (obj->directive_type_->token_ == "ccode") { diff --git a/compiler/src/compiler/to_c_compiler.h b/compiler/src/compiler/to_c_compiler.h index 6a897213..f47aa854 100644 --- a/compiler/src/compiler/to_c_compiler.h +++ b/compiler/src/compiler/to_c_compiler.h @@ -137,7 +137,6 @@ namespace yaksha { wrap_in_paren(const std::string &code) const override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; private: diff --git a/compiler/src/compiler/type_checker.cpp b/compiler/src/compiler/type_checker.cpp index 660b4fef..0c5a4afa 100644 --- a/compiler/src/compiler/type_checker.cpp +++ b/compiler/src/compiler/type_checker.cpp @@ -1111,7 +1111,7 @@ void type_checker::visit_const_stmt(const_stmt *obj) { auto match = type_match(obj->data_type_->args_[0], expression_dt, true); if (match.matched_) { placeholder = expression_data; - placeholder.datatype_ = obj->data_type_; // Set the correct data type + placeholder.datatype_ = obj->data_type_;// Set the correct data type } else { std::stringstream message{}; message << "Constant '" << name << "' data type mismatch. "; @@ -1152,7 +1152,8 @@ type_match_result type_checker::type_match(ykdatatype *required_datatype, if (castable != nullptr) { return type_match_result{"", true, true}; } } // Pass a Type to a Const[Type] is allowed (becomes more restrictive) - if (primitive_or_obj && is_identical_type(required_datatype->const_unwrap(), provided_datatype)) { + if (primitive_or_obj && + is_identical_type(required_datatype->const_unwrap(), provided_datatype)) { return type_match_result{"", true, false}; } std::stringstream message{}; @@ -1436,5 +1437,4 @@ void type_checker::visit_cfor_stmt(cfor_stmt *obj) { pop_scope_type(); } void type_checker::visit_enum_stmt(enum_stmt *obj) {} -void type_checker::visit_union_stmt(union_stmt *obj) {} void type_checker::visit_directive_stmt(directive_stmt *obj) {} diff --git a/compiler/src/compiler/type_checker.h b/compiler/src/compiler/type_checker.h index fcd5e9da..78890ae4 100644 --- a/compiler/src/compiler/type_checker.h +++ b/compiler/src/compiler/type_checker.h @@ -107,7 +107,6 @@ namespace yaksha { void visit_macro_call_expr(macro_call_expr *obj) override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; /** * Errors vector, type checker will try and identify as much errors as possible diff --git a/compiler/src/compiler/usage_analyser.cpp b/compiler/src/compiler/usage_analyser.cpp index 125df6a9..4e0c61df 100644 --- a/compiler/src/compiler/usage_analyser.cpp +++ b/compiler/src/compiler/usage_analyser.cpp @@ -452,5 +452,4 @@ void usage_analyser::visit_cfor_stmt(cfor_stmt *obj) { obj->for_body_->accept(this); } void usage_analyser::visit_enum_stmt(enum_stmt *obj) { obj->hits_++; } -void usage_analyser::visit_union_stmt(union_stmt *obj) { obj->hits_++; } void usage_analyser::visit_directive_stmt(directive_stmt *obj) { obj->hits_++; } diff --git a/compiler/src/compiler/usage_analyser.h b/compiler/src/compiler/usage_analyser.h index a1d7fb3e..c6e215bf 100644 --- a/compiler/src/compiler/usage_analyser.h +++ b/compiler/src/compiler/usage_analyser.h @@ -88,7 +88,6 @@ namespace yaksha { ~usage_analyser() override; void visit_cfor_stmt(cfor_stmt *obj) override; void visit_enum_stmt(enum_stmt *obj) override; - void visit_union_stmt(union_stmt *obj) override; void visit_directive_stmt(directive_stmt *obj) override; std::vector errors_{}; diff --git a/compiler/src/tokenizer/token.h b/compiler/src/tokenizer/token.h index 67211fd7..ab8dff88 100644 --- a/compiler/src/tokenizer/token.h +++ b/compiler/src/tokenizer/token.h @@ -1,41 +1,3 @@ -// ============================================================================================== -// ╦ ┬┌─┐┌─┐┌┐┌┌─┐┌─┐ Yaksha Programming Language -// ║ ││ ├┤ │││└─┐├┤ is Licensed with GPLv3 + extra terms. Please see below. -// ╩═╝┴└─┘└─┘┘└┘└─┘└─┘ -// Note: libs - MIT license, runtime/3rd - various -// ============================================================================================== -// GPLv3: -// -// Yaksha - Programming Language. -// Copyright (C) 2020 - 2024 Bhathiya Perera -// -// This program is free software: you can redistribute it and/or modify it under the terms -// of the GNU General Public License as published by the Free Software Foundation, -// either version 3 of the License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -// or FITNESS FOR A PARTICULAR PURPOSE. -// See the GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License along with this program. -// If not, see https://www.gnu.org/licenses/. -// -// ============================================================================================== -// Additional Terms: -// -// Please note that any commercial use of the programming language's compiler source code -// (everything except compiler/runtime, compiler/libs and compiler/3rd) require a written agreement -// with author of the language (Bhathiya Perera). -// -// If you are using it for an open source project, please give credits. -// Your own project must use GPLv3 license with these additional terms. -// -// You may use programs written in Yaksha/YakshaLisp for any legal purpose -// (commercial, open-source, closed-source, etc) as long as it agrees -// to the licenses of linked runtime libraries (see compiler/runtime/README.md). -// -// ============================================================================================== // token.h // generated by update_tokens.py #ifndef TOKEN_H @@ -157,6 +119,7 @@ namespace yaksha { KEYWORD_DIRECTIVE, KEYWORD_ELIF, KEYWORD_ELSE, + KEYWORD_ENUM, KEYWORD_FOR, KEYWORD_FROM, KEYWORD_IF, @@ -192,6 +155,7 @@ namespace yaksha { case token_type::KEYWORD_DIRECTIVE: case token_type::KEYWORD_ELIF: case token_type::KEYWORD_ELSE: + case token_type::KEYWORD_ENUM: case token_type::KEYWORD_FOR: case token_type::KEYWORD_FROM: case token_type::KEYWORD_IF: @@ -327,6 +291,7 @@ namespace yaksha { if (t == token_type::KEYWORD_DIRECTIVE) return "KEYWORD_DIRECTIVE"; if (t == token_type::KEYWORD_ELIF) return "KEYWORD_ELIF"; if (t == token_type::KEYWORD_ELSE) return "KEYWORD_ELSE"; + if (t == token_type::KEYWORD_ENUM) return "KEYWORD_ENUM"; if (t == token_type::KEYWORD_FOR) return "KEYWORD_FOR"; if (t == token_type::KEYWORD_FROM) return "KEYWORD_FROM"; if (t == token_type::KEYWORD_IF) return "KEYWORD_IF"; @@ -454,6 +419,7 @@ namespace yaksha { if (t == "KEYWORD_DIRECTIVE") return token_type::KEYWORD_DIRECTIVE; if (t == "KEYWORD_ELIF") return token_type::KEYWORD_ELIF; if (t == "KEYWORD_ELSE") return token_type::KEYWORD_ELSE; + if (t == "KEYWORD_ENUM") return token_type::KEYWORD_ENUM; if (t == "KEYWORD_FOR") return token_type::KEYWORD_FOR; if (t == "KEYWORD_FROM") return token_type::KEYWORD_FROM; if (t == "KEYWORD_IF") return token_type::KEYWORD_IF; @@ -488,6 +454,7 @@ namespace yaksha { if (t == "directive") return token_type::KEYWORD_DIRECTIVE; if (t == "elif") return token_type::KEYWORD_ELIF; if (t == "else") return token_type::KEYWORD_ELSE; + if (t == "enum") return token_type::KEYWORD_ENUM; if (t == "for") return token_type::KEYWORD_FOR; if (t == "from") return token_type::KEYWORD_FROM; if (t == "if") return token_type::KEYWORD_IF; @@ -607,20 +574,21 @@ namespace yaksha { if (n == 28970) return token_type::KEYWORD_DIRECTIVE; if (n == 28971) return token_type::KEYWORD_ELIF; if (n == 28972) return token_type::KEYWORD_ELSE; - if (n == 28973) return token_type::KEYWORD_FOR; - if (n == 28974) return token_type::KEYWORD_FROM; - if (n == 28975) return token_type::KEYWORD_IF; - if (n == 28976) return token_type::KEYWORD_IMPORT; - if (n == 28977) return token_type::KEYWORD_IN; - if (n == 28978) return token_type::KEYWORD_MACROS; - if (n == 28979) return token_type::KEYWORD_NOT; - if (n == 28980) return token_type::KEYWORD_OR; - if (n == 28981) return token_type::KEYWORD_PASS; - if (n == 28982) return token_type::KEYWORD_RETURN; - if (n == 28983) return token_type::KEYWORD_RUNTIMEFEATURE; - if (n == 28984) return token_type::KEYWORD_STRUCT; - if (n == 28985) return token_type::KEYWORD_TRY; - if (n == 28986) return token_type::KEYWORD_WHILE; + if (n == 28973) return token_type::KEYWORD_ENUM; + if (n == 28974) return token_type::KEYWORD_FOR; + if (n == 28975) return token_type::KEYWORD_FROM; + if (n == 28976) return token_type::KEYWORD_IF; + if (n == 28977) return token_type::KEYWORD_IMPORT; + if (n == 28978) return token_type::KEYWORD_IN; + if (n == 28979) return token_type::KEYWORD_MACROS; + if (n == 28980) return token_type::KEYWORD_NOT; + if (n == 28981) return token_type::KEYWORD_OR; + if (n == 28982) return token_type::KEYWORD_PASS; + if (n == 28983) return token_type::KEYWORD_RETURN; + if (n == 28984) return token_type::KEYWORD_RUNTIMEFEATURE; + if (n == 28985) return token_type::KEYWORD_STRUCT; + if (n == 28986) return token_type::KEYWORD_TRY; + if (n == 28987) return token_type::KEYWORD_WHILE; return token_type::TK_UNKNOWN_TOKEN_DETECTED; } static inline int64_t token_to_numeric_id(const token_type &t) { @@ -726,20 +694,21 @@ namespace yaksha { if (t == token_type::KEYWORD_DIRECTIVE) return 28970; if (t == token_type::KEYWORD_ELIF) return 28971; if (t == token_type::KEYWORD_ELSE) return 28972; - if (t == token_type::KEYWORD_FOR) return 28973; - if (t == token_type::KEYWORD_FROM) return 28974; - if (t == token_type::KEYWORD_IF) return 28975; - if (t == token_type::KEYWORD_IMPORT) return 28976; - if (t == token_type::KEYWORD_IN) return 28977; - if (t == token_type::KEYWORD_MACROS) return 28978; - if (t == token_type::KEYWORD_NOT) return 28979; - if (t == token_type::KEYWORD_OR) return 28980; - if (t == token_type::KEYWORD_PASS) return 28981; - if (t == token_type::KEYWORD_RETURN) return 28982; - if (t == token_type::KEYWORD_RUNTIMEFEATURE) return 28983; - if (t == token_type::KEYWORD_STRUCT) return 28984; - if (t == token_type::KEYWORD_TRY) return 28985; - if (t == token_type::KEYWORD_WHILE) return 28986; + if (t == token_type::KEYWORD_ENUM) return 28973; + if (t == token_type::KEYWORD_FOR) return 28974; + if (t == token_type::KEYWORD_FROM) return 28975; + if (t == token_type::KEYWORD_IF) return 28976; + if (t == token_type::KEYWORD_IMPORT) return 28977; + if (t == token_type::KEYWORD_IN) return 28978; + if (t == token_type::KEYWORD_MACROS) return 28979; + if (t == token_type::KEYWORD_NOT) return 28980; + if (t == token_type::KEYWORD_OR) return 28981; + if (t == token_type::KEYWORD_PASS) return 28982; + if (t == token_type::KEYWORD_RETURN) return 28983; + if (t == token_type::KEYWORD_RUNTIMEFEATURE) return 28984; + if (t == token_type::KEYWORD_STRUCT) return 28985; + if (t == token_type::KEYWORD_TRY) return 28986; + if (t == token_type::KEYWORD_WHILE) return 28987; return 0; } static inline bool is_number_token(const token_type &t) { @@ -926,6 +895,7 @@ namespace yaksha { if (t == token_type::KEYWORD_DIRECTIVE) return (value == "directive"); if (t == token_type::KEYWORD_ELIF) return (value == "elif"); if (t == token_type::KEYWORD_ELSE) return (value == "else"); + if (t == token_type::KEYWORD_ENUM) return (value == "enum"); if (t == token_type::KEYWORD_FOR) return (value == "for"); if (t == token_type::KEYWORD_FROM) return (value == "from"); if (t == token_type::KEYWORD_IF) return (value == "if"); diff --git a/compiler/src/yaksha_lisp/prelude_token_gen.yaka b/compiler/src/yaksha_lisp/prelude_token_gen.yaka index 114fe51b..185c6862 100644 --- a/compiler/src/yaksha_lisp/prelude_token_gen.yaka +++ b/compiler/src/yaksha_lisp/prelude_token_gen.yaka @@ -60,6 +60,7 @@ (defun ykt_keyword_directive () (yk_create_token YK_TOKEN_KEYWORD_DIRECTIVE "directive")) (defun ykt_keyword_elif () (yk_create_token YK_TOKEN_KEYWORD_ELIF "elif")) (defun ykt_keyword_else () (yk_create_token YK_TOKEN_KEYWORD_ELSE "else")) + (defun ykt_keyword_enum () (yk_create_token YK_TOKEN_KEYWORD_ENUM "enum")) (defun ykt_keyword_for () (yk_create_token YK_TOKEN_KEYWORD_FOR "for")) (defun ykt_keyword_from () (yk_create_token YK_TOKEN_KEYWORD_FROM "from")) (defun ykt_keyword_if () (yk_create_token YK_TOKEN_KEYWORD_IF "if")) diff --git a/compiler/src/yaksha_lisp/prelude_tokens.yaka b/compiler/src/yaksha_lisp/prelude_tokens.yaka index ab8f620d..025a2ad5 100644 --- a/compiler/src/yaksha_lisp/prelude_tokens.yaka +++ b/compiler/src/yaksha_lisp/prelude_tokens.yaka @@ -100,17 +100,18 @@ (def YK_TOKEN_KEYWORD_DIRECTIVE 28970) (def YK_TOKEN_KEYWORD_ELIF 28971) (def YK_TOKEN_KEYWORD_ELSE 28972) - (def YK_TOKEN_KEYWORD_FOR 28973) - (def YK_TOKEN_KEYWORD_FROM 28974) - (def YK_TOKEN_KEYWORD_IF 28975) - (def YK_TOKEN_KEYWORD_IMPORT 28976) - (def YK_TOKEN_KEYWORD_IN 28977) - (def YK_TOKEN_KEYWORD_MACROS 28978) - (def YK_TOKEN_KEYWORD_NOT 28979) - (def YK_TOKEN_KEYWORD_OR 28980) - (def YK_TOKEN_KEYWORD_PASS 28981) - (def YK_TOKEN_KEYWORD_RETURN 28982) - (def YK_TOKEN_KEYWORD_RUNTIMEFEATURE 28983) - (def YK_TOKEN_KEYWORD_STRUCT 28984) - (def YK_TOKEN_KEYWORD_TRY 28985) - (def YK_TOKEN_KEYWORD_WHILE 28986) \ No newline at end of file + (def YK_TOKEN_KEYWORD_ENUM 28973) + (def YK_TOKEN_KEYWORD_FOR 28974) + (def YK_TOKEN_KEYWORD_FROM 28975) + (def YK_TOKEN_KEYWORD_IF 28976) + (def YK_TOKEN_KEYWORD_IMPORT 28977) + (def YK_TOKEN_KEYWORD_IN 28978) + (def YK_TOKEN_KEYWORD_MACROS 28979) + (def YK_TOKEN_KEYWORD_NOT 28980) + (def YK_TOKEN_KEYWORD_OR 28981) + (def YK_TOKEN_KEYWORD_PASS 28982) + (def YK_TOKEN_KEYWORD_RETURN 28983) + (def YK_TOKEN_KEYWORD_RUNTIMEFEATURE 28984) + (def YK_TOKEN_KEYWORD_STRUCT 28985) + (def YK_TOKEN_KEYWORD_TRY 28986) + (def YK_TOKEN_KEYWORD_WHILE 28987) \ No newline at end of file