bpp.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <sstream>
#include <vector>
#include <unordered_map>
#include <list>
#include <memory>
 
#include "replace_all.h"
 
#include <include/EntityMap.h>
#include <include/BashVersion.h>
#include <AST/Nodes/Program.h>
 
namespace bpp {
 
enum bpp_scope {
    SCOPE_PUBLIC,
    SCOPE_PROTECTED,
    SCOPE_PRIVATE,
    SCOPE_INACCESSIBLE
};
 
enum reference_type {
    ref_primitive,
    ref_method,
    ref_object
};
 
enum diagnostic_type {
    DIAGNOSTIC_ERROR,
    DIAGNOSTIC_WARNING,
    DIAGNOSTIC_INFO,
    DIAGNOSTIC_HINT
};
 
struct diagnostic {
    diagnostic_type type;
    std::string message;
    uint32_t start_line;
    uint32_t start_column;
    uint32_t end_line;
    uint32_t end_column;
};
 
// Forward declarations
 
class bpp_entity;
class bpp_code_entity;
class bpp_string;
class bpp_method;
class bpp_method_parameter;
class bpp_class;
class bpp_object;
class bpp_datamember;
class bpp_program;
 
// Statement types
class bash_while_or_until_loop;
class bash_while_or_until_condition;
class bash_if;
class bash_if_branch;
class bash_case;
class bash_case_pattern;
class bash_for_or_select;
class bash_function;
class bpp_delete_statement;
class bpp_dynamic_cast_statement;
class bpp_pointer_dereference;
class bpp_value_assignment;
class bpp_object_assignment;
class bpp_object_reference;
class bpp_object_address;
 
inline const std::shared_ptr<bpp_entity> inaccessible_entity = std::make_shared<bpp_entity>();
 
inline const std::shared_ptr<bpp_datamember> inaccessible_datamember = std::make_shared<bpp_datamember>();
 
inline const std::shared_ptr<bpp_method> inaccessible_method = std::make_shared<bpp_method>();
 
static const char bpp_nullptr[] = "0";
 
inline constexpr const char* protected_keywords[] = {
            "class", "constructor", "delete", "destructor",
            "dynamic_cast", "include", "include_once", "local", "method",
            "new", "nullptr", "primitive", "private",
            "protected", "public", "super", "this",
            "typeof", "virtual"
        };
 
inline bool is_protected_keyword(const std::string& keyword) {
    for (const char* protected_keyword : protected_keywords) {
        if (keyword == protected_keyword) {
            return true;
        }
    }
    return false;
}
 
inline bool is_valid_identifier(const std::string& identifier) {
    // Verify it's not empty, and not a reserved keyword
    if (identifier.empty() || is_protected_keyword(identifier)) {
        return false;
    }
 
    // Verify it doesn't contain two consecutive underscores
    if (identifier.find("__") != std::string::npos) {
        return false;
    }
 
    // Verify it starts with a letter or underscore, and contains only letters, digits, and underscores
    if (!isalpha(identifier[0]) && identifier[0] != '_') {
        return false;
    }
 
    for (char c : identifier) {
        if (!isalnum(c) && c != '_') {
            return false;
        }
    }
    
    // If all checks passed, it's a valid identifier
    return true;
}
 
struct SymbolPosition {
    std::string file;
    uint64_t line;
    uint64_t column;
 
    SymbolPosition() {}
    SymbolPosition(const std::string& file, uint64_t line, uint64_t column)
        : file(file), line(line), column(column) {}
};
 
class bpp_entity {
    protected:
        std::string name = "";
        std::unordered_map<std::string, std::weak_ptr<bpp_class>> classes;
 
        std::unordered_map<std::string, std::weak_ptr<bpp_object>> objects;
 
        std::unordered_map<std::string, std::shared_ptr<bpp_object>> local_objects;
        std::shared_ptr<bpp_class> type = nullptr;
        std::weak_ptr<bpp_class> containing_class;
        std::weak_ptr<bpp_program> containing_program;
        std::vector<std::weak_ptr<bpp_class>> parents;
        std::weak_ptr<bpp_method> overridden_method;
        bpp::SymbolPosition initial_definition;
        std::list<bpp::SymbolPosition> references;
    public:
        virtual ~bpp_entity() = default;
        virtual bool add_class(std::shared_ptr<bpp_class> class_);
        virtual bool add_object(std::shared_ptr<bpp_object> object, bool make_local = false);
 
