public void SetArrayElement(int memoryIndex, int offset, RuntimeValue value)
 {
     _process.MemoryHeap[memoryIndex + offset] = value;
 }
 public void SetGlobalVariable(string identifier, RuntimeValue value)
 {
     _process.MemoryHeap[((VariableSymbol)_process.GlobalScope.FindSymbol(identifier, SymbolType.Variable)).MemoryIndex] = value.Clone();
 }
 /// <summary>
 ///		Pushs an empty element onto the stack.
 /// </summary>
 /// <param name="type">Type of empty value to push onto stack.</param>
 public RuntimeValue PushEmpty(RuntimeValueType type)
 {
     if (_topIndex >= _stack.Length - 1)
         Resize(_stack.Length + 1);
     _stack[_topIndex] = new RuntimeValue(type);
     return _stack[_topIndex++];
 }
 /// <summary>
 ///		Copys this value to another.
 /// </summary>
 public void CopyTo(RuntimeValue value)
 {
     value._booleanLiteral = _booleanLiteral;
     value._byteLiteral = _byteLiteral;
     value._doubleLiteral = _doubleLiteral;
     value._floatLiteral = _floatLiteral;
     value._integerLiteral = _integerLiteral;
     value._longLiteral = _longLiteral;
     value._memoryIndex = _memoryIndex;
     value._shortLiteral = _shortLiteral;
     value._stringLiteral = _stringLiteral;
     value._objectIndex = _objectIndex;
     value._instrIndex = _instrIndex;
     value._symbolIndex = _symbolIndex;
     value._symbol = _symbol;
     value._stackIndex = _stackIndex;
     value._register = _register;
     value._offsetRegister = _offsetRegister;
     value._valueType = _valueType;
     value._dataType = _dataType;
     value._referenceCount = _referenceCount;
 }
        /// <summary>
        ///     Sets the object value of a runtime value. This is used to keep reference counts up to date.
        /// </summary>
        /// <param name="value">Runtime value to set.</param>
        /// <param name="objectIndex">New object index.</param>
        private void SetObjectValue(RuntimeValue value, int objectIndex)
        {
            if (_process == null || value.ObjectIndex == objectIndex) return;

            for (int i = 0; i < _registers.Length; i++)
                if (value == _registers[i])
                {
                    value.ObjectIndex = objectIndex;
                    return;     // Don't bother about registers, they will loose there value soon.
                }

            if (value.ObjectIndex != -1 && _process.ObjectHeap[value.ObjectIndex] != null)
            {
                _process.ObjectHeap[value.ObjectIndex].ReferenceCount--;
                //System.Console.WriteLine("Reduced reference of (" + value.ObjectIndex + ", " + _process.ObjectHeap[value.ObjectIndex].ToString() + ") to " + _process.ObjectHeap[value.ObjectIndex].ReferenceCount);
            }

            value.ObjectIndex = objectIndex;

            if (value.ObjectIndex != -1 && _process.ObjectHeap[value.ObjectIndex] != null)
            {
                _process.ObjectHeap[value.ObjectIndex].ReferenceCount++;
                //System.Console.WriteLine("Increased reference of (" + value.ObjectIndex + ", " + _process.ObjectHeap[value.ObjectIndex].ToString() + ") to " + _process.ObjectHeap[value.ObjectIndex].ReferenceCount);
            }
        }
 /// <summary>
 ///		Clears all elements out of this stack.
 /// </summary>
 public void Clear()
 {
     for (int i = 0; i < _stack.Length; i++)
             _stack[i] = new RuntimeValue(0);
     _topIndex = 0;
     _frameIndex = 0;
 }
        /// <summary>
        ///     Copies a runtime array value from one thread to another whilst keeping track of objects and memory allocations.
        /// </summary>
        /// <param name="value">Value to copy.</param>
        /// <param name="toThread">Thread to copy from.</param>
        /// <param name="fromThread">Thread to copy to.</param>
        /// <returns>Memory index of new array.</returns>
        public int CopyValueArrayFromThread(RuntimeValue value, ScriptThread toThread, ScriptThread fromThread)
        {
            // Create the array.
            int arraySize = GetArrayLength(value.MemoryIndex);
            int arrayIndex = toThread.AllocateArray(value.DataType.DataType, arraySize);

            // Array of objects, how fun.
            if (value.DataType.DataType == DataType.Object)
            {
                for (int j = 0; j < arraySize; j++)
                {
                    RuntimeValue elementValue = fromThread._process.MemoryHeap[arrayIndex + j];
                    if (elementValue.ObjectIndex == -1)
                        toThread.SetArrayElement(arrayIndex, j, (RuntimeObject)null);
                    else
                        toThread.SetArrayElement(arrayIndex, j, fromThread._process.ObjectHeap[elementValue.ObjectIndex]);
                }
            }

            // Yay, an array of normal stuff.
            else
            {
                for (int j = 0; j < arraySize; j++)
                    toThread.SetArrayElement(arrayIndex, j, fromThread._process.MemoryHeap[arrayIndex + j]);
            }

            return arrayIndex;
        }
        /// <summary>
        ///		If the given value directly or indirectly points to another
        ///		value it will be resolved and returned.
        /// </summary>
        /// <param name="value">Value to resolve.</param>
        /// <returns>Resolved value.</returns>
        private RuntimeValue ResolveValue(RuntimeValue value)
        {
            switch (value.ValueType)
            {
                case RuntimeValueType.Register:
                    return _registers[(int)value.Register];

                case RuntimeValueType.DirectStack:
                    return _runtimeStack[value.StackIndex];
                case RuntimeValueType.DirectStackIndexed:
                    return _runtimeStack[value.StackIndex + _registers[(int)value.OffsetRegister].IntegerLiteral];
                case RuntimeValueType.IndirectStack:
                    return _runtimeStack[_registers[(int)value.Register].StackIndex];
                case RuntimeValueType.IndirectStackIndexed:
                    return _runtimeStack[_registers[(int)value.Register].StackIndex + _registers[(int)value.OffsetRegister].IntegerLiteral];

                case RuntimeValueType.DirectMemory:
                    return _process.MemoryHeap[value.MemoryIndex];
                case RuntimeValueType.DirectMemoryIndexed:
                    return _process.MemoryHeap[value.MemoryIndex + _registers[(int)value.OffsetRegister].IntegerLiteral];
                case RuntimeValueType.IndirectMemory:
                    return _process.MemoryHeap[_registers[(int)value.Register].MemoryIndex];
                case RuntimeValueType.IndirectMemoryIndexed:
                    return _process.MemoryHeap[_registers[(int)value.Register].MemoryIndex + _registers[(int)value.OffsetRegister].IntegerLiteral];

                default:
                    return value;
            }
        }
        /// <summary>
        ///		Allocates a chunk of data on the heap.
        /// </summary>
        /// <param name="size">Size of data to allocate.</param>
        /// <param name="type">Data type the allocated memory should store.</param>
        /// <param name="value">Data type this heap is stored as (differs from the type paramter 'type' as it keeps track of arrays and references to)</param>
        /// <returns>Starting index of data on the heap.</returns>
        public int AllocateHeap(int size, RuntimeValueType type, DataTypeValue value)
        {
            // Check if there is any space on the stack.
            // Ignore the constant and global memory index as they are persistant.
            int allocatableIndex = 0, allocatableSize = 0;

            // First element is reserved to capture null-to-zero-cast-to-memory-index (XD) errors.
            for (int i = 1; i < _memoryHeap.Length; i++)
            {
                if (_memoryHeap[i] != null)
                {
                    allocatableSize = 0;
                    allocatableIndex = i + 1;
                    if (_memoryHeap[i].ValueType == RuntimeValueType.MemoryBoundry)
                    {
                        i += _memoryHeap[i].IntegerLiteral;
                        allocatableIndex = i + 1;
                        continue;
                    }
                    i++;
                    continue;
                }
                else
                    allocatableSize++;

                if (allocatableSize >= (size + 1))
                    break;
            }
            if (allocatableSize < (size + 1))// || (allocatableIndex + allocatableSize) >= _memoryHeap.Length)
            {
                CollectGarbage(); // Desperatly try and free some space :S.
                if (allocatableSize + _lastCollectionMemoryCount < (size + 1))
                {
                    // If all else fails, resize. Its better than crashing.
                    Array.Resize(ref _memoryHeap, _memoryHeap.Length * 2 < _memoryHeap.Length + size ? _memoryHeap.Length + size : _memoryHeap.Length * 2); // Double the size.
                    DebugLogger.WriteLog("Memory heap of script '"+_url.ToString()+"' was resized due to overflow.");
                    return AllocateHeap(size, type, value);
                }
                else
                    return AllocateHeap(size, type, value);
            }

            // Actually allocate the data.
            for (int i = allocatableIndex; i <= (allocatableIndex + allocatableSize); i++)
                _memoryHeap[i] = new RuntimeValue(type);

            // Set the first data block as a memory boundry so the GC can look after it.
            _memoryHeap[allocatableIndex].ValueType = RuntimeValueType.MemoryBoundry;
            _memoryHeap[allocatableIndex].IntegerLiteral = size;
            _memoryHeap[allocatableIndex].ReferenceCount = 0;
            _memoryHeap[allocatableIndex].DataType = value;

            return allocatableIndex + 1;
        }
        /// <summary>
        ///		Loads the byte code from a given binary reader.
        /// </summary>
        /// <param name="reader">BinaryReader to load byte code from.</param>
        private void LoadByteCode(BinaryReader reader)
        {
            // Check the header is correct
            if (reader.ReadByte() == 'C' && reader.ReadByte() == 'R' && reader.ReadByte() == 'X')
            {
                // Read in header variables.
                _compileFlags			= (CompileFlags)reader.ReadInt32();
                _internalVariableIndex	= reader.ReadInt32();
                _memorySize				= reader.ReadInt32();
                int globalScopeIndex	= reader.ReadInt32();
                int memberScopeIndex = reader.ReadInt32();
                _defaultEngineStateIndex = reader.ReadInt32();
                _defaultEditorStateIndex = reader.ReadInt32();

                // Create a new memory heap of the correct size
                if (_memorySize > _memoryHeap.Length) _memoryHeap = new RuntimeValue[_memorySize];
                for (int i = 0; i < _memorySize; i++)
                    _memoryHeap[i] = new RuntimeValue(RuntimeValueType.Invalid);

                // Set the 'special' globals to their appropriate values.
                _memoryHeap[0].ValueType = RuntimeValueType.Object;
                _memoryHeap[0].ObjectIndex = 0;

                int defineCount = reader.ReadInt32();
                int symbolCount			= reader.ReadInt32();
                int instructionCount	= reader.ReadInt32();
                int debugFileCount		= 0;

                if ((_compileFlags & CompileFlags.Debug) != 0)
                    debugFileCount = reader.ReadInt32();

                // Read in debug file list.
                string[] debugFiles = new string[debugFileCount];
                if ((_compileFlags & CompileFlags.Debug) != 0)
                {
                    for (int i = 0; i < debugFileCount; i++)
                        debugFiles[i] = reader.ReadString();
                }

                // Read in the define list.
                for (int i = 0; i < defineCount; i++)
                {
                    string ident = reader.ReadString();
                    TokenID valueID = (TokenID)reader.ReadInt32();
                    string value = reader.ReadString();
                    Define define = new Define(ident, value, valueID);
                    _defineList.Add(define);
                }

                // Read in symbol list.
                _symbolList = new Symbol[symbolCount];
                for (int i = 0; i < symbolCount; i++)
                {
                    // Read in general details about symbol.
                    SymbolType type	  = (SymbolType)reader.ReadByte();
                    string identifier = reader.ReadString();
                    int scopeIndex	  = reader.ReadInt32();
                    Symbol scope	  = null;
                    Symbol symbol	  = null;

                    if (scopeIndex != -1)
                        scope = (Symbol)_symbolList[scopeIndex];

                    // Read in specialized details about symbol.
                    switch (type)
                    {
                        case SymbolType.JumpTarget:
                            continue; // Ignore jump targets.

                        case SymbolType.Namespace:
                            NamespaceSymbol namespaceSymbol = new NamespaceSymbol(scope);
                            symbol = namespaceSymbol;
                            break;

                        case SymbolType.Enumeration:
                            EnumerationSymbol enumSymbol = new EnumerationSymbol(scope);
                            symbol = enumSymbol;
                            break;

                        case SymbolType.String:
                            StringSymbol stringSymbol = new StringSymbol(scope, identifier);
                            symbol = stringSymbol;
                            break;

                        case SymbolType.Function:
                            FunctionSymbol functionSymbol = new FunctionSymbol(identifier, scope);
                            symbol = functionSymbol;
                            functionSymbol.EntryPoint = reader.ReadInt32();
                            functionSymbol.LocalDataSize = reader.ReadInt16();
                            functionSymbol.IsEvent = reader.ReadBoolean();
                            functionSymbol.IsConsole = reader.ReadBoolean();
                            functionSymbol.IsExport = reader.ReadBoolean();
                            functionSymbol.IsImport = reader.ReadBoolean();
                            functionSymbol.IsThreadSpawner = reader.ReadBoolean();
                            functionSymbol.IsMember = reader.ReadBoolean();
                            functionSymbol.ParameterCount = reader.ReadByte();
                            bool isArray = reader.ReadBoolean();
                            bool isReference = reader.ReadBoolean();
                            functionSymbol.ReturnType = new DataTypeValue((DataType)reader.ReadByte(), isArray, isReference);
                            functionSymbol.AccessModifier = (SymbolAccessModifier)reader.ReadByte();
                            break;

                        case SymbolType.State:
                            StateSymbol stateSymbol = new StateSymbol(scope);
                            symbol = stateSymbol;
                            stateSymbol.IsEngineDefault = reader.ReadBoolean();
                            stateSymbol.IsEditorDefault = reader.ReadBoolean();
                            break;

                        case SymbolType.Variable:
                            VariableSymbol variableSymbol = new VariableSymbol(scope);
                            symbol = variableSymbol;
                            variableSymbol.DataType		= new DataTypeValue((DataType)reader.ReadByte(), false, false);
                            variableSymbol.DataType.IsReference = reader.ReadBoolean();
                            variableSymbol.IsArray		= reader.ReadBoolean();
                            variableSymbol.DataType.IsArray = variableSymbol.IsArray;
                            variableSymbol.IsConstant	= reader.ReadBoolean();
                            variableSymbol.MemoryIndex	= reader.ReadInt32();
                            variableSymbol.StackIndex	= reader.ReadInt32();
                            variableSymbol.VariableType = (VariableType)reader.ReadByte();
                            variableSymbol.IsProperty = reader.ReadBoolean();
                            variableSymbol.AccessModifier = (SymbolAccessModifier)reader.ReadByte();
                            variableSymbol.ConstToken = new Token(TokenID.TypeIdentifier, reader.ReadString(), 0, 0, "");
                            break;

                        case SymbolType.MetaData:
                            MetaDataSymbol metaDataSymbol = new MetaDataSymbol(scope, identifier, "");
                            symbol = metaDataSymbol;
                            metaDataSymbol.Value = reader.ReadString();
                            break;
                    }

                    symbol.Identifier = identifier;
                    symbol.Index = i;
                    _symbolList[i] = symbol;
                }

                // Retrieve global scope.
                _globalScope = _symbolList[globalScopeIndex] as FunctionSymbol;
                _memberScope = _symbolList[memberScopeIndex] as FunctionSymbol;
                //_currentState = _symbolList[_defaultEngineStateIndex] as StateSymbol; // Force this to be declared in the engine / editor.

                // Read in instruction list.
                _instructionList = new RuntimeInstruction[instructionCount];
                for (int i = 0; i < instructionCount; i++)
                {
                    // Read in instruction details and create a new instruction.
                    OpCode opCode = (OpCode)reader.ReadByte();
                    int operandCount = reader.ReadByte();
                    RuntimeInstruction instruction = new RuntimeInstruction(opCode);
                    _instructionList[i] = instruction;

                    if ((_compileFlags & CompileFlags.Debug) != 0)
                    {
                        int fileIndex = reader.ReadSByte();
                        if (fileIndex != -1) instruction.File = debugFiles[fileIndex];
                        instruction.Offset = reader.ReadInt16();
                        instruction.Line   = reader.ReadInt16();
                    }

                    // Read in each operand attached to this instruction
                    for (int k = 0; k < operandCount; k++)
                    {
                        // Read in general details about this operand and create
                        // a new runtime value instance.
                        RuntimeValueType opType = (RuntimeValueType)reader.ReadInt32();
                        RuntimeValue operand = new RuntimeValue(opType);
                        instruction.Operands[instruction.OperandCount] = operand;
                        instruction.OperandCount++;

                        // Read in specialized info about this operand.
                        switch(opType)
                        {
                            case RuntimeValueType.BooleanLiteral:
                                operand.BooleanLiteral = reader.ReadBoolean();
                                break;
                            case RuntimeValueType.ByteLiteral:
                                operand.ByteLiteral = reader.ReadByte();
                                break;
                            case RuntimeValueType.DirectMemory:
                                operand.MemoryIndex = reader.ReadInt32();
                                break;
                            case RuntimeValueType.DirectMemoryIndexed:
                                operand.MemoryIndex = reader.ReadInt32();
                                operand.OffsetRegister = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.DirectStack:
                                operand.StackIndex = reader.ReadInt32();
                                break;
                            case RuntimeValueType.DirectStackIndexed:
                                operand.StackIndex = reader.ReadInt32();
                                operand.OffsetRegister = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.DoubleLiteral:
                                operand.DoubleLiteral = reader.ReadDouble();
                                break;
                            case RuntimeValueType.FloatLiteral:
                                operand.FloatLiteral = reader.ReadSingle();
                                break;
                            case RuntimeValueType.IndirectMemory:
                                operand.Register = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.IndirectMemoryIndexed:
                                operand.Register = (Register)reader.ReadByte();
                                operand.OffsetRegister = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.IndirectStack:
                                operand.Register = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.IndirectStackIndexed:
                                operand.Register = (Register)reader.ReadByte();
                                operand.OffsetRegister = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.InstrIndex:
                                operand.InstrIndex = reader.ReadInt32();
                                break;
                            case RuntimeValueType.IntegerLiteral:
                                operand.IntegerLiteral = reader.ReadInt32();
                                break;
                            case RuntimeValueType.LongLiteral:
                                operand.LongLiteral = reader.ReadInt64();
                                break;
                            case RuntimeValueType.Register:
                                operand.Register = (Register)reader.ReadByte();
                                break;
                            case RuntimeValueType.ShortLiteral:
                                operand.ShortLiteral = reader.ReadInt16();
                                break;
                            case RuntimeValueType.SymbolIndex:
                                operand.SymbolIndex = reader.ReadInt32();
                                operand.Symbol = (Symbol)_symbolList[operand.SymbolIndex];
                                if (operand.Symbol is StringSymbol)
                                {
                                    operand.StringLiteral = operand.Symbol.Identifier;
                                    operand.ValueType = RuntimeValueType.StringLiteral;
                                }
                                break;
                        }
                    }
                }

                // Fill the member-function hash table.
                foreach (Symbol symbol in GlobalScope.Symbols)
                    if (symbol != null && symbol.Type == SymbolType.Function && ((FunctionSymbol)symbol).AccessModifier == SymbolAccessModifier.Public)
                        _memberFunctionHashTable.Add(symbol.ToString().ToLower(), symbol);
            }
            else
                throw new Exception("Unable to load script byte code, header is invalid.");
        }
 /// <summary>
 ///		Copys this value to another.
 /// </summary>
 public void CopyTo(RuntimeValue value)
 {
     value._values = _values;
     value._stringLiteralValue = _stringLiteralValue;
     value._memoryIndex = _memoryIndex;
     value._objectIndex = _objectIndex;
     value._instrIndex = _instrIndex;
     value._symbolIndex = _symbolIndex;
     value._symbol = _symbol;
     value._stackIndex = _stackIndex;
     value._register = _register;
     value._offsetRegister = _offsetRegister;
     value._valueType = _valueType;
     value._dataType = _dataType;
     value._referenceCount = _referenceCount;
 }
 /// <summary>
 ///     Creates an exact clone of this value.
 /// </summary>
 /// <returns>Exact clone of this value.</returns>
 public RuntimeValue Clone()
 {
     RuntimeValue value = new RuntimeValue(RuntimeValueType.Invalid);
     CopyTo(value);
     return value;
 }
        /// <summary>
        ///     Sets the memory inde value of a runtime value. This is used to keep reference counts up to date.
        /// </summary>
        /// <param name="value">Runtime value to set.</param>
        /// <param name="memoryIndex">New memory index.</param>
        private void SetMemoryIndexValue(RuntimeValue value, int memoryIndex)
        {
            for (int i = 0; i < _registers.Length; i++)
                if (value == _registers[i])
                {
                    value.MemoryIndex = memoryIndex;
                    return;     // Don't bother about registers, they will loose there value soon.
                }

            if (value.MemoryIndex != -1 && _process.MemoryHeap[value.MemoryIndex - 1] != null)
                _process.MemoryHeap[value.MemoryIndex - 1].ReferenceCount--;

            value.MemoryIndex = memoryIndex;

            if (value.MemoryIndex != -1 && _process.MemoryHeap[value.MemoryIndex - 1] != null)
                _process.MemoryHeap[value.MemoryIndex - 1].ReferenceCount++;
        }
 public void SetLocalVariable(string identifier, RuntimeValue value)
 {
     RuntimeValue localValue = ResolveLocal(identifier);
     value.CopyTo(localValue);
 }
        /// <summary>
        ///     Copies a runtime value from one thread to another whilst keeping track of objects and memory allocations.
        /// </summary>
        /// <param name="value">Value to copy.</param>
        /// <param name="toThread">Thread to copy from.</param>
        /// <param name="fromThread">Thread to copy to.</param>
        /// <returns>New value.</returns>
        public RuntimeValue CopyValueFromThread(RuntimeValue value, ScriptThread toThread, ScriptThread fromThread)
        {
            if (value.ValueType == RuntimeValueType.Object)
            {
                int index = (value.ObjectIndex != -1) ? toThread._process.AllocateObjectIndex(fromThread._process.ObjectHeap[value.ObjectIndex]) : -1;
                RuntimeValue stackValue = new RuntimeValue(RuntimeValueType.Object);
                stackValue.DataType = value.DataType;
                SetObjectValue(stackValue, index);

                return stackValue;
            }
            else
            {
                return value;
            }
        }
 /// <summary>
 ///		Sets the return value as a given value.
 /// </summary>
 /// <param name="value">Value to move into return value.</param>
 public void SetReturnValue(RuntimeValue value)
 {
     _registers[(int)Register.Return] = value.Clone();
 }
 public void PassParameter(string value)
 {
     RuntimeValue stackValue = new RuntimeValue(RuntimeValueType.StringLiteral);
     stackValue.StringLiteral = value;
     _runtimeStack.Push(stackValue);
     _passedParameterCount++;
     _passedParameterMask.Add(new DataTypeValue(DataType.String, false, false));
 }
        /// <summary>
        ///     Sets the memory inde value of a runtime value. This is used to keep reference counts up to date.
        /// </summary>
        /// <param name="value">Runtime value to set.</param>
        /// <param name="memoryIndex">New memory index.</param>
        private void SetMemoryIndexValue(RuntimeValue value, int memoryIndex)
        {
            if (_process == null || value.MemoryIndex == memoryIndex) return;

            for (int i = 0; i < _registers.Length; i++)
                if (value == _registers[i])
                {
                    value.MemoryIndex = memoryIndex;
                    return;     // Don't bother about registers, they will loose there value soon.
                }

               // System.Console.WriteLine(_process.Instructions[_instructionPointer].OpCode + ": " + value.MemoryIndex + " to " + memoryIndex);

            if (value.MemoryIndex != -1 && _process.MemoryHeap[value.MemoryIndex - 1] != null)
            {
                _process.MemoryHeap[value.MemoryIndex - 1].ReferenceCount--;
               // System.Console.WriteLine("Decreased ref count of " + value.MemoryIndex + " to " + _process.MemoryHeap[value.MemoryIndex - 1].ReferenceCount);
            }

            value.MemoryIndex = memoryIndex;

            if (value.MemoryIndex != -1 && _process.MemoryHeap[value.MemoryIndex - 1] != null)
            {
                _process.MemoryHeap[value.MemoryIndex - 1].ReferenceCount++;
               // System.Console.WriteLine("Increased ref count of " + value.MemoryIndex + " to " + _process.MemoryHeap[value.MemoryIndex - 1].ReferenceCount);
            }
        }
        public void PassParameter(RuntimeObject value)
        {
            int index = _process.AllocateObjectIndex(value);
            RuntimeValue stackValue = new RuntimeValue(RuntimeValueType.Object);
            SetObjectValue(stackValue, index);

            _runtimeStack.Push(stackValue);
            _passedParameterCount++;
            _passedParameterMask.Add(new DataTypeValue(DataType.Object, false, false));
        }
 /// <summary>
 ///     Invoked when a script wants to set the value of an indexed member of this object.
 /// </summary>
 /// <param name="thread">Script thread that invoked this function.</param>
 /// <param name="variable">Symbol describing the member that it wants set.</param>
 /// <param name="value">Value it wants the member to be set to.</param>
 /// <param name="index">Index of member to it wants set.</param>
 /// <returns>True if successfull or false if not.</returns>
 public virtual bool SetMember(ScriptThread thread, VariableSymbol variable, RuntimeValue value, RuntimeValue indexer)
 {
     return false;
 }
 public void PassParameter(RuntimeValue value)
 {
     _runtimeStack.Push(value);
     _passedParameterCount++;
     _passedParameterMask.Add(value.DataType);
 }
 /// <summary>
 ///		Pushs a new value onto the top of the stack.
 /// </summary>
 /// <param name="value">Value to push onto stack.</param>
 public RuntimeValue Push(RuntimeValue value)
 {
     if (_topIndex >= _stack.Length - 1)
         Resize(_stack.Length + 1);
     _stack[_topIndex++] = value;
     return value;
 }
        public void PassParameterArray(int memoryIndex)
        {
            RuntimeValue stackValue = new RuntimeValue(RuntimeValueType.DirectMemory);
            SetMemoryIndexValue(stackValue, memoryIndex);

            _runtimeStack.Push(stackValue);
            _passedParameterCount++;
            _passedParameterMask.Add(_process.MemoryHeap[memoryIndex].DataType);
        }
        /// <summary>
        ///		Resizes the stack so it can store a given capacity 
        ///		of runtime values.
        /// </summary>
        /// <param name="capacity">New capacity of stack.</param>
        public void Resize(int capacity)
        {
            if (_stack == null)
                _stack = new RuntimeValue[capacity];
            else
                Array.Resize<RuntimeValue>(ref _stack, capacity);

            for (int i = 0; i < _stack.Length; i++)
                if (_stack[i] == null) _stack[i] = new RuntimeValue(0);
        }
