✨ add nasal_new_lexer

ast/ast_visitor.cpp

@@ -1,21 +1,29 @@
 #include "ast_visitor.h"
 
-void ast_visitor::visit_expr(expr* node) {
+bool ast_visitor::visit_expr(expr* node) {
     node->accept(this);
 }
 
-void ast_visitor::visit_null_expr(null_expr* node) {
-    node->accept(this);
+bool ast_visitor::visit_null_expr(null_expr* node) {
+    return true;
 }
 
-void ast_visitor::visit_nil_expr(nil_expr* node) {
-    node->accept(this);
+bool ast_visitor::visit_nil_expr(nil_expr* node) {
+    return true;
 }
 
-void ast_visitor::visit_number_literal(number_literal* node) {
-    node->accept(this);
+bool ast_visitor::visit_number_literal(number_literal* node) {
+    return true;
 }
 
-void ast_visitor::visit_string_literal(string_literal* node) {
-    node->accept(this);
+bool ast_visitor::visit_string_literal(string_literal* node) {
+    return true;
+}
+
+bool ast_visitor::visit_identifier(identifier* node) {
+    return true;
+}
+
+bool ast_visitor::visit_bool_literal(bool_literal* node) {
+    return true;
 }

ast/ast_visitor.h

@@ -4,9 +4,11 @@
 
 class ast_visitor {
 public:
-    virtual void visit_expr(expr*);
-    virtual void visit_null_expr(null_expr*);
-    virtual void visit_nil_expr(nil_expr*);
-    virtual void visit_number_literal(number_literal*);
-    virtual void visit_string_literal(string_literal*);
+    virtual bool visit_expr(expr*);
+    virtual bool visit_null_expr(null_expr*);
+    virtual bool visit_nil_expr(nil_expr*);
+    virtual bool visit_number_literal(number_literal*);
+    virtual bool visit_string_literal(string_literal*);
+    virtual bool visit_identifier(identifier*);
+    virtual bool visit_bool_literal(bool_literal*);
 };

ast/nasal_new_ast.cpp

@@ -1,27 +1,30 @@
 #include "nasal_new_ast.h"
 #include "ast_visitor.h"
 
-bool expr::accept(ast_visitor* visitor) {
+void expr::accept(ast_visitor* visitor) {
     visitor->visit_expr(this);
-    return true;
 }
 
-bool null_expr::accept(ast_visitor* visitor) {
+void null_expr::accept(ast_visitor* visitor) {
     visitor->visit_null_expr(this);
-    return true;
 }
 
-bool nil_expr::accept(ast_visitor* visitor) {
+void nil_expr::accept(ast_visitor* visitor) {
     visitor->visit_nil_expr(this);
-    return true;
 }
 
-bool number_literal::accept(ast_visitor* visitor) {
+void number_literal::accept(ast_visitor* visitor) {
     visitor->visit_number_literal(this);
-    return true;
 }
 
-bool string_literal::accept(ast_visitor* visitor) {
+void string_literal::accept(ast_visitor* visitor) {
     visitor->visit_string_literal(this);
-    return true;
+}
+
+void identifier::accept(ast_visitor* visitor) {
+    visitor->visit_identifier(this);
+}
+
+void bool_literal::accept(ast_visitor* visitor) {
+    visitor->visit_bool_literal(this);
 }

ast/nasal_new_ast.h

@@ -83,23 +83,23 @@ class expr {
     expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
-    virtual bool accept(ast_visitor*) = 0;
+    virtual void accept(ast_visitor*) = 0;
 };
 
 class null_expr:public expr {
 public:
     null_expr(const span& location):
         expr(location, expr_type::ast_null) {}
     ~null_expr() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
 class nil_expr:public expr {
 public:
     nil_expr(const span& location):
         expr(location, expr_type::ast_nil) {}
     ~nil_expr() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
 class number_literal:public expr {
@@ -110,7 +110,7 @@ class number_literal:public expr {
     number_literal(const span& location, const f64 num):
         expr(location, expr_type::ast_num), number(num) {}
     ~number_literal() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
 class string_literal:public expr {
@@ -121,57 +121,147 @@ class string_literal:public expr {
     string_literal(const span& location, const string& str):
         expr(location, expr_type::ast_str), content(str) {}
     ~string_literal() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
-class identifier:public expr {};
+class identifier:public expr {
+private:
+    string name;
+
+public:
+    identifier(const span& location, const string& str):
+        expr(location, expr_type::ast_id), name(str) {}
+    ~identifier() = default;
+    virtual void accept(ast_visitor*) override;
+};
 
-class bool_literal:public expr {};
+class bool_literal:public expr {
+private:
+    bool flag;
+
+public:
+    bool_literal(const span& location, const bool bool_flag):
+        expr(location, expr_type::ast_bool), flag(bool_flag) {}
+    ~bool_literal() = default;
+    virtual void accept(ast_visitor*) override;
+};
 
-class vector_expr:public expr {};
+class vector_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class hash_expr:public expr {};
+class hash_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class hash_pair:public expr {};
+class hash_pair:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class function:public expr {};
+class function:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class parameter:public expr {};
+class parameter:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class ternary_operator:public expr {};
+class ternary_operator:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class binary_operator:public expr {};
+class binary_operator:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class unary_operator:public expr {};
+class unary_operator:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_expr:public expr {};
+class call_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_hash:public expr {};
+class call_hash:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_vector:public expr {};
+class call_vector:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_function:public expr {};
+class call_function:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class slice_vector:public expr {};
+class slice_vector:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class definition:public expr {};
+class definition:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class multi_define:public expr {};
+class multi_define:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class while_expr:public expr {};
+class while_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class for_expr:public expr {};
+class for_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class foreach_expr:public expr {};
+class foreach_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class forindex_expr:public expr {};
+class forindex_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class condition_expr:public expr {};
+class condition_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class if_expr:public expr {};
+class if_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class continue_expr:public expr {};
+class continue_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class break_expr:public expr {};
+class break_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class return_expr:public expr {};
+class return_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};