function-scope.hpp

#pragma once
#include <gyoji-frontend.hpp>
#include <gyoji-mir.hpp>
 
namespace Gyoji::frontend::lowering {
 
    class Scope;
    class ScopeOperation;
    class ScopeTracker;
    class LocalVariable;
 
    class FunctionPoint {
    public:
    FunctionPoint(size_t _basic_block_id, size_t _location);
    ~FunctionPoint();
    size_t get_basic_block_id() const;
    size_t get_location() const;
    private:
    size_t basic_block_id;
    size_t location;
    };
    
    class ScopeOperation {
    public:
 
    typedef enum {
        VAR_DECL,
        LABEL_DEFINITION,
        GOTO_DEFINITION,
        CHILD_SCOPE
    } ScopeOperationType;
    ~ScopeOperation();
 
    static Gyoji::owned<ScopeOperation> create_variable(
        std::string _variable_name,
        const Gyoji::mir::Type *_variable_type,
        const Gyoji::context::SourceReference & _source_ref
        );
    static Gyoji::owned<ScopeOperation> create_label(
        std::string _label_name,
        const Gyoji::context::SourceReference & _source_ref
        );
    static Gyoji::owned<ScopeOperation> create_goto(
        std::string _goto_label,
        Gyoji::owned<FunctionPoint> _goto_point,
        const Gyoji::context::SourceReference & _source_ref
        );
    static Gyoji::owned<ScopeOperation> create_child(
        Gyoji::owned<Scope> _child,
        const Gyoji::context::SourceReference & _source_ref
        );
    
    void dump(int indent) const;
    const ScopeOperationType & get_type() const;
    const std::string & get_label_name() const;
    
    const std::string & get_goto_label() const;
    const FunctionPoint & get_goto_point() const;
    
    const std::string & get_variable_name() const;
    const Scope *get_child() const;
 
    const Gyoji::context::SourceReference & get_source_ref() const;
 
    
    private:
    ScopeOperation(
        ScopeOperationType _type,
        const Gyoji::context::SourceReference & _source_ref
        );
    ScopeOperationType type;
 
    const Gyoji::context::SourceReference & source_ref;
 
    LocalVariable *local_variable;
    const Gyoji::mir::Type *variable_type;
    std::string variable_name;
    
    std::string label_name;
    
    std::string goto_label;
    Gyoji::owned<FunctionPoint> goto_point;
    
    Gyoji::owned<Scope> child;
    };
 
    class LocalVariable {
    public:
    LocalVariable(
        const Gyoji::mir::Type *_type,
        const Gyoji::context::SourceReference & _source_ref
        );
    ~LocalVariable();
    const Gyoji::mir::Type *get_type() const;
    const Gyoji::context::SourceReference & get_source_ref() const;
    private:
    const Gyoji::mir::Type *type;
    const Gyoji::context::SourceReference & source_ref;
    };
 
    class Scope {
    public:
    Scope();
    Scope(bool _is_loop,
          size_t _loop_break_blockid,
          size_t _loop_continue_blockid
        );
    ~Scope();
    void add_operation(Gyoji::owned<ScopeOperation> op);
    
    void dump(int indent) const;
 
    const LocalVariable *get_variable(std::string name) const;
 
    bool is_loop() const;
    
    size_t get_loop_break_blockid() const;
    
    size_t get_loop_continue_blockid() const;
 
    const std::map<std::string, Gyoji::owned<LocalVariable>> & get_variables() const;
    private:
    friend ScopeTracker;
    Scope *parent;
 
    // If this scope is a loop,
    // what is the block id to jump
    // to for a 'break' or 'continue' operation?
    bool scope_is_loop;
    size_t loop_break_blockid;
    size_t loop_continue_blockid;
    
    std::vector<Gyoji::owned<ScopeOperation>> operations;
    std::map<std::string, Gyoji::owned<LocalVariable>> variables;
    };
 
    class FunctionLabel {
    public:
        FunctionLabel(
        size_t _block_id
        );
        ~FunctionLabel();
    size_t get_block() const;
    bool is_resolved() const;
    void resolve(const Gyoji::context::SourceReference & _src_ref);
    const Gyoji::context::SourceReference & get_source_ref() const;
    private:
    bool resolved;
    size_t block_id;
    const Gyoji::context::SourceReference * src_ref;
    };
 
    class ScopeTracker {
    public:
    ScopeTracker(const Gyoji::context::CompilerContext & _compiler_context);
    ~ScopeTracker();
 
    void scope_push(
        const Gyoji::context::SourceReference & _source_ref
        );
 
    void scope_push_loop(
        const Gyoji::context::SourceReference & _source_ref,
        size_t _loop_break_blockid,
        size_t _loop_continue_blockid
        );
 
    void scope_pop();
 
    // Use this for 'label' to say we have a label and it's in the current
    // scope, but it's on the 'notfound' list, so move it over to
    // the real list because we've found it now.
    void label_define(
        std::string label_name,
        const Gyoji::context::SourceReference & _source_ref
        );
 
    // Use this for 'label' to say we have a label, it's in the
    // current scope, but it wasn't forwar-declared on the
    // notfound list.
    void label_define(
        std::string label_name,
        size_t label_block_id,
        const Gyoji::context::SourceReference & _source_ref
        );
    
    // Use this for 'goto' to say we want a label, but we
    // don't yet know where it will live, so put it on the
    // notfound labels list.
    void label_declare(std::string label_name, size_t label_blockid);
    
    void add_goto(
        std::string goto_label,
        Gyoji::owned<FunctionPoint> function_point,
        const Gyoji::context::SourceReference & _source_ref
        );
              
    const FunctionLabel * get_label(std::string name) const;
 
    bool add_variable(std::string variable_name, const Gyoji::mir::Type *mir_type, const Gyoji::context::SourceReference & source_ref);
    
    void dump() const;
 
    bool check(
        std::vector<std::pair<const ScopeOperation*, std::vector<const ScopeOperation*>>> & goto_fixups
        ) const;
    
    bool is_in_loop() const;
 
    size_t get_loop_break_blockid() const;
    size_t get_loop_continue_blockid() const;
    
    const LocalVariable* get_variable(std::string variable_name) const;
    
    std::vector<std::string> get_variables_to_unwind_for_root() const;
 
    std::vector<std::string> get_variables_to_unwind_for_scope() const;
    
    std::vector<std::string> get_variables_to_unwind_for_break() const;
 
    std::vector<std::string> get_variables_to_unwind_for_label(std::string & label) const;
 
    const Scope *get_current() const;
    
    private:
    void add_flat_op(const ScopeOperation *op);
 
    void add_operation(Gyoji::owned<ScopeOperation> op);
 
 
    
    Gyoji::owned<Scope> root;
    Scope *current;
    const Gyoji::context::CompilerContext & compiler_context;
    
    // Labels that actually have a definition.
    std::map<std::string, Gyoji::owned<FunctionLabel>> labels;
 
    // Labels that have been referenced in a 'goto'
    // but not yet defined in a scope.
    std::map<std::string, Gyoji::owned<FunctionLabel>> labels_forward_declared;
 
    std::vector<size_t> tracker_prior_point;
    std::map<size_t, size_t> tracker_backward_edges;
    std::vector<const ScopeOperation*> tracker_flat;
    
    std::map<std::string, size_t> tracker_label_locations;
    std::map<size_t, std::string> tracker_goto_labels_at;
    };
};