Scope.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <memory>
 
#include "../String.h"
#include "../Scripting.h"
#include "Instruction.h"
#include "Input.h"
#include "Compilers.h"
#include "Runtime.h"
 
namespace Gorgon { namespace Scripting {
    
    class Line {
    public:
        Instruction instruction;
        
        long physical;
    };
    
    class CompilerBase;
    
    class SourceMarker {
        friend class ScopeInstance;
    public:
        SourceMarker() { }
        SourceMarker(const SourceMarker &)=default;
        
        SourceMarker &operator=(const SourceMarker &)=default;
 
        bool operator <(const SourceMarker &other) {
            return (source == other.source ? line<other.line : source<other.source);
        }
        
        bool IsValid() const { return source!=0; }
        
        uintptr_t GetSource() const { return source; }
        
        unsigned long GetLine() const { return line; }
        
    private:
        SourceMarker(unsigned long line, uintptr_t source) : line(line), source(source) {}
        
        unsigned long line = 0;
        uintptr_t     source = 0;
    };
    
    class ScopeInstance;
    
    class Scope {
        friend class ScopeInstance;
    public:
        Scope(InputProvider &provider, const std::string &name, bool terminal=false);
        
        Scope(Scope &parent, const std::string &name, bool terminal=false);
        
        const Instruction *ReadInstruction(unsigned long line);
        
        long GetPhysicalLine(unsigned long line) {
            if(ReadInstruction(line)) {
                return lines[line].physical;
            }
            else {
                return -1;
            }
        }
        
        bool IsInteractive() const {
            if(!provider) return false;
            
            return provider->IsInteractive();
        }
        
        unsigned ReadyInstructionCount() const {
            return (unsigned)lines.size();
        }
        
        std::string GetName() const { return name; }
        
        void SaveInstruction(Instruction inst, long pline) {
            lines.push_back({inst, pline});
        }
        
        void SaveInstructions(const std::vector<Instruction> &insts) {
            long pline=0;
            for(auto &inst : insts) {
                lines.push_back({inst, pline});
            }
        }
        
        bool IsTerminal() const {
            return terminal;
        }
        
        std::shared_ptr<ScopeInstance> Instantiate();
        
        std::shared_ptr<ScopeInstance> Instantiate(ScopeInstance &current);
        
        bool HasInstance() const {
            return instances.GetCount()!=0;
        }
        
        ScopeInstance &LastInstance() const {
            ASSERT(instances.GetCount(), "There are no instances available");
            
            return *instances.Last();
        }
        
        bool HasParent() const {
            return parent!=nullptr;
        }
        
        Scope &GetParent() const {
            return *parent;
        }
        
        Variable *GetVariable(const std::string &name) {
            auto var=variables.find(name);
            
            if( var !=variables.end() )
                return &var->second;
            else
                return nullptr;
        }
        
        void SetVariable(const std::string &name, const Data &data) {
            variables[name]={name, data};
        }
        
        bool UnsetVariable(const std::string &name) {
            auto var=variables.find(name);
            
            if( var !=variables.end() ) {
                variables.erase(var);
                return true;
            }
            else
                return false;
        }
        
        void Unload() {
            using std::swap;
            
            std::vector<Line> temp; 
            swap(temp, lines);
            
            provider->Reset();
        }
        
        void SetName(const std::string &name) {
            this->name=name;
        }
        
    private:
        std::string name;
        
        int nextid=1;
        
        long pline=0;
 
        InputProvider *provider = nullptr;
        
        Compilers::Base *parser =nullptr;
        
        Scope *parent=nullptr;
        
        bool terminal;
        
        Containers::Collection<ScopeInstance> instances;
        
        //-unordered map
        std::map<std::string, Variable, String::CaseInsensitiveLess> variables;
        
        std::vector<Line> lines;
    };
    
    class Return {
    public:
        const Type *type;
        
        bool constant;
        
        bool reference;
    };
    
    class ScopeInstance { 
        friend class Scope;
        friend class VirtualMachine;
        
        using variablestoragetype=std::map<std::string, Variable, String::CaseInsensitiveLess>;
        using symbolstoragetype  =std::map<std::string, const StaticMember*, String::CaseInsensitiveLess>;
    public:
        
        ~ScopeInstance() {
            scope.instances.Remove(this);
        }
        
        void Jumpto(unsigned long line) {
            current=line;
        }
        
        unsigned long GetLineNumber() const {
            return current-1;
        }
        
        SourceMarker GetMarkerForNext() const {
            return {current, reinterpret_cast<uintptr_t>(this)};
        }
        
        SourceMarker GetMarkerForCurrent() const {
            return {current-1, reinterpret_cast<uintptr_t>(this)};
        }
        
