semantic.hpp

Go to the documentation of this file.

 
#include "../parser/ast.hpp"
#include <filesystem>
#include <vector>
#include <memory>
#include <stack>
#include <map>
 
class SemanticAnalyzer {
private:
    std::string libs_path;                                                      
    std::string file_name;                                                      
    std::string path_to_current_dir;                                            
    std::vector<AST::StmtPtr>& stmts;                                           
    bool is_debug;                                                              

    enum Space {
        SPACE_GLOBAL,
        SPACE_MODULE,
        SPACE_FUNCTION,
    } current_space;
 
    std::map<AST::TypeValue, std::vector<AST::TypeValue>> implicitly_cast_allowed_types {
        {AST::TYPE_BOOL, {AST::TYPE_BOOL}},
        {AST::TYPE_CHAR, {AST::TYPE_CHAR, AST::TYPE_SHORT, AST::TYPE_INT, AST::TYPE_LONG, AST::TYPE_FLOAT, AST::TYPE_DOUBLE}},
        {AST::TYPE_SHORT, {AST::TYPE_SHORT, AST::TYPE_INT, AST::TYPE_LONG, AST::TYPE_FLOAT, AST::TYPE_DOUBLE}},
        {AST::TYPE_INT, {AST::TYPE_INT, AST::TYPE_LONG, AST::TYPE_FLOAT, AST::TYPE_DOUBLE}},
        {AST::TYPE_LONG, {AST::TYPE_LONG, AST::TYPE_FLOAT, AST::TYPE_DOUBLE}},
        {AST::TYPE_FLOAT, {AST::TYPE_FLOAT, AST::TYPE_DOUBLE}}
    };                                                                          

    struct Value {
        AST::Type type;                                                         
        AST::Value value;                                                       
        bool is_value_unknown;                                                  
        bool is_literal;                                                        
 
        Value(AST::Type t, AST::Value v, bool vu, bool il) : type(t), value(v), is_value_unknown(vu), is_literal(il) {}
    };
 
    std::stack<std::map<std::string, Value>> variables;                         

    struct FunctionInfo {
        AST::Type ret_type;                                                     
        std::vector<AST::Argument> args;                                        
        std::vector<AST::StmtPtr> block;                                        
 
        FunctionInfo(AST::Type rt, std::vector<AST::Argument> a, std::vector<AST::StmtPtr> b) : ret_type(rt), args(std::move(a)), block(std::move(b)) {}
    };
    std::map<std::string, std::vector<std::shared_ptr<FunctionInfo>>> functions;
    std::stack<AST::Type> functions_ret_types;                                  
    unsigned depth_of_loops;                                                    
    std::vector<std::string> allowed_langs_for_extern {                         
        "C",
        "C++",
        "Rust"
    };
 
public:
    struct ModuleInfo {
        std::map<std::string, std::pair<AST::AccessModifier, ModuleInfo*>> modules;     
        std::map<std::string, std::pair<AST::AccessModifier, std::string>> functions;   
    };
private:
    std::map<std::string, ModuleInfo*> modules;                                 
    std::vector<std::string> names_of_imported_modules;                         

    struct PathPart {
        std::string name;                                                       

        enum Object {
            OBJ_MODULE,
            OBJ_CLASS,
        } object;
    };
    std::stack<PathPart> current_path;                                          
 
public:
    SemanticAnalyzer(std::vector<AST::StmtPtr>& s, std::string lp, std::string fn, bool id) : stmts(s), libs_path(lp), file_name(fn), depth_of_loops(0), is_debug(id) {
        std::filesystem::path file_path = std::filesystem::absolute(fn);
        path_to_current_dir = file_path.parent_path().string();
        variables.push({});
    }

    void analyze();

    std::map<std::string, ModuleInfo*> get_modules() const {
        return modules;
    }

    std::map<std::string, std::vector<std::shared_ptr<FunctionInfo>>> get_functions() const {
        return functions;
    }
 
private:
    void analyze_stmt(AST::Stmt& stmt);

    void analyze_var_decl_stmt(AST::VarDeclStmt& vds, bool is_func_arg = false);

    void analyze_var_asgn_stmt(AST::VarAsgnStmt& vas);

    void analyze_func_decl_stmt(AST::FuncDeclStmt& fds);

    void analyze_func_call_stmt(AST::FuncCallStmt& fcs);

    void analyze_return_stmt(AST::ReturnStmt& rs);

    void analyze_if_else_stmt(AST::IfElseStmt& ies);

    void analyze_while_cycle_stmt(AST::WhileCycleStmt& wcs);

    void analyze_do_while_cycle_stmt(AST::DoWhileCycleStmt& dwcs);

    void analyze_for_cycle_stmt(AST::ForCycleStmt& fcs);

    void analyze_break_stmt(AST::BreakStmt& bs);

    void analyze_continue_stmt(AST::ContinueStmt& cs);

    void analyze_module_stmt(AST::ModuleStmt& ms);

    void analyze_use_module_stmt(AST::UseModuleStmt& ums);

    void analyze_extern_stmt(AST::ExternStmt& es);
    
    Value analyze_expr(AST::Expr& expr);
    
    Value analyze_literal_expr(AST::Literal& lit);

    Value analyze_binary_expr(AST::BinaryExpr& be);

    Value analyze_unary_expr(AST::UnaryExpr& ue);

    Value analyze_var_expr(AST::VarExpr& ve);

    Value analyze_func_call_expr(AST::FuncCallExpr& fce);

    Value analyze_obj_chain_expr(AST::ChainObjects& co);

    Value analyze_obj_from_chain(Value target, AST::Expr& obj);

    Value get_function_return_value(std::shared_ptr<FunctionInfo> func, AST::FuncCallExpr& fce);

    Value *get_function_return_value_from_if_else(AST::IfElseStmt& ies);

    Value *get_function_return_value_from_while_cycle(AST::WhileCycleStmt& wcs);

    Value *get_function_return_value_from_do_while_cycle(AST::DoWhileCycleStmt& dwcs);

    Value *get_function_return_value_from_for_cycle(AST::ForCycleStmt& fcs);

    AST::Value get_default_val_by_type(AST::Type type, uint32_t line);

    std::unique_ptr<Value> get_variable_value(std::string name);

    std::vector<std::shared_ptr<FunctionInfo>> get_function_candidates(std::string name);

    bool has_common_type(AST::Type left, AST::Type right);
    
    AST::Type get_common_type(AST::Type left, AST::Type right, uint32_t line);

    Value implicitly_cast(Value val, AST::Type type, uint32_t line);

    double binary_two_variants(Value left, Value right, TokenType op, uint32_t line);

    double unary_two_variants(Value value, TokenType op, uint32_t line);

    std::string get_mangled_name(std::string base_name);

    std::vector<PathPart> get_resolved_name(std::string mangled_name);
};