        virtual std::shared_ptr<bpp_class> get_class();
        virtual std::string get_address() const;
        virtual void set_name(const std::string& name);
        virtual std::string get_name() const;
        virtual std::weak_ptr<bpp::bpp_class> get_containing_class();
        virtual std::weak_ptr<bpp_program> get_containing_program();
        virtual bool set_containing_class(std::weak_ptr<bpp::bpp_class> containing_class);
 
        void inherit(std::shared_ptr<bpp_entity> parent);
        void inherit(std::shared_ptr<bpp_program> program);
        virtual void inherit(std::shared_ptr<bpp_class> parent);
 
        void set_definition_position(const std::string& file, uint64_t line, uint64_t column);
        void add_reference(const std::string& file, uint64_t line, uint64_t column);
 
        bpp::SymbolPosition get_initial_definition() const;
        std::list<bpp::SymbolPosition> get_references() const;
 
        std::unordered_map<std::string, std::shared_ptr<bpp_class>> get_classes() const;
        std::unordered_map<std::string, std::shared_ptr<bpp_object>> get_objects() const;
        std::shared_ptr<bpp_class> get_class(const std::string& name);
        std::shared_ptr<bpp_object> get_object(const std::string& name);
 
        std::shared_ptr<bpp_class> get_parent() const;
};
 
class bpp_code_entity : public bpp_entity {
    protected:
        std::shared_ptr<std::ostream> code = std::make_shared<std::ostringstream>();
        std::string nextline_buffer = "";
        std::string postline_buffer = "";
        bool buffers_flushed = false;
 
        bool requires_perfect_forwarding = false;
    public:
        bpp_code_entity();
 
        virtual void add_code(const std::string& code, bool add_newline = true);
        virtual void add_code_to_previous_line(const std::string& code);
        virtual void add_code_to_next_line(const std::string& code);
 
        bool add_object(std::shared_ptr<bpp_object> object, bool make_local = false) override;
 
        virtual void flush_nextline_buffer();
        virtual void flush_postline_buffer();
        virtual void flush_code_buffers();
 
        virtual void clear_all_buffers();
 
        virtual std::string get_code() const;
        virtual std::string get_pre_code() const;
        virtual std::string get_post_code() const;
 
        void set_requires_perfect_forwarding(bool require);
        bool get_requires_perfect_forwarding() const;
};
 
class bpp_string : public bpp_code_entity {
    public:
        bpp_string();
 
        void add_code(const std::string& code, bool add_newline = true) override;
        void add_code_to_previous_line(const std::string& code) override;
        void add_code_to_next_line(const std::string& code) override;
 
        std::string get_code() const override;
        std::string get_pre_code() const override;
        std::string get_post_code() const override;
};
 
class bash_command_sequence : public bpp_string {
    protected:
        std::string joined_code = "";
        bool contains_multiple_commands = false;
 
        bool perfect_forwarding = false;
 
        void join();
    public:
        bash_command_sequence() = default;
 
        void add_connective(bool is_and);
 
        void add_code(const std::string& code, bool add_newline = true) override;
 
        std::string get_code() const override;
        std::string get_pre_code() const override;
        std::string get_post_code() const override;
 
        void set_perfect_forwarding(bool enable);
};
 
class bpp_method : public bpp_code_entity {
    private:
        std::vector<std::shared_ptr<bpp_method_parameter>> parameters;
        bpp_scope scope = SCOPE_PUBLIC;
        bool m_is_virtual = false;
        bool m_is_overridable = false;
        bool inherited = false;
        bool add_object_as_parameter(std::shared_ptr<bpp_object> object);
        std::string last_override; // Name of the latest class to override this virtual method
    public:
        bpp_method();
        explicit bpp_method(const std::string& name);
        bpp_method(const std::string& name, bool is_virtual);
 
        virtual bool add_parameter(std::shared_ptr<bpp_method_parameter> parameter);
        void set_scope(bpp_scope scope);
        void set_virtual(bool is_virtual);
        void set_overridable(bool is_overridable);
        void set_inherited(bool is_inherited);
        void set_last_override(const std::string& class_name);
        void set_overridden_method(std::weak_ptr<bpp_method> method);
        bool add_object(std::shared_ptr<bpp_object> object, bool make_local) override;
 
        std::vector<std::shared_ptr<bpp_method_parameter>> get_parameters() const;
        bpp_scope get_scope() const;
        bool is_virtual() const;
        bool is_overridable() const;
        bool is_inherited() const;
        std::string get_last_override() const;
 
