Instruction.h

Go to the documentation of this file.

#pragma once
#include "../Scripting.h"
 
namespace Gorgon { namespace Scripting {
    
        enum class InstructionType {
            Unknown,
 
            FunctionCall,
 
            MemberFunctionCall, 
 
            MethodCall,
            
            MemberToTemp,
            
            MemberToVar,
            
            MemberAssignment,
 
            MemberMethodCall,
 
            Assignment,
            
            RemoveTemp,
            
            SaveToTemp,
            
            Jump,
            
            JumpFalse,
            
            JumpTrue,
            
            DeclOverload,
        };
 
        enum class ValueType {
            Temp,
            
            Literal,
            
            Variable,
            
            Identifier,
            
            None,
        };
        
        struct Value {
            std::string Name;
 
            Data Literal=Data::Invalid();
 
            ValueType Type;
 
            Byte Result;
            
            void SetLiteral(const Scripting::Type *type, Any value) {
                Type=ValueType::Literal;
                Literal={type, value};
            }
            
            void SetLiteral(const Data &value) {
                Type=ValueType::Literal;
                Literal=value;
            }
            
            void SetStringLiteral(const std::string &value) {
                Type=ValueType::Literal;
                Literal={Types::String(), {value}};
            }
            
            void SetVariable(const std::string &name) {
                Type=ValueType::Variable;
                Name=name;
            }
            
            void SetIdentifier(const std::string &name) {
                Type=ValueType::Identifier;
                Name=name;
            }
            
            void SetTemp(Byte index) {
                Type=ValueType::Temp;
                Result=index;
            }
            
            std::string ToString() const {
                if(Type==ValueType::Temp) {
                    return String::From(Result);
                }
                else if(Type==ValueType::Literal) {
                    return Literal.ToString();
                }
                else {
                    return Name;
                }
            }
        };
        
        struct Instruction {
            Instruction() { }
            
            Instruction(const Instruction &inst) :
            Type(inst.Type), Name(inst.Name), RHS(inst.RHS), Parameters(inst.Parameters), JumpOffset(inst.JumpOffset),
            Reference(inst.Reference)
            { }
            
            InstructionType Type = InstructionType::Unknown;
            
            Value Name;
            
            Value RHS;
            
            std::vector<Value> Parameters;
            
            bool Reference=false;
 
            union {
                Byte Store;
                int JumpOffset=0;
            };
        };
} }