Words VM Prototype

        internal void Execute(RuntimeObjects.WordsMethod function, EvaluationStack stack)
        {
            byte[] methodIL = function.ModifiedIL;
            int pos = 0;

            object[] arguments = new object[function.Symbol.Type.Arguments.Count];
            for (int i = 0; i < function.Symbol.Type.Arguments.Count; i++)
            {
                arguments[i] = stack.Pop();
            }

            object[] locals = new object[function.CompiledFunction.FunctionIL.Locals.Count];
            for (int i = 0; i < function.CompiledFunction.FunctionIL.Locals.Count; i++)
            {
                Core.Type t = function.CompiledFunction.FunctionIL.Locals[i].Item1;
                switch (t.BuiltinType)
                {
                    case InternalTypeCode.Int8:
                        locals[i] = (sbyte)0; break;
                    case InternalTypeCode.UInt8:
                        locals[i] = (byte)0; break;
                    case InternalTypeCode.Int16:
                        locals[i] = (short)0; break;
                    case InternalTypeCode.UInt16:
                        locals[i] = (ushort)0; break;
                    case InternalTypeCode.Int32:
                        locals[i] = (int)0; break;
                    case InternalTypeCode.UInt32:
                        locals[i] = (uint)0; break;
                    case InternalTypeCode.Int64:
                        locals[i] = (long)0; break;
                    case InternalTypeCode.UInt64:
                        locals[i] = (ulong)0; break;
                    case InternalTypeCode.Float32:
                        locals[i] = (float)0.0f; break;
                    case InternalTypeCode.Float64:
                        locals[i] = (double)0.0; break;
                    case InternalTypeCode.String:
                        locals[i] = string.Empty; break;
                    case InternalTypeCode.Object:
                        locals[i] = null; break;
                    default:
                        throw new Exception();
                }
            }

            unchecked
            {

                while (pos != methodIL.Length)
                {
                    OpCode code = (OpCode)methodIL[pos];
                    pos++;

                    switch (code)
                    {
                        case OpCode.LDC_I4_0:
                            stack.Push(0); break;
                        case OpCode.LDC_I4_1:
                            stack.Push(1); break;
                        case OpCode.LDC_I4_N1:
                            stack.Push(-1); break;
                        case OpCode.LDC_I4:
                            stack.Push(BitConverter.ToInt32(methodIL, pos)); pos += 4; break;
                        case OpCode.LDC_I8:
                            stack.Push(BitConverter.ToInt64(methodIL, pos)); pos += 8; break;
                        case OpCode.LDC_F4_0:
                            stack.Push(0.0f); break;
                        case OpCode.LDC_F4_1:
                            stack.Push(1.0f); break;
                        case OpCode.LDC_F4_N1:
                            stack.Push(-1.0f); break;
                        case OpCode.LDC_F4:
                            stack.Push(BitConverter.ToSingle(methodIL, pos)); pos += 4; break;
                        case OpCode.LDC_F8:
                            stack.Push(BitConverter.ToDouble(methodIL, pos)); pos += 8; break;
                        case OpCode.LD_STR:
                            stack.Push(function.CompiledFunction.FunctionIL.StringTable[BitConverter.ToInt32(methodIL, pos)]);
                            pos += 4;
                            break;
                        case OpCode.OP_ADD:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a + b);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a + b);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a + b);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a + b);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(a + b);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.OP_SUB:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a - b);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a - b);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a - b);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a - b);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.OP_MUL:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a * b);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a * b);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a * b);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a * b);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.OP_DIV:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a / b);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a / b);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a / b);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            uint b = (uint)(int)stack.Pop();
                                            stack.Push((int)(a / b));
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a / b);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            ulong b = (ulong)(long)stack.Pop();
                                            stack.Push((long)(a / b));
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.OP_MOD:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a % b);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a % b);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a % b);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            uint b = (uint)(int)stack.Pop();
                                            stack.Push((int)(a % b));
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a % b);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            ulong b = (ulong)(long)stack.Pop();
                                            stack.Push((long)(a % b));
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CMP_EQ:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a == b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a == b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a == b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a == b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(a == b ? 1 : 0);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CMP_NEQ:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a != b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a != b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a != b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a != b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(a != b ? 1 : 0);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CMP_GT:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a > b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a > b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a > b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a > b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            uint b = (uint)(int)stack.Pop();
                                            stack.Push(a > b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            ulong b = (ulong)(long)stack.Pop();
                                            stack.Push(a > b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(StringComparer.Ordinal.Compare(a, b) > 0 ? 1 : 0);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CMP_GTE:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a >= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a >= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a >= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a >= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            uint b = (uint)(int)stack.Pop();
                                            stack.Push(a >= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            ulong b = (ulong)(long)stack.Pop();
                                            stack.Push(a >= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(StringComparer.Ordinal.Compare(a, b) >= 0 ? 1 : 0);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CMP_LT:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a < b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a < b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a < b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a < b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            uint b = (uint)(int)stack.Pop();
                                            stack.Push(a < b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            ulong b = (ulong)(long)stack.Pop();
                                            stack.Push(a < b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(StringComparer.Ordinal.Compare(a, b) < 0 ? 1 : 0);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CMP_LTE:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            float b = (float)stack.Pop();
                                            stack.Push(a <= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            double b = (double)stack.Pop();
                                            stack.Push(a <= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            int b = (int)stack.Pop();
                                            stack.Push(a <= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            long b = (long)stack.Pop();
                                            stack.Push(a <= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            uint b = (uint)(int)stack.Pop();
                                            stack.Push(a <= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            ulong b = (ulong)(long)stack.Pop();
                                            stack.Push(a <= b ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            string b = (string)stack.Pop();
                                            stack.Push(StringComparer.Ordinal.Compare(a, b) <= 0 ? 1 : 0);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.CVT_BOOL:
                            {
                                NumericVariant mode = (NumericVariant)methodIL[pos++];
                                switch (mode)
                                {
                                    case NumericVariant.Float4:
                                        {
                                            float a = (float)stack.Pop();
                                            stack.Push(a != 0.0f ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Float8:
                                        {
                                            double a = (double)stack.Pop();
                                            stack.Push(a != 0.0 ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int4:
                                        {
                                            int a = (int)stack.Pop();
                                            stack.Push(a != 0 ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.Int8:
                                        {
                                            long a = (long)stack.Pop();
                                            stack.Push(a != 0 ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt4:
                                        {
                                            uint a = (uint)(int)stack.Pop();
                                            stack.Push(a != 0 ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.UInt8:
                                        {
                                            ulong a = (ulong)(long)stack.Pop();
                                            stack.Push(a != 0 ? 1 : 0);
                                            break;
                                        }
                                    case NumericVariant.String:
                                        {
                                            string a = (string)stack.Pop();
                                            stack.Push(string.IsNullOrEmpty(a) ? 0 : 1);
                                            break;
                                        }
                                    case NumericVariant.Object:
                                        {
                                            object a = (object)stack.Pop();
                                            stack.Push(a == null ? 0 : 1);
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.JMP_FALSE:
                            {
                                int o = (int)stack.Pop();
                                bool b = o == 0;
                                if (!b)
                                {
                                    pos += 4;
                                    break;
                                }
                                int index = BitConverter.ToInt32(methodIL, pos) - 1;
                                pos += index;
                                break;
                            }
                        case OpCode.JMP_TRUE:
                            {
                                int o = (int)stack.Pop();
                                bool b = o != 0;
                                if (!b)
                                {
                                    pos += 4;
                                    break;
                                }
                                int index = BitConverter.ToInt32(methodIL, pos) - 1;
                                pos += index;
                                break;
                            }
                        case OpCode.JMP:
                            {
                                int index = BitConverter.ToInt32(methodIL, pos) - 1;
                                pos += index;
                                break;
                            }
                        case OpCode.POP:
                            stack.Pop();
                            break;
                        case OpCode.RET:
                            goto Cleanup;
                        case OpCode.NOP:
                            break;
                        case OpCode.BOX:
                            {
                                int index = BitConverter.ToInt32(methodIL, pos);
                                pos += 4;
                                break;
                            }
                            break;
                        case OpCode.ST_LOC:
                            {
                                int index = BitConverter.ToInt32(methodIL, pos);
                                pos += 4;
                                switch (function.CompiledFunction.FunctionIL.Locals[index].Item1.BuiltinType)
                                {
                                    case InternalTypeCode.Int8:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = (sbyte)x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt8:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = (byte)x;
                                            break;
                                        }
                                    case InternalTypeCode.Int16:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = (short)x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt16:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = (ushort)x;
                                            break;
                                        }
                                    case InternalTypeCode.Int32:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt32:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = (uint)x;
                                            break;
                                        }
                                    case InternalTypeCode.Int64:
                                        {
                                            long x = (long)stack.Pop();
                                            locals[index] = x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt64:
                                        {
                                            long x = (long)stack.Pop();
                                            locals[index] = (ulong)x;
                                            break;
                                        }
                                    case InternalTypeCode.Float32:
                                        {
                                            locals[index] = (float)stack.Pop();
                                            break;
                                        }
                                    case InternalTypeCode.Float64:
                                        {
                                            locals[index] = (double)stack.Pop();
                                            break;
                                        }
                                    case InternalTypeCode.Boolean:
                                        {
                                            int x = (int)stack.Pop();
                                            locals[index] = x > 0;
                                            break;
                                        }
                                    case InternalTypeCode.String:
                                        {
                                            locals[index] = (string)stack.Pop();
                                            break;
                                        }
                                    case InternalTypeCode.Object:
                                        {
                                            locals[index] = stack.Pop();
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.ST_ARG:
                            {
                                int index = BitConverter.ToInt32(methodIL, pos);
                                pos += 4;
                                switch (function.Symbol.Type.Arguments[index].BuiltinType)
                                {
                                    case InternalTypeCode.Int8:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = (sbyte)x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt8:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = (byte)x;
                                            break;
                                        }
                                    case InternalTypeCode.Int16:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = (short)x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt16:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = (ushort)x;
                                            break;
                                        }
                                    case InternalTypeCode.Int32:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt32:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = (uint)x;
                                            break;
                                        }
                                    case InternalTypeCode.Int64:
                                        {
                                            long x = (long)stack.Pop();
                                            arguments[index] = x;
                                            break;
                                        }
                                    case InternalTypeCode.UInt64:
                                        {
                                            long x = (long)stack.Pop();
                                            arguments[index] = (ulong)x;
                                            break;
                                        }
                                    case InternalTypeCode.Float32:
                                        {
                                            arguments[index] = (float)stack.Pop();
                                            break;
                                        }
                                    case InternalTypeCode.Float64:
                                        {
                                            arguments[index] = (double)stack.Pop();
                                            break;
                                        }
                                    case InternalTypeCode.Boolean:
                                        {
                                            int x = (int)stack.Pop();
                                            arguments[index] = x > 0;
                                            break;
                                        }
                                    case InternalTypeCode.String:
                                        {
                                            arguments[index] = (string)stack.Pop();
                                            break;
                                        }
                                    case InternalTypeCode.Object:
                                        {
                                            arguments[index] = stack.Pop();
                                            break;
                                        }
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.LD_ARG:
                            {
                                int index = BitConverter.ToInt32(methodIL, pos);
                                pos += 4;
                                switch (function.Symbol.Type.Arguments[index].BuiltinType)
                                {
                                    case InternalTypeCode.Int8:
                                        stack.Push((int)(sbyte)arguments[index]); break;
                                    case InternalTypeCode.UInt8:
                                        stack.Push((int)(byte)arguments[index]); break;
                                    case InternalTypeCode.Int16:
                                        stack.Push((int)(short)arguments[index]); break;
                                    case InternalTypeCode.UInt16:
                                        stack.Push((int)(ushort)arguments[index]); break;
                                    case InternalTypeCode.Int32:
                                        stack.Push((int)arguments[index]); break;
                                    case InternalTypeCode.UInt32:
                                        stack.Push((int)(uint)arguments[index]); break;
                                    case InternalTypeCode.Int64:
                                        stack.Push((long)arguments[index]); break;
                                    case InternalTypeCode.UInt64:
                                        stack.Push((ulong)(long)arguments[index]); break;
                                    case InternalTypeCode.Float32:
                                        stack.Push((float)arguments[index]); break;
                                    case InternalTypeCode.Float64:
                                        stack.Push((double)arguments[index]); break;
                                    case InternalTypeCode.Boolean:
                                        stack.Push(((bool)arguments[index]) ? 1 : 0); break;
                                    case InternalTypeCode.String:
                                        stack.Push((string)arguments[index]); break;
                                    case InternalTypeCode.Object:
                                        stack.Push(arguments[index]); break;
                                        break;
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }
                        case OpCode.LD_LOC:
                            {
                                int index = BitConverter.ToInt32(methodIL, pos);
                                pos += 4;
                                switch (function.CompiledFunction.FunctionIL.Locals[index].Item1.BuiltinType)
                                {
                                    case InternalTypeCode.Int8:
                                        stack.Push((int)(sbyte)locals[index]); break;
                                    case InternalTypeCode.UInt8:
                                        stack.Push((int)(byte)locals[index]); break;
                                    case InternalTypeCode.Int16:
                                        stack.Push((int)(short)locals[index]); break;
                                    case InternalTypeCode.UInt16:
                                        stack.Push((int)(ushort)locals[index]); break;
                                    case InternalTypeCode.Int32:
                                        stack.Push((int)locals[index]); break;
                                    case InternalTypeCode.UInt32:
                                        stack.Push((int)(uint)locals[index]); break;
                                    case InternalTypeCode.Int64:
                                        stack.Push((long)locals[index]); break;
                                    case InternalTypeCode.UInt64:
                                        stack.Push((ulong)(long)locals[index]); break;
                                    case InternalTypeCode.Float32:
                                        stack.Push((float)locals[index]); break;
                                    case InternalTypeCode.Float64:
                                        stack.Push((double)locals[index]); break;
                                    case InternalTypeCode.Boolean:
                                        stack.Push(((bool)locals[index]) ? 1 : 0); break;
                                    case InternalTypeCode.String:
                                        stack.Push((string)locals[index]); break;
                                    case InternalTypeCode.Object:
                                        stack.Push(locals[index]); break;
                                        break;
                                    default:
                                        throw new Exception();
                                }
                                break;
                            }

                        case OpCode.TRUNC_S1:
                            stack.Push((int)(sbyte)(int)stack.Pop()); break;
                        case OpCode.TRUNC_U1:
                            stack.Push((int)(byte)(int)stack.Pop()); break;
                        case OpCode.TRUNC_S2:
                            stack.Push((int)(short)(int)stack.Pop()); break;
                        case OpCode.TRUNC_U2:
                            stack.Push((int)(ushort)(int)stack.Pop()); break;
                        case OpCode.CONV_I4_I8:
                            stack.Push((long)(int)stack.Pop()); break;
                        case OpCode.CONV_I4_F4:
                            stack.Push((float)(int)stack.Pop()); break;
                        case OpCode.CONV_I4_F8:
                            stack.Push((double)(int)stack.Pop()); break;
                        case OpCode.CONV_U4_I8:
                            stack.Push((long)(uint)(int)stack.Pop()); break;
                        case OpCode.CONV_U4_F4:
                            stack.Push((float)(uint)(int)stack.Pop()); break;
                        case OpCode.CONV_U4_F8:
                            stack.Push((double)(uint)(int)stack.Pop()); break;
                        case OpCode.CONV_I8_I4:
                            stack.Push((int)(long)stack.Pop()); break;
                        case OpCode.CONV_I8_F4:
                            stack.Push((float)(long)stack.Pop()); break;
                        case OpCode.CONV_I8_F8:
                            stack.Push((double)(long)stack.Pop()); break;
                        case OpCode.CONV_U8_F4:
                            stack.Push((float)(ulong)(long)stack.Pop()); break;
                        case OpCode.CONV_U8_F8:
                            stack.Push((double)(ulong)(long)stack.Pop()); break;
                        case OpCode.CONV_F4_I8:
                            stack.Push((long)(float)stack.Pop()); break;
                        case OpCode.CONV_F4_I4:
                            stack.Push((int)(float)stack.Pop()); break;
                        case OpCode.CONV_F4_F8:
                            stack.Push((double)(float)stack.Pop()); break;
                        case OpCode.CONV_F8_I8:
                            stack.Push((long)(double)stack.Pop()); break;
                        case OpCode.CONV_F8_I4:
                            stack.Push((int)(double)stack.Pop()); break;
                        case OpCode.CONV_F8_F4:
                            stack.Push((float)(double)stack.Pop()); break;

                        case OpCode.CALL_STATIC:
                            {
                                int callID = BitConverter.ToInt32(methodIL, pos);
                                pos += 4;
                                RuntimeObjects.RuntimeMethod rm = function.ResolvedSymbols[callID] as RuntimeObjects.RuntimeMethod;
                                rm.Execute(this, stack);
                                break;
                            }

                        default:
                            throw new Exception();
                    }

                    // Leaving switch
                }

            Cleanup:
                ;

                // Main IL loop
            }
            // Unchecked

            return;
        }