        void destruct_local_objects(std::shared_ptr<bpp_program> program);
};
 
class bpp_method_parameter : public bpp_entity {
    public:
        explicit bpp_method_parameter(const std::string& name);
 
        void set_type(std::shared_ptr<bpp_class>);
        std::shared_ptr<bpp_class> get_type() const;
};
 
class bpp_class : public bpp_entity, public std::enable_shared_from_this<bpp_class> {
    private:
        std::vector<std::shared_ptr<bpp_method>> methods;
        std::vector<std::shared_ptr<bpp_datamember>> datamembers;
        bool has_custom_toPrimitive = false;
 
        void remove_default_toPrimitive();
        void add_default_toPrimitive();
    public:
        bpp_class();
 
        std::weak_ptr<bpp_class> get_containing_class() override;
        bool set_containing_class(std::weak_ptr<bpp::bpp_class> containing_class) override;
 
        std::shared_ptr<bpp_class> get_class() override;
 
        void set_name(const std::string& name) override;
        bool add_method(std::shared_ptr<bpp_method> method);
        bool add_datamember(std::shared_ptr<bpp_datamember> datamember);
 
        std::vector<std::shared_ptr<bpp_method>> get_methods() const;
        std::vector<std::shared_ptr<bpp_datamember>> get_datamembers() const;
 
        std::shared_ptr<bpp_method> get_method(const std::string& name, std::shared_ptr<bpp_entity> context);
        std::shared_ptr<bpp_method> get_method_UNSAFE(const std::string& name);
        std::shared_ptr<bpp_datamember> get_datamember(const std::string& name, std::shared_ptr<bpp_entity> context);
        std::shared_ptr<bpp_datamember> get_datamember_UNSAFE(const std::string& name);
 
        using bpp_entity::inherit;
        void inherit(std::shared_ptr<bpp_class> parent) override;
        std::shared_ptr<bpp::bpp_class> get_parent();
};
 
class bpp_object : public bpp_entity {
    protected:
        std::string address = "";
        std::string assignment_value = "";
        std::string pre_access_code = "";
        std::string post_access_code = "";
        bool m_is_pointer = false;
        std::shared_ptr<bpp::bpp_object> copy_from = nullptr;
    public:
        bpp_object();
        explicit bpp_object(const std::string& name);
        bpp_object(const std::string& name, bool is_pointer);
 
        void set_class(std::shared_ptr<bpp_class> object_class);
        void set_pointer(bool is_pointer);
        void set_address(const std::string& address);
        void set_assignment_value(const std::string& assignment_value);
        void set_pre_access_code(const std::string& pre_access_code);
        void set_post_access_code(const std::string& post_access_code);
        void set_nullptr();
 
        std::string get_address() const override;
        std::string get_assignment_value() const;
        std::shared_ptr<bpp_class> get_class() override;
        std::string get_pre_access_code() const;
        std::string get_post_access_code() const;
        std::shared_ptr<bpp::bpp_object> get_copy_from() const;
 
        bool is_pointer() const;
};
 
class bpp_datamember : public bpp_object {
    private:
        std::string default_value = "";
        bpp_scope scope = SCOPE_PRIVATE;
        bool array = false;
    public:
        bpp_datamember();
 
        void set_default_value(const std::string& default_value);
        void set_scope(bpp_scope scope);
        void set_array(bool is_array);
 
        std::string get_address() const override;
        std::string get_default_value() const;
        bpp_scope get_scope() const;
        bool is_array() const;
};
 
class bpp_program : public bpp_code_entity, public std::enable_shared_from_this<bpp_program> {
    private:
        std::shared_ptr<bpp_class> primitive_class;
        uint64_t supershell_counter = 0;
        uint64_t assignment_counter = 0;
        uint64_t function_counter = 0;
        uint64_t dynamic_cast_counter = 0;
        uint64_t typeof_counter = 0;
        uint64_t object_counter = 0;
        
        BashVersion target_bash_version = {5, 2};
 
        std::string main_source_file;
 
        // To ensure that the bpp_program **owns** its classes
        // I.e., that those classes don't get destroyed before we're done with them
        std::unordered_map<std::string, std::shared_ptr<bpp::bpp_class>> owned_classes;
 
        // Source file -> AST
        // Used for advanced analysis, e.g. LSP features
        std::unordered_map<std::string, std::shared_ptr<AST::Program>> source_file_asts;
 