Example #25
0
        /// <summary>
        ///     Invoked when a script wants to get the value of an indexed member of this object.
        /// </summary>
        /// <param name="thread">Script thread that invoked this function.</param>
        /// <param name="variable">Symbol describing the member that it wants get.</param>
        /// <param name="index">Index of member it want to get.</param>
        /// <returns>True if successfull or false if not.</returns>
        public override bool SetMember(ScriptThread thread, VariableSymbol variable, RuntimeValue value, RuntimeValue indexer)
        {
            if (_nativeObject is ScriptedEntityNode)
            {
                // Check the script process is valid.
                ScriptProcess process = ((ScriptedEntityNode)_nativeObject).ScriptProcess;
                if (process == null) return false;

                // See if we can get the symbol they are after.
                VariableSymbol processSymbol = process.GetSymbol(variable.Identifier, SymbolType.Variable) as VariableSymbol;
                if (processSymbol == null)
                    return false;

                // Grab the variable runtime value. (This can probably be optimized).
                RuntimeValue runtimeValue = process[0].GetRuntimeValueGlobal(processSymbol.Identifier);

                // Check its public.
                if (processSymbol.AccessModifier != SymbolAccessModifier.Public)
                    return false;

                // Check data types are correct.
                if (variable.DataType.DataType != processSymbol.DataType.DataType || processSymbol.DataType.IsArray != true)
                    return false;

                // Grab the arrays variable.
                RuntimeValue indexValue = process[0].GetRuntimeValueArrayElement(runtimeValue.MemoryIndex, indexer.IntegerLiteral);

                // Copy value.
                RuntimeValue copiedValue = process[0].CopyValueFromThread(value, process[0], thread);

                // Set value (this can be optimized).
                process[0].SetGlobalVariable(processSymbol.Identifier, copiedValue);
            }
            else if (_nativeObject is EntityNode)
            {

            }
            else if (_nativeObject is EmitterNode)
            {

            }
            else if (_nativeObject is TilemapSegmentNode)
            {

            }
            else if ((_nativeObject as SceneNode) != null)
            {

            }

            return false;
        }