VirtualMachine.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <string>
#include <thread>
 
#include "../Types.h"
#include "../Event.h"
#include "../Containers/Collection.h"
#include "../Containers/Hashmap.h"
 
#include "Reflection.h"
#include "Runtime.h"
#include "Data.h"
#include "Exceptions.h"
#include "Instruction.h"
#include "Scope.h"
 
 
 
namespace Gorgon {
    
    namespace Scripting {
        
        class Symbol {
        public:
            std::string namespc;
            
            SymbolType  type;
            
            Any object;
            
            // Name of the symbol is optimized out
            // std::string name;
        };
        
        extern Library Reflection, Integrals, Keywords, Math;
 
        
        class VirtualMachine {
        public:
 
            explicit VirtualMachine(bool automaticreset=true, std::ostream &out=std::cout, std::istream &in=std::cin);
            
            ~VirtualMachine() {
            }
 
            bool ExecuteStatement(const std::string &code, InputProvider::Dialect dialect = InputProvider::Programming);
            
            Data ExecuteFunction(const Function *fn, const std::vector<Data> &params, bool method);
            
            void Run();
 
            void Run(std::shared_ptr<ScopeInstance> scope);
 
            void Run(unsigned executiontarget);
 
            void Start(InputProvider &input);
            
            void Begin(InputProvider &input);
            
            void CompileCurrent();
 
            void AddLibrary(const Library &library);
 
            void RemoveLibrary(const Library &library);
 
            void UsingNamespace(const Namespace &name);
            
            void UsingNamespace(const std::string &name);
            
            void Jump(unsigned long line);
 
            void Jump(SourceMarker marker);
 
            void LongJump(SourceMarker marker);
            
            Data FindSymbol(const std::string &original, bool reference=false, bool allownull=false);
 
 
            static VirtualMachine &Get() {
                if(!activevms.Exists(std::this_thread::get_id())) {
                    throw std::runtime_error("No active VMs for this thread.");
                }
 
                return activevms[std::this_thread::get_id()];
            }
 
            static bool Exists() {
                return activevms.Exists(std::this_thread::get_id());
            }
 
            bool IsVariableSet(const std::string &name);
            
            Variable GetVariable(const std::string &name);
 
            void SetVariable(const std::string &name, Data data, bool ref=false);
            
            void UnsetVariable(const std::string &name);
 
            void AttachCommandConsole();
 
            bool DetachCommandConsole();
 
            void SetOutput(std::ostream &out, bool deleteonchange=false);
 
            void SetInput(std::istream &in);
 
            std::ostream &GetOutput() const {
                return *output;
            }
 
            std::istream &GetInput() const {
                return *input;
            }
 
            void ResetOutput() {
                if(deleteoutonchange) delete output;
                deleteoutonchange=false;
                
                output=defoutput;
            }
 
            void ResetInput() {
                input=definput;
            }
 
            void Activate() {
                activevms.Add(std::this_thread::get_id(), this);
            }
 
            unsigned GetScopeInstanceCount() const {
                return (unsigned)scopeinstances.size();
            }
            
            ScopeInstance &CurrentScopeInstance() const {
                return *scopeinstances.back();
            }
 
            SourceMarker GetMarkerForNext() const {
                return scopeinstances.front()->GetMarkerForNext();
            }
            
            
            Data GetReturnValue() const {
                return returnvalue;
            }
            
            void Return(Data value=Data::Invalid()) {
                if(scopeinstances.size()==0) {
                    throw std::runtime_error("No scope instance to return from.");
                }
                scopeinstances.back()->ReturnValue=value;
                returnimmediately=true;
            }
            
            void SetSpecialIdentifierHandler(std::function<Data(char,std::string)> handler) {
                spechandler=handler;
            }
 
            void Reset();
            
            Variable *getvarref(const std::string &var);
 
            const Containers::Collection<const Library> &Libraries;
 
            ReferenceCounter References;
 
        private:
            void execute(const Instruction* inst);
            Data callfunction(const Function *fn, bool method, const std::vector<Value> &params);
            Data callvariant(const Function *fn, const Function::Overload *variant, bool method, const std::vector<Value> &params);
            Data getvalue(const Value &val, bool reference=false);
            void functioncall(const Instruction *inst, bool memberonly, bool method);
            void activatescopeinstance(std::shared_ptr<ScopeInstance> instance);
            void addsymbol(const StaticMember &symbol);
 
            Containers::Collection<const Library> libraries;
 
            std::string alllibnames;
            
            bool returnimmediately=false;
            
            //special identifier handler.
            std::function<Data(char, std::string)> spechandler;
 
 
            bool automaticreset;
            
            Data returnvalue=Data::Invalid();
 
            std::vector<std::shared_ptr<ScopeInstance>> scopeinstances;
            Containers::Collection<Scope>               scopes;
 
            int highesttemp=0;
            int tempbase = -1;
 
            std::ostream *output;
            std::istream *input;
 
            std::ostream *defoutput;
            std::istream *definput;
            
            bool deleteoutonchange=false;
 
            std::vector<Data> temporaries;
            
            std::shared_ptr<ScopeInstance> toplevel;
            
            
            static Containers::Hashmap<std::thread::id, VirtualMachine> activevms;
        };
        
        
    }
}