        // Source file -> EntityMap
        std::unordered_map<std::string, EntityMap> entity_maps;
        // s.t. requesting entity_maps["/path/to/file1.bpp"] returns an EntityMap
        // which outlines for us which container entities are active at each point in the file
 
        // Source file -> Diagnostics
        std::unordered_map<std::string, std::vector<bpp::diagnostic>> diagnostics;
        // Each 'diagnostic' contains a type (error, warning, etc), message, and position in the source file
 
        // For debug info:
        std::shared_ptr<std::vector<std::string>> include_paths;
    public:
        bpp_program();
 
        bool set_containing_class(std::weak_ptr<bpp_class> containing_class) override;
        void set_output_stream(std::shared_ptr<std::ostream> output_stream);
 
        bool prepare_class(std::shared_ptr<bpp_class> class_);
        bool add_class(std::shared_ptr<bpp_class> class_) override;
 
        std::shared_ptr<bpp_class> get_primitive_class() const;
 
        std::weak_ptr<bpp_program> get_containing_program() override;
 
        void set_include_paths(std::shared_ptr<std::vector<std::string>> paths);
        std::shared_ptr<std::vector<std::string>> get_include_paths() const;
 
        void increment_supershell_counter();
        uint64_t get_supershell_counter() const;
 
        void increment_assignment_counter();
        uint64_t get_assignment_counter() const;
 
        void increment_function_counter();
        uint64_t get_function_counter() const;
 
        void increment_dynamic_cast_counter();
        uint64_t get_dynamic_cast_counter() const;
 
        void increment_typeof_counter();
        uint64_t get_typeof_counter() const;
 
        void increment_object_counter();
        uint64_t get_object_counter() const;
 
        void set_target_bash_version(BashVersion target_bash_version);
        BashVersion get_target_bash_version() const;
 
        void mark_entity(
            const std::string& file,
            uint32_t start_line, uint32_t start_column,
            uint32_t end_line, uint32_t end_column,
            std::shared_ptr<bpp::bpp_entity> entity
        );
 
        std::shared_ptr<bpp::bpp_entity> get_active_entity(
            const std::string& file,
            uint32_t line, uint32_t column
        );
 
        std::vector<std::string> get_source_files() const;
        std::string get_main_source_file() const;
        void set_main_source_file(const std::string& file);
        void add_source_file(const std::string& file);
 
        void set_source_file_ast(const std::string& file, std::shared_ptr<AST::Program> ast);
        std::shared_ptr<AST::Program> get_source_file_ast(const std::string& file) const;
 
        void add_diagnostic(
            const std::string& file,
            diagnostic_type type,
            const std::string& message,
            uint32_t start_line, uint32_t start_column,
            uint32_t end_line, uint32_t end_column
        );
 
        std::vector<bpp::diagnostic> get_diagnostics(const std::string& file) const;
        void clear_diagnostics(const std::string& file);
};
 
class bash_while_or_until_loop : public bpp_code_entity {
    private:
        std::shared_ptr<bpp::bash_while_or_until_condition> condition;
    public:
        bash_while_or_until_loop();
 
        void set_condition(std::shared_ptr<bpp::bash_while_or_until_condition> condition);
        std::shared_ptr<bpp::bash_while_or_until_condition> get_condition() const;
 
        std::string get_code() const override;
        std::string get_pre_code() const override;
        std::string get_post_code() const override;
};
 
class bash_while_or_until_condition : public bpp_string {
    public:
        bash_while_or_until_condition() = default;
};
 
class bash_if : public bpp_string {
    private:
        std::vector<std::pair<std::string, std::string>> conditional_branches = {};
    public:
        bash_if();
 
        void new_branch();
        void add_condition_code(const std::string& condition_code);
        void add_branch_code(const std::string& branch_code);
        const std::vector<std::pair<std::string, std::string>>& get_conditional_branches() const;
};
 
class bash_if_branch : public bpp_code_entity {
    private:
        std::shared_ptr<bpp::bash_if> if_statement;
    public:
        bash_if_branch();
 
        void set_if_statement(std::shared_ptr<bpp::bash_if> if_statement);
        std::shared_ptr<bpp::bash_if> get_if_statement() const;
 
        std::string get_code() const override;
        std::string get_pre_code() const override;
        std::string get_post_code() const override;
};
 
class bash_case : public bpp_string {
    private:
        std::string cases = "";
    public:
        bash_case();
 
