ast.hpp

Go to the documentation of this file.

 
#pragma once
#include "../lexer/token.hpp"
#include <uchar.h>
#include <variant>
#include <memory>
#include <vector>
#include <cmath>
 
namespace AST {
    enum TypeValue {
        TYPE_BOOL,                              
        TYPE_CHAR,                              
        TYPE_SHORT,                             
        TYPE_INT,                               
        TYPE_LONG,                              
        TYPE_FLOAT,                             
        TYPE_DOUBLE,                            
        TYPE_NOTH,                              
        TYPE_STRING_LIT,                        
        TYPE_TRAIT,                             
        TYPE_CLASS,                             
        TYPE_MODULE,                            
    };
    
    struct Type {
        TypeValue type;                         
        std::string name;                       
        bool is_const;                          
        bool is_ptr;                            
        bool is_nullable;                       
        
        Type(TypeValue t, std::string n, bool ic = false, bool ip = false, bool in = false) : type(t), name(n), is_const(ic), is_ptr(ip), is_nullable(in) {}
 
        bool operator ==(Type& other) {
            return type == other.type && name == other.name && is_const == other.is_const && is_ptr == other.is_ptr && is_nullable == other.is_nullable;
        }
 
        bool operator !=(Type& other) {
            return !(*this == other);
        }
        
        std::string to_str() {
            std::stringstream ss;
            ss << (is_const ? "const " : "") << name << (is_ptr ? "*" : "") << (is_nullable ? "? " : "");
            return ss.str();
        }
    };

    struct Value {
        std::variant<bool, char8_t, int16_t, int32_t, int64_t, float_t, double_t, std::string> value;               
 
        Value(bool v)               : value(v) {}
        Value(char8_t v)            : value(v) {}
        Value(int16_t v)            : value(v) {}
        Value(int32_t v)            : value(v) {}
        Value(int64_t v)            : value(v) {}
        Value(float_t v)            : value(v) {}
        Value(double_t v)           : value(v) {}
        Value(std::string v)        : value(v) {}
    };

    struct Argument {
        std::string name;                                       
        Type type;                                              
 
        Argument(std::string n, Type t) : name(n), type(t) {}
    };

    enum AccessModifier {
        ACCESS_NONE,
        ACCESS_PRIVATE,
        ACCESS_PUBLIC,
    };
    
    class Stmt {
    public:
        uint32_t line;                                          
 
        Stmt(uint32_t l) : line(l) {}
        virtual ~Stmt() = default;
    };

    class Expr {
    public:
        uint32_t line;                                          
 
        Expr(uint32_t l) : line(l) {}
        virtual ~Expr() = default;
    };
 
    using StmtPtr = std::unique_ptr<Stmt>;
    using ExprPtr = std::unique_ptr<Expr>;
 
    // EXPRESSIONS

    class Literal : public Expr {
    public:
        Type type;                                              
        Value value;                                            
 
        Literal(Type t, Value v, uint32_t l) : type(t), value(v), Expr(l) {}
        ~Literal() override = default;
    };

    class BoolLiteral : public Literal {
    public:
        BoolLiteral(bool v, uint32_t l) : Literal(Type(TYPE_BOOL, "bool"), Value(v), l) {}
        ~BoolLiteral() override = default;
    };
    
    class CharacterLiteral : public Literal {
    public:
        CharacterLiteral(char8_t v, uint32_t l) : Literal(Type(TYPE_CHAR, "char"), Value(v), l) {}
        ~CharacterLiteral() override = default;
    };

    class ShortLiteral : public Literal {
    public:
        ShortLiteral(int16_t v, uint32_t l) : Literal(Type(TYPE_SHORT, "short"), Value(v), l) {}
        ~ShortLiteral() override = default;
    };

    class IntLiteral : public Literal {
    public:
        IntLiteral(int32_t v, uint32_t l) : Literal(Type(TYPE_INT, "int"), Value(v), l) {}
        ~IntLiteral() override = default;
    };

    class LongLiteral : public Literal {
    public:
        LongLiteral(int64_t v, uint32_t l) : Literal(Type(TYPE_LONG, "long"), Value(v), l) {}
        ~LongLiteral() override = default;
    };

    class FloatLiteral : public Literal {
    public:
        FloatLiteral(float_t v, uint32_t l) : Literal(Type(TYPE_FLOAT, "float"), Value(v), l) {}
        ~FloatLiteral() override = default;
    };

    class DoubleLiteral : public Literal {
    public:
        DoubleLiteral(double_t v, uint32_t l) : Literal(Type(TYPE_DOUBLE, "double"), Value(v), l) {}
        ~DoubleLiteral() override = default;
    };

    class StringLiteral : public Literal {
    public:
        StringLiteral(std::string v, uint32_t l) : Literal(Type(TYPE_STRING_LIT, "string"), Value(v), l) {}
        ~StringLiteral() override = default;
    };

    class BinaryExpr : public Expr {
    public:
        Token op;                                               
        ExprPtr left_expr;                                      
        ExprPtr right_expr;                                     
 
        BinaryExpr(Token o, ExprPtr le, ExprPtr re, uint32_t l) : op(o), left_expr(std::move(le)), right_expr(std::move(re)), Expr(l) {}
        ~BinaryExpr() override = default;
    };

    class UnaryExpr : public Expr {
    public:
        Token op;                                               
        ExprPtr expr;                                           
 
        UnaryExpr(Token o, ExprPtr e, uint32_t l) : op(o), expr(std::move(e)), Expr(l) {}
        ~UnaryExpr() override = default;
    };

    class VarExpr : public Expr {
    public:
        std::string name;                                       
 
        VarExpr(std::string n, uint32_t l) : name(n), Expr(l) {}
        ~VarExpr() override = default;
    };