        const Instruction *Get() {
            auto ret=scope.ReadInstruction(current);
            current++;
            
            return ret;
        }
        
        std::string GetName() const {
            return name;
        }
        
        Variable *GetLocalVariable(const std::string &name) {
            auto varit=variables.find(name);
            if( varit !=variables.end() )
                return &varit->second;
            else
                return nullptr;
        }
        
        const std::map<std::string, Variable, String::CaseInsensitiveLess> &GetLocalVariables() {
            return variables;
        }
        
        Variable *GetVariable(const std::string &name) {
            auto varit=variables.find(name);
            if( varit !=variables.end() )
                return &varit->second;
            
            auto var=scope.GetVariable(name);
            if(var)
                return var;
            
            if(scope.HasParent() && scope.GetParent().HasInstance() && !scope.IsTerminal())
                var=scope.GetParent().LastInstance().GetVariable(name);
            
            return var;
        }
        
        void SetVariable(const std::string &name, const Data &data) {
            variables[name]={name, data};
        }
        
        bool UnsetVariable(const std::string &name) {
            auto var=variables.find(name);
            
            if( var !=variables.end() ) {
                variables.erase(var);
                return true;
            }
            
            auto done=scope.UnsetVariable(name);
            if(done)
                return true;
            
            if(scope.HasParent() && scope.GetParent().HasInstance() && !scope.IsTerminal())
                done=scope.GetParent().LastInstance().UnsetVariable(name);
            
            return done;
        }
        
        void Compile() {
            int c=current;
            while(scope.ReadInstruction(c++)) ;
        }           
        
        const Instruction *Peek() {
            return scope.ReadInstruction(current);
        }
        
        const Instruction *Peek(unsigned long line) {
            return scope.ReadInstruction(line);
        }
        
        void MoveToEnd() {
            current=scope.ReadyInstructionCount();
        }
        
        long GetPhysicalLine() {
            return scope.GetPhysicalLine(current-1);
        }
 
        Scope &GetScope() const { return scope; }
        
        void SetReturn(Return returns) { this->returns=returns; }
        
        void AddSymbol(const StaticMember &symbol) {
            if(symbols.count(symbol.GetName())!=0) {
                ambiguoussymbols.insert(std::make_pair(symbol.GetName(), symbols[symbol.GetName()]->GetQualifiedName()));
                symbols.erase(symbol.GetName());
                ambiguoussymbols[symbol.GetName()]+=", "+symbol.GetQualifiedName();
            }
            else if(ambiguoussymbols.count(symbol.GetName())!=0) {
                ambiguoussymbols[symbol.GetName()]+=", "+symbol.GetQualifiedName();
            }
            else {
                symbols.insert(std::make_pair(symbol.GetName(), &symbol));
            }
        }
        
        Data FindSymbol(const std::string &name, bool reference) {
            //check local vars first
            variablestoragetype::iterator it;
            if( (it=variables.find(name)) != variables.end() ) {
                Variable &var=it->second;
                if(reference)
                    return var.GetReference();
                else
                    return var;
            }
            
            //check statics too
            auto var=scope.GetVariable(name);
            if(var)
                return *var;
            
            
            //check ambiguity
            if(ambiguoussymbols.count(name)!=0) {
                throw AmbiguousSymbolException(name, SymbolType::Identifier, "Could be one of: "+ambiguoussymbols[name]);
            }
            
            //check local symbols
            symbolstoragetype::iterator sym;
            if( (sym=symbols.find(name)) != symbols.end() ) {
                return sym->second->Get(); //all static member symbols are reference
            }
            
            //if we have a parent, try that         
            if(scope.HasParent() && scope.GetParent().HasInstance() && !scope.IsTerminal())
                return scope.GetParent().LastInstance().FindSymbol(name, reference);
            else
                return Data::Invalid();
        }
        
        Data ReturnValue;
        
    private:
        std::set<std::string> UsedNamespaces;
        
        std::map<std::string, const StaticMember*, String::CaseInsensitiveLess> symbols;
        std::map<std::string, std::string, String::CaseInsensitiveLess> ambiguoussymbols;
        
        ScopeInstance(Scope &scope, ScopeInstance *parent) : scope(scope), parent(parent) {
            name=scope.GetName()+" #"+String::From(scope.nextid++);
        }
        
        Return returns = Return({nullptr, false, false});
        int tempbase;
        
        //-unordered map
        std::map<std::string, Variable, String::CaseInsensitiveLess> variables;
 
        ScopeInstance *parent = nullptr;
        
        std::string name;
        
        Scope &scope;
 
        unsigned long current = 0;
    };
    
} }