daily pastebin goal
20%
SHARE
TWEET

Words VM Prototype

a guest Jan 26th, 2014 5 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
 
  1.         internal void Execute(RuntimeObjects.WordsMethod function, EvaluationStack stack)
  2.         {
  3.             byte[] methodIL = function.ModifiedIL;
  4.             int pos = 0;
  5.  
  6.             object[] arguments = new object[function.Symbol.Type.Arguments.Count];
  7.             for (int i = 0; i < function.Symbol.Type.Arguments.Count; i++)
  8.             {
  9.                 arguments[i] = stack.Pop();
  10.             }
  11.  
  12.             object[] locals = new object[function.CompiledFunction.FunctionIL.Locals.Count];
  13.             for (int i = 0; i < function.CompiledFunction.FunctionIL.Locals.Count; i++)
  14.             {
  15.                 Core.Type t = function.CompiledFunction.FunctionIL.Locals[i].Item1;
  16.                 switch (t.BuiltinType)
  17.                 {
  18.                     case InternalTypeCode.Int8:
  19.                         locals[i] = (sbyte)0; break;
  20.                     case InternalTypeCode.UInt8:
  21.                         locals[i] = (byte)0; break;
  22.                     case InternalTypeCode.Int16:
  23.                         locals[i] = (short)0; break;
  24.                     case InternalTypeCode.UInt16:
  25.                         locals[i] = (ushort)0; break;
  26.                     case InternalTypeCode.Int32:
  27.                         locals[i] = (int)0; break;
  28.                     case InternalTypeCode.UInt32:
  29.                         locals[i] = (uint)0; break;
  30.                     case InternalTypeCode.Int64:
  31.                         locals[i] = (long)0; break;
  32.                     case InternalTypeCode.UInt64:
  33.                         locals[i] = (ulong)0; break;
  34.                     case InternalTypeCode.Float32:
  35.                         locals[i] = (float)0.0f; break;
  36.                     case InternalTypeCode.Float64:
  37.                         locals[i] = (double)0.0; break;
  38.                     case InternalTypeCode.String:
  39.                         locals[i] = string.Empty; break;
  40.                     case InternalTypeCode.Object:
  41.                         locals[i] = null; break;
  42.                     default:
  43.                         throw new Exception();
  44.                 }
  45.             }
  46.  
  47.             unchecked
  48.             {
  49.  
  50.                 while (pos != methodIL.Length)
  51.                 {
  52.                     OpCode code = (OpCode)methodIL[pos];
  53.                     pos++;
  54.  
  55.                     switch (code)
  56.                     {
  57.                         case OpCode.LDC_I4_0:
  58.                             stack.Push(0); break;
  59.                         case OpCode.LDC_I4_1:
  60.                             stack.Push(1); break;
  61.                         case OpCode.LDC_I4_N1:
  62.                             stack.Push(-1); break;
  63.                         case OpCode.LDC_I4:
  64.                             stack.Push(BitConverter.ToInt32(methodIL, pos)); pos += 4; break;
  65.                         case OpCode.LDC_I8:
  66.                             stack.Push(BitConverter.ToInt64(methodIL, pos)); pos += 8; break;
  67.                         case OpCode.LDC_F4_0:
  68.                             stack.Push(0.0f); break;
  69.                         case OpCode.LDC_F4_1:
  70.                             stack.Push(1.0f); break;
  71.                         case OpCode.LDC_F4_N1:
  72.                             stack.Push(-1.0f); break;
  73.                         case OpCode.LDC_F4:
  74.                             stack.Push(BitConverter.ToSingle(methodIL, pos)); pos += 4; break;
  75.                         case OpCode.LDC_F8:
  76.                             stack.Push(BitConverter.ToDouble(methodIL, pos)); pos += 8; break;
  77.                         case OpCode.LD_STR:
  78.                             stack.Push(function.CompiledFunction.FunctionIL.StringTable[BitConverter.ToInt32(methodIL, pos)]);
  79.                             pos += 4;
  80.                             break;
  81.                         case OpCode.OP_ADD:
  82.                             {
  83.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  84.                                 switch (mode)
  85.                                 {
  86.                                     case NumericVariant.Float4:
  87.                                         {
  88.                                             float a = (float)stack.Pop();
  89.                                             float b = (float)stack.Pop();
  90.                                             stack.Push(a + b);
  91.                                             break;
  92.                                         }
  93.                                     case NumericVariant.Float8:
  94.                                         {
  95.                                             double a = (double)stack.Pop();
  96.                                             double b = (double)stack.Pop();
  97.                                             stack.Push(a + b);
  98.                                             break;
  99.                                         }
  100.                                     case NumericVariant.UInt4:
  101.                                     case NumericVariant.Int4:
  102.                                         {
  103.                                             int a = (int)stack.Pop();
  104.                                             int b = (int)stack.Pop();
  105.                                             stack.Push(a + b);
  106.                                             break;
  107.                                         }
  108.                                     case NumericVariant.UInt8:
  109.                                     case NumericVariant.Int8:
  110.                                         {
  111.                                             long a = (long)stack.Pop();
  112.                                             long b = (long)stack.Pop();
  113.                                             stack.Push(a + b);
  114.                                             break;
  115.                                         }
  116.                                     case NumericVariant.String:
  117.                                         {
  118.                                             string a = (string)stack.Pop();
  119.                                             string b = (string)stack.Pop();
  120.                                             stack.Push(a + b);
  121.                                             break;
  122.                                         }
  123.                                     default:
  124.                                         throw new Exception();
  125.                                 }
  126.                                 break;
  127.                             }
  128.                         case OpCode.OP_SUB:
  129.                             {
  130.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  131.                                 switch (mode)
  132.                                 {
  133.                                     case NumericVariant.Float4:
  134.                                         {
  135.                                             float a = (float)stack.Pop();
  136.                                             float b = (float)stack.Pop();
  137.                                             stack.Push(a - b);
  138.                                             break;
  139.                                         }
  140.                                     case NumericVariant.Float8:
  141.                                         {
  142.                                             double a = (double)stack.Pop();
  143.                                             double b = (double)stack.Pop();
  144.                                             stack.Push(a - b);
  145.                                             break;
  146.                                         }
  147.                                     case NumericVariant.UInt4:
  148.                                     case NumericVariant.Int4:
  149.                                         {
  150.                                             int a = (int)stack.Pop();
  151.                                             int b = (int)stack.Pop();
  152.                                             stack.Push(a - b);
  153.                                             break;
  154.                                         }
  155.                                     case NumericVariant.UInt8:
  156.                                     case NumericVariant.Int8:
  157.                                         {
  158.                                             long a = (long)stack.Pop();
  159.                                             long b = (long)stack.Pop();
  160.                                             stack.Push(a - b);
  161.                                             break;
  162.                                         }
  163.                                     default:
  164.                                         throw new Exception();
  165.                                 }
  166.                                 break;
  167.                             }
  168.                         case OpCode.OP_MUL:
  169.                             {
  170.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  171.                                 switch (mode)
  172.                                 {
  173.                                     case NumericVariant.Float4:
  174.                                         {
  175.                                             float a = (float)stack.Pop();
  176.                                             float b = (float)stack.Pop();
  177.                                             stack.Push(a * b);
  178.                                             break;
  179.                                         }
  180.                                     case NumericVariant.Float8:
  181.                                         {
  182.                                             double a = (double)stack.Pop();
  183.                                             double b = (double)stack.Pop();
  184.                                             stack.Push(a * b);
  185.                                             break;
  186.                                         }
  187.                                     case NumericVariant.UInt4:
  188.                                     case NumericVariant.Int4:
  189.                                         {
  190.                                             int a = (int)stack.Pop();
  191.                                             int b = (int)stack.Pop();
  192.                                             stack.Push(a * b);
  193.                                             break;
  194.                                         }
  195.                                     case NumericVariant.UInt8:
  196.                                     case NumericVariant.Int8:
  197.                                         {
  198.                                             long a = (long)stack.Pop();
  199.                                             long b = (long)stack.Pop();
  200.                                             stack.Push(a * b);
  201.                                             break;
  202.                                         }
  203.                                     default:
  204.                                         throw new Exception();
  205.                                 }
  206.                                 break;
  207.                             }
  208.                         case OpCode.OP_DIV:
  209.                             {
  210.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  211.                                 switch (mode)
  212.                                 {
  213.                                     case NumericVariant.Float4:
  214.                                         {
  215.                                             float a = (float)stack.Pop();
  216.                                             float b = (float)stack.Pop();
  217.                                             stack.Push(a / b);
  218.                                             break;
  219.                                         }
  220.                                     case NumericVariant.Float8:
  221.                                         {
  222.                                             double a = (double)stack.Pop();
  223.                                             double b = (double)stack.Pop();
  224.                                             stack.Push(a / b);
  225.                                             break;
  226.                                         }
  227.                                     case NumericVariant.Int4:
  228.                                         {
  229.                                             int a = (int)stack.Pop();
  230.                                             int b = (int)stack.Pop();
  231.                                             stack.Push(a / b);
  232.                                             break;
  233.                                         }
  234.                                     case NumericVariant.UInt4:
  235.                                         {
  236.                                             uint a = (uint)(int)stack.Pop();
  237.                                             uint b = (uint)(int)stack.Pop();
  238.                                             stack.Push((int)(a / b));
  239.                                             break;
  240.                                         }
  241.                                     case NumericVariant.Int8:
  242.                                         {
  243.                                             long a = (long)stack.Pop();
  244.                                             long b = (long)stack.Pop();
  245.                                             stack.Push(a / b);
  246.                                             break;
  247.                                         }
  248.                                     case NumericVariant.UInt8:
  249.                                         {
  250.                                             ulong a = (ulong)(long)stack.Pop();
  251.                                             ulong b = (ulong)(long)stack.Pop();
  252.                                             stack.Push((long)(a / b));
  253.                                             break;
  254.                                         }
  255.                                     default:
  256.                                         throw new Exception();
  257.                                 }
  258.                                 break;
  259.                             }
  260.                         case OpCode.OP_MOD:
  261.                             {
  262.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  263.                                 switch (mode)
  264.                                 {
  265.                                     case NumericVariant.Float4:
  266.                                         {
  267.                                             float a = (float)stack.Pop();
  268.                                             float b = (float)stack.Pop();
  269.                                             stack.Push(a % b);
  270.                                             break;
  271.                                         }
  272.                                     case NumericVariant.Float8:
  273.                                         {
  274.                                             double a = (double)stack.Pop();
  275.                                             double b = (double)stack.Pop();
  276.                                             stack.Push(a % b);
  277.                                             break;
  278.                                         }
  279.                                     case NumericVariant.Int4:
  280.                                         {
  281.                                             int a = (int)stack.Pop();
  282.                                             int b = (int)stack.Pop();
  283.                                             stack.Push(a % b);
  284.                                             break;
  285.                                         }
  286.                                     case NumericVariant.UInt4:
  287.                                         {
  288.                                             uint a = (uint)(int)stack.Pop();
  289.                                             uint b = (uint)(int)stack.Pop();
  290.                                             stack.Push((int)(a % b));
  291.                                             break;
  292.                                         }
  293.                                     case NumericVariant.Int8:
  294.                                         {
  295.                                             long a = (long)stack.Pop();
  296.                                             long b = (long)stack.Pop();
  297.                                             stack.Push(a % b);
  298.                                             break;
  299.                                         }
  300.                                     case NumericVariant.UInt8:
  301.                                         {
  302.                                             ulong a = (ulong)(long)stack.Pop();
  303.                                             ulong b = (ulong)(long)stack.Pop();
  304.                                             stack.Push((long)(a % b));
  305.                                             break;
  306.                                         }
  307.                                     default:
  308.                                         throw new Exception();
  309.                                 }
  310.                                 break;
  311.                             }
  312.                         case OpCode.CMP_EQ:
  313.                             {
  314.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  315.                                 switch (mode)
  316.                                 {
  317.                                     case NumericVariant.Float4:
  318.                                         {
  319.                                             float a = (float)stack.Pop();
  320.                                             float b = (float)stack.Pop();
  321.                                             stack.Push(a == b ? 1 : 0);
  322.                                             break;
  323.                                         }
  324.                                     case NumericVariant.Float8:
  325.                                         {
  326.                                             double a = (double)stack.Pop();
  327.                                             double b = (double)stack.Pop();
  328.                                             stack.Push(a == b ? 1 : 0);
  329.                                             break;
  330.                                         }
  331.                                     case NumericVariant.UInt4:
  332.                                     case NumericVariant.Int4:
  333.                                         {
  334.                                             int a = (int)stack.Pop();
  335.                                             int b = (int)stack.Pop();
  336.                                             stack.Push(a == b ? 1 : 0);
  337.                                             break;
  338.                                         }
  339.                                     case NumericVariant.UInt8:
  340.                                     case NumericVariant.Int8:
  341.                                         {
  342.                                             long a = (long)stack.Pop();
  343.                                             long b = (long)stack.Pop();
  344.                                             stack.Push(a == b ? 1 : 0);
  345.                                             break;
  346.                                         }
  347.                                     case NumericVariant.String:
  348.                                         {
  349.                                             string a = (string)stack.Pop();
  350.                                             string b = (string)stack.Pop();
  351.                                             stack.Push(a == b ? 1 : 0);
  352.                                             break;
  353.                                         }
  354.                                     default:
  355.                                         throw new Exception();
  356.                                 }
  357.                                 break;
  358.                             }
  359.                         case OpCode.CMP_NEQ:
  360.                             {
  361.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  362.                                 switch (mode)
  363.                                 {
  364.                                     case NumericVariant.Float4:
  365.                                         {
  366.                                             float a = (float)stack.Pop();
  367.                                             float b = (float)stack.Pop();
  368.                                             stack.Push(a != b ? 1 : 0);
  369.                                             break;
  370.                                         }
  371.                                     case NumericVariant.Float8:
  372.                                         {
  373.                                             double a = (double)stack.Pop();
  374.                                             double b = (double)stack.Pop();
  375.                                             stack.Push(a != b ? 1 : 0);
  376.                                             break;
  377.                                         }
  378.                                     case NumericVariant.UInt4:
  379.                                     case NumericVariant.Int4:
  380.                                         {
  381.                                             int a = (int)stack.Pop();
  382.                                             int b = (int)stack.Pop();
  383.                                             stack.Push(a != b ? 1 : 0);
  384.                                             break;
  385.                                         }
  386.                                     case NumericVariant.UInt8:
  387.                                     case NumericVariant.Int8:
  388.                                         {
  389.                                             long a = (long)stack.Pop();
  390.                                             long b = (long)stack.Pop();
  391.                                             stack.Push(a != b ? 1 : 0);
  392.                                             break;
  393.                                         }
  394.                                     case NumericVariant.String:
  395.                                         {
  396.                                             string a = (string)stack.Pop();
  397.                                             string b = (string)stack.Pop();
  398.                                             stack.Push(a != b ? 1 : 0);
  399.                                             break;
  400.                                         }
  401.                                     default:
  402.                                         throw new Exception();
  403.                                 }
  404.                                 break;
  405.                             }
  406.                         case OpCode.CMP_GT:
  407.                             {
  408.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  409.                                 switch (mode)
  410.                                 {
  411.                                     case NumericVariant.Float4:
  412.                                         {
  413.                                             float a = (float)stack.Pop();
  414.                                             float b = (float)stack.Pop();
  415.                                             stack.Push(a > b ? 1 : 0);
  416.                                             break;
  417.                                         }
  418.                                     case NumericVariant.Float8:
  419.                                         {
  420.                                             double a = (double)stack.Pop();
  421.                                             double b = (double)stack.Pop();
  422.                                             stack.Push(a > b ? 1 : 0);
  423.                                             break;
  424.                                         }
  425.                                     case NumericVariant.Int4:
  426.                                         {
  427.                                             int a = (int)stack.Pop();
  428.                                             int b = (int)stack.Pop();
  429.                                             stack.Push(a > b ? 1 : 0);
  430.                                             break;
  431.                                         }
  432.                                     case NumericVariant.Int8:
  433.                                         {
  434.                                             long a = (long)stack.Pop();
  435.                                             long b = (long)stack.Pop();
  436.                                             stack.Push(a > b ? 1 : 0);
  437.                                             break;
  438.                                         }
  439.                                     case NumericVariant.UInt4:
  440.                                         {
  441.                                             uint a = (uint)(int)stack.Pop();
  442.                                             uint b = (uint)(int)stack.Pop();
  443.                                             stack.Push(a > b ? 1 : 0);
  444.                                             break;
  445.                                         }
  446.                                     case NumericVariant.UInt8:
  447.                                         {
  448.                                             ulong a = (ulong)(long)stack.Pop();
  449.                                             ulong b = (ulong)(long)stack.Pop();
  450.                                             stack.Push(a > b ? 1 : 0);
  451.                                             break;
  452.                                         }
  453.                                     case NumericVariant.String:
  454.                                         {
  455.                                             string a = (string)stack.Pop();
  456.                                             string b = (string)stack.Pop();
  457.                                             stack.Push(StringComparer.Ordinal.Compare(a, b) > 0 ? 1 : 0);
  458.                                             break;
  459.                                         }
  460.                                     default:
  461.                                         throw new Exception();
  462.                                 }
  463.                                 break;
  464.                             }
  465.                         case OpCode.CMP_GTE:
  466.                             {
  467.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  468.                                 switch (mode)
  469.                                 {
  470.                                     case NumericVariant.Float4:
  471.                                         {
  472.                                             float a = (float)stack.Pop();
  473.                                             float b = (float)stack.Pop();
  474.                                             stack.Push(a >= b ? 1 : 0);
  475.                                             break;
  476.                                         }
  477.                                     case NumericVariant.Float8:
  478.                                         {
  479.                                             double a = (double)stack.Pop();
  480.                                             double b = (double)stack.Pop();
  481.                                             stack.Push(a >= b ? 1 : 0);
  482.                                             break;
  483.                                         }
  484.                                     case NumericVariant.Int4:
  485.                                         {
  486.                                             int a = (int)stack.Pop();
  487.                                             int b = (int)stack.Pop();
  488.                                             stack.Push(a >= b ? 1 : 0);
  489.                                             break;
  490.                                         }
  491.                                     case NumericVariant.Int8:
  492.                                         {
  493.                                             long a = (long)stack.Pop();
  494.                                             long b = (long)stack.Pop();
  495.                                             stack.Push(a >= b ? 1 : 0);
  496.                                             break;
  497.                                         }
  498.                                     case NumericVariant.UInt4:
  499.                                         {
  500.                                             uint a = (uint)(int)stack.Pop();
  501.                                             uint b = (uint)(int)stack.Pop();
  502.                                             stack.Push(a >= b ? 1 : 0);
  503.                                             break;
  504.                                         }
  505.                                     case NumericVariant.UInt8:
  506.                                         {
  507.                                             ulong a = (ulong)(long)stack.Pop();
  508.                                             ulong b = (ulong)(long)stack.Pop();
  509.                                             stack.Push(a >= b ? 1 : 0);
  510.                                             break;
  511.                                         }
  512.                                     case NumericVariant.String:
  513.                                         {
  514.                                             string a = (string)stack.Pop();
  515.                                             string b = (string)stack.Pop();
  516.                                             stack.Push(StringComparer.Ordinal.Compare(a, b) >= 0 ? 1 : 0);
  517.                                             break;
  518.                                         }
  519.                                     default:
  520.                                         throw new Exception();
  521.                                 }
  522.                                 break;
  523.                             }
  524.                         case OpCode.CMP_LT:
  525.                             {
  526.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  527.                                 switch (mode)
  528.                                 {
  529.                                     case NumericVariant.Float4:
  530.                                         {
  531.                                             float a = (float)stack.Pop();
  532.                                             float b = (float)stack.Pop();
  533.                                             stack.Push(a < b ? 1 : 0);
  534.                                             break;
  535.                                         }
  536.                                     case NumericVariant.Float8:
  537.                                         {
  538.                                             double a = (double)stack.Pop();
  539.                                             double b = (double)stack.Pop();
  540.                                             stack.Push(a < b ? 1 : 0);
  541.                                             break;
  542.                                         }
  543.                                     case NumericVariant.Int4:
  544.                                         {
  545.                                             int a = (int)stack.Pop();
  546.                                             int b = (int)stack.Pop();
  547.                                             stack.Push(a < b ? 1 : 0);
  548.                                             break;
  549.                                         }
  550.                                     case NumericVariant.Int8:
  551.                                         {
  552.                                             long a = (long)stack.Pop();
  553.                                             long b = (long)stack.Pop();
  554.                                             stack.Push(a < b ? 1 : 0);
  555.                                             break;
  556.                                         }
  557.                                     case NumericVariant.UInt4:
  558.                                         {
  559.                                             uint a = (uint)(int)stack.Pop();
  560.                                             uint b = (uint)(int)stack.Pop();
  561.                                             stack.Push(a < b ? 1 : 0);
  562.                                             break;
  563.                                         }
  564.                                     case NumericVariant.UInt8:
  565.                                         {
  566.                                             ulong a = (ulong)(long)stack.Pop();
  567.                                             ulong b = (ulong)(long)stack.Pop();
  568.                                             stack.Push(a < b ? 1 : 0);
  569.                                             break;
  570.                                         }
  571.                                     case NumericVariant.String:
  572.                                         {
  573.                                             string a = (string)stack.Pop();
  574.                                             string b = (string)stack.Pop();
  575.                                             stack.Push(StringComparer.Ordinal.Compare(a, b) < 0 ? 1 : 0);
  576.                                             break;
  577.                                         }
  578.                                     default:
  579.                                         throw new Exception();
  580.                                 }
  581.                                 break;
  582.                             }
  583.                         case OpCode.CMP_LTE:
  584.                             {
  585.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  586.                                 switch (mode)
  587.                                 {
  588.                                     case NumericVariant.Float4:
  589.                                         {
  590.                                             float a = (float)stack.Pop();
  591.                                             float b = (float)stack.Pop();
  592.                                             stack.Push(a <= b ? 1 : 0);
  593.                                             break;
  594.                                         }
  595.                                     case NumericVariant.Float8:
  596.                                         {
  597.                                             double a = (double)stack.Pop();
  598.                                             double b = (double)stack.Pop();
  599.                                             stack.Push(a <= b ? 1 : 0);
  600.                                             break;
  601.                                         }
  602.                                     case NumericVariant.Int4:
  603.                                         {
  604.                                             int a = (int)stack.Pop();
  605.                                             int b = (int)stack.Pop();
  606.                                             stack.Push(a <= b ? 1 : 0);
  607.                                             break;
  608.                                         }
  609.                                     case NumericVariant.Int8:
  610.                                         {
  611.                                             long a = (long)stack.Pop();
  612.                                             long b = (long)stack.Pop();
  613.                                             stack.Push(a <= b ? 1 : 0);
  614.                                             break;
  615.                                         }
  616.                                     case NumericVariant.UInt4:
  617.                                         {
  618.                                             uint a = (uint)(int)stack.Pop();
  619.                                             uint b = (uint)(int)stack.Pop();
  620.                                             stack.Push(a <= b ? 1 : 0);
  621.                                             break;
  622.                                         }
  623.                                     case NumericVariant.UInt8:
  624.                                         {
  625.                                             ulong a = (ulong)(long)stack.Pop();
  626.                                             ulong b = (ulong)(long)stack.Pop();
  627.                                             stack.Push(a <= b ? 1 : 0);
  628.                                             break;
  629.                                         }
  630.                                     case NumericVariant.String:
  631.                                         {
  632.                                             string a = (string)stack.Pop();
  633.                                             string b = (string)stack.Pop();
  634.                                             stack.Push(StringComparer.Ordinal.Compare(a, b) <= 0 ? 1 : 0);
  635.                                             break;
  636.                                         }
  637.                                     default:
  638.                                         throw new Exception();
  639.                                 }
  640.                                 break;
  641.                             }
  642.                         case OpCode.CVT_BOOL:
  643.                             {
  644.                                 NumericVariant mode = (NumericVariant)methodIL[pos++];
  645.                                 switch (mode)
  646.                                 {
  647.                                     case NumericVariant.Float4:
  648.                                         {
  649.                                             float a = (float)stack.Pop();
  650.                                             stack.Push(a != 0.0f ? 1 : 0);
  651.                                             break;
  652.                                         }
  653.                                     case NumericVariant.Float8:
  654.                                         {
  655.                                             double a = (double)stack.Pop();
  656.                                             stack.Push(a != 0.0 ? 1 : 0);
  657.                                             break;
  658.                                         }
  659.                                     case NumericVariant.Int4:
  660.                                         {
  661.                                             int a = (int)stack.Pop();
  662.                                             stack.Push(a != 0 ? 1 : 0);
  663.                                             break;
  664.                                         }
  665.                                     case NumericVariant.Int8:
  666.                                         {
  667.                                             long a = (long)stack.Pop();
  668.                                             stack.Push(a != 0 ? 1 : 0);
  669.                                             break;
  670.                                         }
  671.                                     case NumericVariant.UInt4:
  672.                                         {
  673.                                             uint a = (uint)(int)stack.Pop();
  674.                                             stack.Push(a != 0 ? 1 : 0);
  675.                                             break;
  676.                                         }
  677.                                     case NumericVariant.UInt8:
  678.                                         {
  679.                                             ulong a = (ulong)(long)stack.Pop();
  680.                                             stack.Push(a != 0 ? 1 : 0);
  681.                                             break;
  682.                                         }
  683.                                     case NumericVariant.String:
  684.                                         {
  685.                                             string a = (string)stack.Pop();
  686.                                             stack.Push(string.IsNullOrEmpty(a) ? 0 : 1);
  687.                                             break;
  688.                                         }
  689.                                     case NumericVariant.Object:
  690.                                         {
  691.                                             object a = (object)stack.Pop();
  692.                                             stack.Push(a == null ? 0 : 1);
  693.                                             break;
  694.                                         }
  695.                                     default:
  696.                                         throw new Exception();
  697.                                 }
  698.                                 break;
  699.                             }
  700.                         case OpCode.JMP_FALSE:
  701.                             {
  702.                                 int o = (int)stack.Pop();
  703.                                 bool b = o == 0;
  704.                                 if (!b)
  705.                                 {
  706.                                     pos += 4;
  707.                                     break;
  708.                                 }
  709.                                 int index = BitConverter.ToInt32(methodIL, pos) - 1;
  710.                                 pos += index;
  711.                                 break;
  712.                             }
  713.                         case OpCode.JMP_TRUE:
  714.                             {
  715.                                 int o = (int)stack.Pop();
  716.                                 bool b = o != 0;
  717.                                 if (!b)
  718.                                 {
  719.                                     pos += 4;
  720.                                     break;
  721.                                 }
  722.                                 int index = BitConverter.ToInt32(methodIL, pos) - 1;
  723.                                 pos += index;
  724.                                 break;
  725.                             }
  726.                         case OpCode.JMP:
  727.                             {
  728.                                 int index = BitConverter.ToInt32(methodIL, pos) - 1;
  729.                                 pos += index;
  730.                                 break;
  731.                             }
  732.                         case OpCode.POP:
  733.                             stack.Pop();
  734.                             break;
  735.                         case OpCode.RET:
  736.                             goto Cleanup;
  737.                         case OpCode.NOP:
  738.                             break;
  739.                         case OpCode.BOX:
  740.                             {
  741.                                 int index = BitConverter.ToInt32(methodIL, pos);
  742.                                 pos += 4;
  743.                                 break;
  744.                             }
  745.                             break;
  746.                         case OpCode.ST_LOC:
  747.                             {
  748.                                 int index = BitConverter.ToInt32(methodIL, pos);
  749.                                 pos += 4;
  750.                                 switch (function.CompiledFunction.FunctionIL.Locals[index].Item1.BuiltinType)
  751.                                 {
  752.                                     case InternalTypeCode.Int8:
  753.                                         {
  754.                                             int x = (int)stack.Pop();
  755.                                             locals[index] = (sbyte)x;
  756.                                             break;
  757.                                         }
  758.                                     case InternalTypeCode.UInt8:
  759.                                         {
  760.                                             int x = (int)stack.Pop();
  761.                                             locals[index] = (byte)x;
  762.                                             break;
  763.                                         }
  764.                                     case InternalTypeCode.Int16:
  765.                                         {
  766.                                             int x = (int)stack.Pop();
  767.                                             locals[index] = (short)x;
  768.                                             break;
  769.                                         }
  770.                                     case InternalTypeCode.UInt16:
  771.                                         {
  772.                                             int x = (int)stack.Pop();
  773.                                             locals[index] = (ushort)x;
  774.                                             break;
  775.                                         }
  776.                                     case InternalTypeCode.Int32:
  777.                                         {
  778.                                             int x = (int)stack.Pop();
  779.                                             locals[index] = x;
  780.                                             break;
  781.                                         }
  782.                                     case InternalTypeCode.UInt32:
  783.                                         {
  784.                                             int x = (int)stack.Pop();
  785.                                             locals[index] = (uint)x;
  786.                                             break;
  787.                                         }
  788.                                     case InternalTypeCode.Int64:
  789.                                         {
  790.                                             long x = (long)stack.Pop();
  791.                                             locals[index] = x;
  792.                                             break;
  793.                                         }
  794.                                     case InternalTypeCode.UInt64:
  795.                                         {
  796.                                             long x = (long)stack.Pop();
  797.                                             locals[index] = (ulong)x;
  798.                                             break;
  799.                                         }
  800.                                     case InternalTypeCode.Float32:
  801.                                         {
  802.                                             locals[index] = (float)stack.Pop();
  803.                                             break;
  804.                                         }
  805.                                     case InternalTypeCode.Float64:
  806.                                         {
  807.                                             locals[index] = (double)stack.Pop();
  808.                                             break;
  809.                                         }
  810.                                     case InternalTypeCode.Boolean:
  811.                                         {
  812.                                             int x = (int)stack.Pop();
  813.                                             locals[index] = x > 0;
  814.                                             break;
  815.                                         }
  816.                                     case InternalTypeCode.String:
  817.                                         {
  818.                                             locals[index] = (string)stack.Pop();
  819.                                             break;
  820.                                         }
  821.                                     case InternalTypeCode.Object:
  822.                                         {
  823.                                             locals[index] = stack.Pop();
  824.                                             break;
  825.                                         }
  826.                                     default:
  827.                                         throw new Exception();
  828.                                 }
  829.                                 break;
  830.                             }
  831.                         case OpCode.ST_ARG:
  832.                             {
  833.                                 int index = BitConverter.ToInt32(methodIL, pos);
  834.                                 pos += 4;
  835.                                 switch (function.Symbol.Type.Arguments[index].BuiltinType)
  836.                                 {
  837.                                     case InternalTypeCode.Int8:
  838.                                         {
  839.                                             int x = (int)stack.Pop();
  840.                                             arguments[index] = (sbyte)x;
  841.                                             break;
  842.                                         }
  843.                                     case InternalTypeCode.UInt8:
  844.                                         {
  845.                                             int x = (int)stack.Pop();
  846.                                             arguments[index] = (byte)x;
  847.                                             break;
  848.                                         }
  849.                                     case InternalTypeCode.Int16:
  850.                                         {
  851.                                             int x = (int)stack.Pop();
  852.                                             arguments[index] = (short)x;
  853.                                             break;
  854.                                         }
  855.                                     case InternalTypeCode.UInt16:
  856.                                         {
  857.                                             int x = (int)stack.Pop();
  858.                                             arguments[index] = (ushort)x;
  859.                                             break;
  860.                                         }
  861.                                     case InternalTypeCode.Int32:
  862.                                         {
  863.                                             int x = (int)stack.Pop();
  864.                                             arguments[index] = x;
  865.                                             break;
  866.                                         }
  867.                                     case InternalTypeCode.UInt32:
  868.                                         {
  869.                                             int x = (int)stack.Pop();
  870.                                             arguments[index] = (uint)x;
  871.                                             break;
  872.                                         }
  873.                                     case InternalTypeCode.Int64:
  874.                                         {
  875.                                             long x = (long)stack.Pop();
  876.                                             arguments[index] = x;
  877.                                             break;
  878.                                         }
  879.                                     case InternalTypeCode.UInt64:
  880.                                         {
  881.                                             long x = (long)stack.Pop();
  882.                                             arguments[index] = (ulong)x;
  883.                                             break;
  884.                                         }
  885.                                     case InternalTypeCode.Float32:
  886.                                         {
  887.                                             arguments[index] = (float)stack.Pop();
  888.                                             break;
  889.                                         }
  890.                                     case InternalTypeCode.Float64:
  891.                                         {
  892.                                             arguments[index] = (double)stack.Pop();
  893.                                             break;
  894.                                         }
  895.                                     case InternalTypeCode.Boolean:
  896.                                         {
  897.                                             int x = (int)stack.Pop();
  898.                                             arguments[index] = x > 0;
  899.                                             break;
  900.                                         }
  901.                                     case InternalTypeCode.String:
  902.                                         {
  903.                                             arguments[index] = (string)stack.Pop();
  904.                                             break;
  905.                                         }
  906.                                     case InternalTypeCode.Object:
  907.                                         {
  908.                                             arguments[index] = stack.Pop();
  909.                                             break;
  910.                                         }
  911.                                     default:
  912.                                         throw new Exception();
  913.                                 }
  914.                                 break;
  915.                             }
  916.                         case OpCode.LD_ARG:
  917.                             {
  918.                                 int index = BitConverter.ToInt32(methodIL, pos);
  919.                                 pos += 4;
  920.                                 switch (function.Symbol.Type.Arguments[index].BuiltinType)
  921.                                 {
  922.                                     case InternalTypeCode.Int8:
  923.                                         stack.Push((int)(sbyte)arguments[index]); break;
  924.                                     case InternalTypeCode.UInt8:
  925.                                         stack.Push((int)(byte)arguments[index]); break;
  926.                                     case InternalTypeCode.Int16:
  927.                                         stack.Push((int)(short)arguments[index]); break;
  928.                                     case InternalTypeCode.UInt16:
  929.                                         stack.Push((int)(ushort)arguments[index]); break;
  930.                                     case InternalTypeCode.Int32:
  931.                                         stack.Push((int)arguments[index]); break;
  932.                                     case InternalTypeCode.UInt32:
  933.                                         stack.Push((int)(uint)arguments[index]); break;
  934.                                     case InternalTypeCode.Int64:
  935.                                         stack.Push((long)arguments[index]); break;
  936.                                     case InternalTypeCode.UInt64:
  937.                                         stack.Push((ulong)(long)arguments[index]); break;
  938.                                     case InternalTypeCode.Float32:
  939.                                         stack.Push((float)arguments[index]); break;
  940.                                     case InternalTypeCode.Float64:
  941.                                         stack.Push((double)arguments[index]); break;
  942.                                     case InternalTypeCode.Boolean:
  943.                                         stack.Push(((bool)arguments[index]) ? 1 : 0); break;
  944.                                     case InternalTypeCode.String:
  945.                                         stack.Push((string)arguments[index]); break;
  946.                                     case InternalTypeCode.Object:
  947.                                         stack.Push(arguments[index]); break;
  948.                                         break;
  949.                                     default:
  950.                                         throw new Exception();
  951.                                 }
  952.                                 break;
  953.                             }
  954.                         case OpCode.LD_LOC:
  955.                             {
  956.                                 int index = BitConverter.ToInt32(methodIL, pos);
  957.                                 pos += 4;
  958.                                 switch (function.CompiledFunction.FunctionIL.Locals[index].Item1.BuiltinType)
  959.                                 {
  960.                                     case InternalTypeCode.Int8:
  961.                                         stack.Push((int)(sbyte)locals[index]); break;
  962.                                     case InternalTypeCode.UInt8:
  963.                                         stack.Push((int)(byte)locals[index]); break;
  964.                                     case InternalTypeCode.Int16:
  965.                                         stack.Push((int)(short)locals[index]); break;
  966.                                     case InternalTypeCode.UInt16:
  967.                                         stack.Push((int)(ushort)locals[index]); break;
  968.                                     case InternalTypeCode.Int32:
  969.                                         stack.Push((int)locals[index]); break;
  970.                                     case InternalTypeCode.UInt32:
  971.                                         stack.Push((int)(uint)locals[index]); break;
  972.                                     case InternalTypeCode.Int64:
  973.                                         stack.Push((long)locals[index]); break;
  974.                                     case InternalTypeCode.UInt64:
  975.                                         stack.Push((ulong)(long)locals[index]); break;
  976.                                     case InternalTypeCode.Float32:
  977.                                         stack.Push((float)locals[index]); break;
  978.                                     case InternalTypeCode.Float64:
  979.                                         stack.Push((double)locals[index]); break;
  980.                                     case InternalTypeCode.Boolean:
  981.                                         stack.Push(((bool)locals[index]) ? 1 : 0); break;
  982.                                     case InternalTypeCode.String:
  983.                                         stack.Push((string)locals[index]); break;
  984.                                     case InternalTypeCode.Object:
  985.                                         stack.Push(locals[index]); break;
  986.                                         break;
  987.                                     default:
  988.                                         throw new Exception();
  989.                                 }
  990.                                 break;
  991.                             }
  992.  
  993.                         case OpCode.TRUNC_S1:
  994.                             stack.Push((int)(sbyte)(int)stack.Pop()); break;
  995.                         case OpCode.TRUNC_U1:
  996.                             stack.Push((int)(byte)(int)stack.Pop()); break;
  997.                         case OpCode.TRUNC_S2:
  998.                             stack.Push((int)(short)(int)stack.Pop()); break;
  999.                         case OpCode.TRUNC_U2:
  1000.                             stack.Push((int)(ushort)(int)stack.Pop()); break;
  1001.                         case OpCode.CONV_I4_I8:
  1002.                             stack.Push((long)(int)stack.Pop()); break;
  1003.                         case OpCode.CONV_I4_F4:
  1004.                             stack.Push((float)(int)stack.Pop()); break;
  1005.                         case OpCode.CONV_I4_F8:
  1006.                             stack.Push((double)(int)stack.Pop()); break;
  1007.                         case OpCode.CONV_U4_I8:
  1008.                             stack.Push((long)(uint)(int)stack.Pop()); break;
  1009.                         case OpCode.CONV_U4_F4:
  1010.                             stack.Push((float)(uint)(int)stack.Pop()); break;
  1011.                         case OpCode.CONV_U4_F8:
  1012.                             stack.Push((double)(uint)(int)stack.Pop()); break;
  1013.                         case OpCode.CONV_I8_I4:
  1014.                             stack.Push((int)(long)stack.Pop()); break;
  1015.                         case OpCode.CONV_I8_F4:
  1016.                             stack.Push((float)(long)stack.Pop()); break;
  1017.                         case OpCode.CONV_I8_F8:
  1018.                             stack.Push((double)(long)stack.Pop()); break;
  1019.                         case OpCode.CONV_U8_F4:
  1020.                             stack.Push((float)(ulong)(long)stack.Pop()); break;
  1021.                         case OpCode.CONV_U8_F8:
  1022.                             stack.Push((double)(ulong)(long)stack.Pop()); break;
  1023.                         case OpCode.CONV_F4_I8:
  1024.                             stack.Push((long)(float)stack.Pop()); break;
  1025.                         case OpCode.CONV_F4_I4:
  1026.                             stack.Push((int)(float)stack.Pop()); break;
  1027.                         case OpCode.CONV_F4_F8:
  1028.                             stack.Push((double)(float)stack.Pop()); break;
  1029.                         case OpCode.CONV_F8_I8:
  1030.                             stack.Push((long)(double)stack.Pop()); break;
  1031.                         case OpCode.CONV_F8_I4:
  1032.                             stack.Push((int)(double)stack.Pop()); break;
  1033.                         case OpCode.CONV_F8_F4:
  1034.                             stack.Push((float)(double)stack.Pop()); break;
  1035.  
  1036.                         case OpCode.CALL_STATIC:
  1037.                             {
  1038.                                 int callID = BitConverter.ToInt32(methodIL, pos);
  1039.                                 pos += 4;
  1040.                                 RuntimeObjects.RuntimeMethod rm = function.ResolvedSymbols[callID] as RuntimeObjects.RuntimeMethod;
  1041.                                 rm.Execute(this, stack);
  1042.                                 break;
  1043.                             }
  1044.  
  1045.                         default:
  1046.                             throw new Exception();
  1047.                     }
  1048.  
  1049.                     // Leaving switch
  1050.                 }
  1051.  
  1052.             Cleanup:
  1053.                 ;
  1054.  
  1055.                 // Main IL loop
  1056.             }
  1057.             // Unchecked
  1058.  
  1059.             return;
  1060.         }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top