    class FuncCallExpr : public Expr {
    public:
        std::string name;                                       
        std::vector<ExprPtr> args;                              
 
        FuncCallExpr(std::string n, std::vector<ExprPtr> a, uint32_t l) : name(n), args(std::move(a)), Expr(l) {}
        ~FuncCallExpr() override = default;
    };

    class ChainObjects : public Expr {
    public:
        std::vector<ExprPtr> chain;                             
 
        ChainObjects(std::vector<ExprPtr> c, uint32_t l) : chain(std::move(c)), Expr(l) {}
        ~ChainObjects() override = default;
    };
 
    // STATEMENTS

    class VarDeclStmt : public Stmt {
    public:
        AccessModifier access;                                  
        Type type;                                              
        ExprPtr expr;                                           
        std::string name;                                       
 
        VarDeclStmt(AccessModifier am, Type t, ExprPtr e, std::string n, uint32_t l) : access(am), type(t), expr(std::move(e)), name(n), Stmt(l) {}
        ~VarDeclStmt() override = default;
    };

    class VarAsgnStmt : public Stmt {
    public:
        std::string name;                                       
        ExprPtr expr;                                           
        bool is_deref;                                          
 
        VarAsgnStmt(std::string n, ExprPtr e, bool id, uint32_t l) : name(n), expr(std::move(e)), is_deref(id), Stmt(l) {}
        ~VarAsgnStmt() override = default;
    };

    class FuncDeclStmt : public Stmt {
    public:
        AccessModifier access;                                  
        std::string name;                                       
        std::vector<Argument> args;                             
        Type ret_type;                                          
        std::vector<StmtPtr> block;                             
 
        FuncDeclStmt(AccessModifier am, std::string n, std::vector<Argument> a, Type rt, std::vector<StmtPtr> b, uint32_t l) : access(am), name(n), args(std::move(a)), ret_type(rt), block(std::move(b)), Stmt(l) {}
        ~FuncDeclStmt() override = default;
    };

    class FuncCallStmt : public Stmt {
    public:
        std::string name;                                       
        std::vector<ExprPtr> args;                              
 
        FuncCallStmt(std::string n, std::vector<ExprPtr> a, uint32_t l) : name(n), args(std::move(a)), Stmt(l) {}
        ~FuncCallStmt() override = default;
    };

    class ReturnStmt : public Stmt {
    public:
        ExprPtr expr;                                           
 
        ReturnStmt(ExprPtr e, uint32_t l) : expr(std::move(e)), Stmt(l) {}
        ~ReturnStmt() override = default;
    };

    class IfElseStmt : public Stmt {
    public:
        ExprPtr cond;                                           
        std::vector<StmtPtr> then_block;                        
        std::vector<StmtPtr> else_block;                        
 
        IfElseStmt(ExprPtr c, std::vector<StmtPtr> tb, std::vector<StmtPtr> eb, uint32_t l) : cond(std::move(c)), then_block(std::move(tb)), else_block(std::move(eb)), Stmt(l) {}
    };

    class WhileCycleStmt : public Stmt {
    public:
        ExprPtr cond;                                           
        std::vector<StmtPtr> block;                             
 
        WhileCycleStmt(ExprPtr c, std::vector<StmtPtr> b, uint32_t l) : cond(std::move(c)), block(std::move(b)), Stmt(l) {}
        ~WhileCycleStmt() override = default;
    };

    class DoWhileCycleStmt : public Stmt {
    public:
        ExprPtr cond;                                           
        std::vector<StmtPtr> block;                             
 
        DoWhileCycleStmt(ExprPtr c, std::vector<StmtPtr> b, uint32_t l) : cond(std::move(c)), block(std::move(b)), Stmt(l) {}
        ~DoWhileCycleStmt() override = default;
    };

    class ForCycleStmt : public Stmt {
    public:
        StmtPtr indexator;                                      
        ExprPtr cond;                                           
        StmtPtr iteration;                                      
        std::vector<StmtPtr> block;                             
 
        ForCycleStmt(StmtPtr ix, ExprPtr c, StmtPtr it, std::vector<StmtPtr> b, uint32_t l) : indexator(std::move(ix)), cond(std::move(c)), iteration(std::move(it)), block(std::move(b)), Stmt(l) {}
        ~ForCycleStmt() override = default;
    };

    class BreakStmt : public Stmt {
    public:
        BreakStmt(uint32_t l) : Stmt(l) {}
        ~BreakStmt() override = default;
    };

    class ContinueStmt : public Stmt {
    public:
        ContinueStmt(uint32_t l) : Stmt(l) {}
        ~ContinueStmt() override = default;
    };

    class ModuleStmt : public Stmt {
    public:
        AccessModifier access;                                  
        std::string file_name;                                  
        std::string name;                                       
        std::vector<StmtPtr> block;                             
 
        ModuleStmt(AccessModifier am, std::string fn, std::string n, std::vector<StmtPtr> b, uint32_t l) : access(am), file_name(fn), name(n), block(std::move(b)), Stmt(l) {}
        ~ModuleStmt() override = default;
    };

    class UseModuleStmt : public Stmt {
    public:
        std::vector<std::string> path;                          
 
        UseModuleStmt(std::vector<std::string> p, uint32_t l) : path(std::move(p)), Stmt(l) {}
        ~UseModuleStmt() override = default;
    };

    class ExternStmt : public Stmt {
    public:
        std::string lang_name_lit;                              
        std::vector<StmtPtr> block;                             
 
        ExternStmt(std::string lnl, std::vector<StmtPtr> b, uint32_t l) : lang_name_lit(lnl), block(std::move(b)), Stmt(l) {}
        ~ExternStmt() override = default;
    };
}