        void add_case(const std::string& case_);
 
        const std::string& get_cases() const;
};
 
class bash_case_pattern : public bpp_code_entity {
    private:
        std::string pattern = "";
        std::shared_ptr<bpp::bash_case> containing_case;
    public:
        bash_case_pattern();
 
        void set_pattern(const std::string& pattern);
        void set_containing_case(std::shared_ptr<bpp::bash_case> containing_case);
 
        const std::string& get_pattern() const;
        std::shared_ptr<bpp::bash_case> get_containing_case() const;
};
 
class bash_for_or_select : public bpp_code_entity {
    private:
        std::string header_pre_code = "";
        std::string header_post_code = "";
        std::string header_code = "";
    public:
        bash_for_or_select();
 
        void set_header_pre_code(const std::string& pre_code);
        void set_header_post_code(const std::string& post_code);
        void set_header_code(const std::string& code);
 
        const std::string& get_header_pre_code() const;
        const std::string& get_header_post_code() const;
        const std::string& get_header_code() const;
};
 
class bash_function : public bpp_code_entity {
    public:
        bash_function();
};
 
class bpp_delete_statement : public bpp_string {
    private:
        std::shared_ptr<bpp::bpp_object> object_to_delete;
    public:
        bpp_delete_statement() = default;
 
        void set_object_to_delete(std::shared_ptr<bpp::bpp_object> object);
        std::shared_ptr<bpp::bpp_object> get_object_to_delete() const;
};
 
class bpp_dynamic_cast_statement : public bpp_string {
    private:
        std::string cast_to;
    public:
        bpp_dynamic_cast_statement();
 
        void set_cast_to(const std::string& cast_to);
        std::string get_cast_to() const;
};
 
class bpp_dynamic_cast_target : public bpp_string {
    public:
        bpp_dynamic_cast_target() = default;
};
 
class bpp_value_assignment : public bpp_string {
    private:
        bool nonprimitive_assignment = false;
        std::shared_ptr<bpp_entity> nonprimitive_object;
        bool lvalue_nonprimitive = false;
        bool array_assignment = false;
        bool adding = false;
    public:
        bpp_value_assignment();
 
        void set_nonprimitive_assignment(bool is_nonprimitive);
        void set_nonprimitive_object(std::shared_ptr<bpp_entity> object);
        void set_lvalue_nonprimitive(bool is_nonprimitive);
        void set_array_assignment(bool is_array);
        void set_adding(bool is_adding);
 
        bool is_nonprimitive_assignment() const;
        std::shared_ptr<bpp_entity> get_nonprimitive_object() const;
        bool lvalue_is_nonprimitive() const;
        bool is_array_assignment() const;
        bool is_adding() const;
};
 
class bpp_object_assignment : public bpp_string {
    private:
        std::string lvalue = "";
        std::string rvalue = "";
        bool lvalue_nonprimitive = false;
        bool rvalue_nonprimitive = false;
        std::shared_ptr<bpp_entity> lvalue_object;
        std::shared_ptr<bpp_entity> rvalue_object;
        bool adding = false;
        bool rvalue_array = false;
    public:
        bpp_object_assignment();
 
        void set_lvalue(const std::string& lvalue);
        void set_rvalue(const std::string& rvalue);
        void set_lvalue_nonprimitive(bool is_nonprimitive);
        void set_rvalue_nonprimitive(bool is_nonprimitive);
        void set_lvalue_object(std::shared_ptr<bpp_entity> object);
        void set_rvalue_object(std::shared_ptr<bpp_entity> object);
        void set_adding(bool is_adding);
        void set_rvalue_array(bool is_array);
 
        std::string get_lvalue() const;
        std::string get_rvalue() const;
        bool lvalue_is_nonprimitive() const;
        bool rvalue_is_nonprimitive() const;
        std::shared_ptr<bpp_entity> get_lvalue_object() const;
        std::shared_ptr<bpp_entity> get_rvalue_object() const;
        bool is_adding() const;
        bool rvalue_is_array() const;
};
 
class bpp_object_reference : public bpp_string {
    private:
        bpp::reference_type reference_type;
        std::string array_index = "";
    public: 
        bpp_object_reference();
 
        void set_reference_type(bpp::reference_type reference_type);
        void set_array_index(const std::string& array_index);
        bpp::reference_type get_reference_type() const;
        std::string get_array_index() const;
        bool has_array_index() const;
};
 
} // namespace bpp