Beispiel #1
0
        public static void TheProblemAgain()
        {
            var stack = new ObjectStack();

            stack.Push("Hello World");
            stack.Push(100);

            Console.WriteLine(100 * (int)stack.Pop());
            Console.WriteLine(100 * (int)stack.Pop());
        }
        public void StartObject(ISerializable obj)
        {
            bool isSameAsPreviousObject = IsObjectSameAsPreviousObject(obj);

            ObjectStack.Push(obj);
            if (!isSameAsPreviousObject)
            {
                JsonWriter.WriteStartObject();
                SerializationManager.StartObjectSerialization(this, obj);
            }
        }
Beispiel #3
0
 public override float EvaluateTestCase(GAIndividual inIndividual, object inInput, object inOutput) {
   int timeSteps = 1000;
   float timeDiscritized = 0.01f;
   float maxTime = timeSteps * timeDiscritized;
   float captureRadius = 0.01f;
   ObjectPair xv = (ObjectPair)inInput;
   float position = (float)xv._first;
   float velocity = (float)xv._second;
   for (int step = 1; step <= timeSteps; step++) {
     _interpreter.ClearStacks();
     FloatStack fStack = _interpreter.FloatStack();
     BooleanStack bStack = _interpreter.BoolStack();
     ObjectStack iStack = _interpreter.InputStack();
     // Position will be on the top of the stack, and velocity will be
     // second.
     fStack.Push(position);
     fStack.Push(velocity);
     // Must be included in order to use the input stack. Uses same order
     // as inputs on Float stack.
     iStack.Push(position);
     iStack.Push(velocity);
     _interpreter.Execute(((PushGPIndividual)inIndividual)._program, _executionLimit);
     // If there is no boolean on the stack, the program has failed to
     // return a reasonable output. So, return a penalty fitness of
     // twice the maximum time.
     if (bStack.Size() == 0) {
       return 2 * maxTime;
     }
     // If there is a boolean, use it to compute the next position and
     // velocity. Then, check for termination conditions.
     // NOTE: If result == True, we will apply the force in the positive
     // direction, and if result == False, we will apply the force in
     // the negative direction.
     bool positiveForce = bStack.Top();
     float acceleration;
     if (positiveForce) {
       acceleration = 0.5f;
     } else {
       acceleration = -0.5f;
     }
     velocity = velocity + (timeDiscritized * acceleration);
     position = position + (timeDiscritized * velocity);
     // Check for termination conditions
     if (position <= captureRadius && position >= -captureRadius && velocity <= captureRadius && velocity >= -captureRadius) {
       //Cart is centered, so return time it took.
       return step * timeDiscritized;
     }
   }
   // If here, the cart failed to come to rest in the allotted time. So,
   // return the failed error of maxTime.
   return maxTime;
 }
Beispiel #4
0
        public void InvalidCastExceptionTest()
        {
            // Now suppose we want a stack that stores just integers:
            var intStack = new ObjectStack();

            // It's easy to make mistakes:
            intStack.Push("s"); // Wrong type, but no error!

            Assert.Throws <System.InvalidCastException>(() =>
            {
                _ = (int)intStack.Pop();  // Downcast - runtime error!
            });
        }
Beispiel #5
0
 public override string ToString()
 {
     if (ObjectCardArray != null)
     {
         return(ObjectCardArray[0].CardSuit.ToString() + ObjectCardArray[0].CardNumber.ToString() + " to "
                + ObjectCardArray[ObjectCardArray.Count - 1].CardSuit.ToString() + ObjectCardArray[ObjectCardArray.Count - 1].CardNumber.ToString()
                + " → " + ObjectStack.ToString());
     }
     else
     {
         return(SingleCard.CardSuit.ToString() + SingleCard.CardNumber.ToString() + " → " + ObjectStack.ToString());
     }
 }
        public ActionResult <FoodBag> CreateFoodBag(FoodBag foodBag)
        {
            using (var ctx = MyContext.New())
            {
                foodBag.IsPersisted = 1;

                ctx.FoodBags.Add(foodBag);
                ctx.ObjectMetas.Add(new ObjectMeta
                {
                    Id       = Guid.NewGuid().ToString(),
                    ObjectId = foodBag.Id,
                    Name     = "description",
                    Value    = foodBag.Description ?? "",
                });
                foreach (var ingredientStack in foodBag.IngredientStacks)
                {
                    var s = new ObjectStack
                    {
                        Id          = Guid.NewGuid().ToString(),
                        Type        = StackTypes.Ingredient,
                        ParentId    = foodBag.Id,
                        ItemId      = ingredientStack.ItemId,
                        TotalAmount = ingredientStack.TotalAmount,
                        IsDeleted   = 0,
                        IsPersisted = 1,
                    };
                    ctx.ObjectStacks.Add(s);
                }

                foreach (var recipeStack in foodBag.RecipeStacks)
                {
                    var s = new ObjectStack
                    {
                        Id          = Guid.NewGuid().ToString(),
                        Type        = StackTypes.Recipe,
                        ParentId    = foodBag.Id,
                        ItemId      = recipeStack.ItemId,
                        TotalAmount = recipeStack.TotalAmount,
                        IsDeleted   = 0,
                        IsPersisted = 1,
                    };
                    ctx.ObjectStacks.Add(s);
                }

                ctx.SaveChanges();
                return(foodBag);
            }
        }
Beispiel #7
0
        public static ObjectStack CompleteRecipeStack(MyContext ctx, ObjectStack recipeStack)
        {
            var recipe = ctx.Recipes.First(i => i.Id == recipeStack.ItemId && i.IsDeleted == 0);

            recipe.IngredientStacks = ctx.ObjectStacks
                                      .Where(s => s.ParentId == recipe.Id &&
                                             s.IsDeleted == 0 &&
                                             s.Type == ObjectStack.StackTypes.Ingredient)
                                      .AsEnumerable()
                                      .Select(s =>
            {
                s.Item = IngredientService.GetIngredientById(ctx, s.ItemId);
                return(s);
            })
                                      .ToList();
            recipeStack.Item = recipe;
            return(recipeStack);
        }
Beispiel #8
0
    static void Main(string[] args)
    {
        // create a new IntStack
        ObjectStack stack = new ObjectStack();

        stack.Push(2);
        stack.Push("apple");
        stack.Push(8);

        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Pop value: {0}", stack.Pop());
        }

        // wait for input before exiting
        Console.WriteLine("Press enter to finish");
        Console.ReadLine();
    }
        private static void OnExceptionRestoreStack()
        {
            foreach (var i in BackUpList)
            {
                ObjectStack.Push(i);
            }
            var initialCount = ObjectStack.Count;

            Console.WriteLine(Environment.NewLine);
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Restored Stack Contents Count {0}", ObjectStack.Count);
            Console.WriteLine("Contents from Restored Stack");
            for (var i = 0; i < initialCount; i++)
            {
                Console.WriteLine("Restored value {0} ,  at Position {1}", ObjectStack.Pop(), i);
            }
            Console.WriteLine("Restored Stack To Initial State");
        }
Beispiel #10
0
        public InterpreterState(Stack stack, FloatingPointStack floatingPointStack, ObjectStack objectStack, ReturnStack returnStack, ExceptionStack exceptionStack, InputSourceStack inputSourceStack, Heap heap, ObjectHeap objectHeap, IWordsList wordsList)
        {
            Stack = stack ?? throw new ArgumentNullException(nameof(stack));
            FloatingPointStack = floatingPointStack ?? throw new ArgumentNullException(nameof(floatingPointStack));
            ObjectStack        = objectStack ?? throw new ArgumentNullException(nameof(objectStack));
            ReturnStack        = returnStack ?? throw new ArgumentNullException(nameof(returnStack));
            ExceptionStack     = exceptionStack ?? throw new ArgumentNullException(nameof(exceptionStack));
            InputSourceStack   = inputSourceStack ?? throw new ArgumentNullException(nameof(inputSourceStack));

            Heap       = heap ?? throw new ArgumentNullException(nameof(heap));
            ObjectHeap = objectHeap ?? throw new ArgumentNullException(nameof(objectHeap));

            Picture   = string.Empty;
            WordsList = wordsList ?? throw new ArgumentNullException(nameof(wordsList));

            _stacksRegistry = new Dictionary <string, IStack>();

            RegisterDefaultStacks();
            SetupDefaults();
        }
     public static void Main(string[] args)
     {
         var objects = new List<Object>();
         for (var i = 0; i < NumOfObjects; i++) {
             objects.Add(new object());
         }
         var tasks = new Task[NumOfThreads];
         var objectStack = new ObjectStack(objects);
         for (var i = 0; i < NumOfThreads; i++)
         {
             var task = new Task(objectStack.ThreadUnsafeMultiPop);
             tasks[i] = task;
         }
         for (var i = 0; i < NumOfThreads; i++)
         {
             tasks[i].Start();
         }
         //Using this seems to throw exceptions from unit test context
         //Parallel.For(0, NumOfThreads, x => objectStack.ThreadUnsafeMultiPop());
 }
        public static void Main()
        {
            string      input;
            ObjectStack os = new ObjectStack(1);

            do
            {
                System.Console.WriteLine($"Length: {os.Size}");
                System.Console.Write("Enter a string: ");
                input = Console.ReadLine();
                if (input != "")
                {
                    os.Push(input);
                }
            } while(input != "");

            Console.WriteLine("\nPopping the stack!");
            while (!os.Empty)
            {
                Console.WriteLine(os.Pop());
            }
        }
Beispiel #13
0
 public Sandbox(RantEngine engine, RantPattern pattern, RNG rng, int sizeLimit = 0, RantPatternArgs args = null)
 {
     _engine     = engine;
     _format     = engine.Format;
     _sizeLimit  = new Limit(sizeLimit);
     _baseOutput = new OutputWriter(this);
     _outputs    = new Stack <OutputWriter>();
     _outputs.Push(_baseOutput);
     _rng               = rng;
     _startingGen       = rng.Generation;
     _pattern           = pattern;
     _objects           = new ObjectStack(engine.Objects);
     _blocks            = new Stack <BlockState>();
     _matches           = new Stack <Match>();
     _queryState        = new QueryState();
     _subroutineArgs    = new Stack <Dictionary <string, RantAction> >();
     _syncManager       = new SyncManager(this);
     _blockManager      = new BlockManager();
     _scriptObjectStack = new Stack <object>();
     _patternArgs       = args;
     _stopwatch         = new Stopwatch();
 }
Beispiel #14
0
        /// <summary>
        ///     回收对象
        /// </summary>
        /// <param name="obj"></param>
        public void ReleaseObject(T obj)
        {
            if (ReleaseObjectRunTime != null)
            {
                obj = ReleaseObjectRunTime(obj, this);

                if (obj == null)
                {
                    return;
                }
            }

            if (ObjectStack.Count >= MaxObjectCount)
            {
                if (obj is IDisposable)
                {
                    ((IDisposable)obj).Dispose();
                }
            }
            else
            {
                ObjectStack.Push(obj);
            }
        }
 private bool IsObjectSameAsPreviousObject(ISerializable obj)
 {
     return(ObjectStack.Count != 0 && ReferenceEquals(obj, ObjectStack.Peek()));
 }
Beispiel #16
0
        public void CheckTypesEx(int init_n, int init_level, IntegerStack init_class_stack)
        {
            ClassObject classObject;
            IntegerStack stack;
            FunctionObject obj9;
            int num52;
            if (this.scripter.IsError())
            {
                return;
            }
            IntegerList a = new IntegerList(true);
            IntegerList list2 = new IntegerList(true);
            IntegerList pos = new IntegerList(true);
            IntegerList list4 = new IntegerList(false);
            IntegerList l = new IntegerList(false);
            ClassObject obj2 = null;
            if (init_class_stack == null)
            {
                stack = new IntegerStack();
            }
            else
            {
                stack = init_class_stack.Clone();
            }
            if (stack.Count == 0)
            {
                classObject = null;
            }
            else
            {
                classObject = this.GetClassObject(stack.Peek());
            }
            this.n = init_n;
            int num = init_level;
            Label_0079:
            this.n++;
            if (this.n >= this.Card)
            {
                goto Label_22C6;
            }
            this.r = (ProgRec) this.prog[this.n];
            int op = this.r.op;
            if ((op == this.OP_SEPARATOR) || (op == this.OP_LABEL))
            {
                goto Label_0079;
            }
            if (op != this.OP_CREATE_INDEX_OBJECT)
            {
                if (op == this.OP_ADD_INDEX)
                {
                    if (((this.symbol_table[this.r.res].TypeId != 12) || (this[this.n + 1].op != this.OP_ADD_INDEX)) || (this[this.n + 1].res != this.r.res))
                    {
                        goto Label_04A6;
                    }
                    int num7 = 1;
                    while ((this[this.n + num7].op == this.OP_ADD_INDEX) && (this[this.n + num7].res == this.r.res))
                    {
                        num7++;
                    }
                    this.scripter.CreateErrorObjectEx("CS1501. No overload for method '{0}' takes '{1}' arguments.", new object[] { "this", num7 });
                    goto Label_22C6;
                }
                if (op == this.OP_SETUP_INDEX_OBJECT)
                {
                    int n = this.n;
                    int num9 = 0;
                    do
                    {
                        n--;
                        if ((this[n].op == this.OP_ADD_INDEX) && (this[n].arg1 == this.r.arg1))
                        {
                            num9++;
                        }
                    }
                    while ((this[n].op != this.OP_CREATE_INDEX_OBJECT) || (this[n].res != this.r.arg1));
                    int typeId = this.symbol_table[this[n].arg1].TypeId;
                    int rank = CSLite_System.GetRank(this.symbol_table[typeId].Name);
                    if ((rank > 0) && (rank != num9))
                    {
                        this.scripter.CreateErrorObjectEx("CS0022. Wrong number of indices inside [], expected '{0}'.", new object[] { rank.ToString() });
                        goto Label_22C6;
                    }
                }
            }
            else
            {
                int num3 = this.symbol_table[this.r.arg1].TypeId;
                string name = this.symbol_table[num3].Name;
                string elementTypeName = CSLite_System.GetElementTypeName(name);
                int num4 = 0;
                PropertyObject obj4 = null;
                if (elementTypeName == "")
                {
                    ClassObject obj5 = this.GetClassObject(num3);
                    if (obj5.IsPascalArray)
                    {
                        name = obj5.ImportedType.Name + "[]";
                        elementTypeName = this.symbol_table[obj5.IndexTypeId].Name;
                    }
                }
                if (elementTypeName == "")
                {
                    obj4 = this.GetClassObject(num3).FindIndexer();
                    if (obj4 == null)
                    {
                        this.scripter.CreateErrorObjectEx("CS0021. Cannot apply indexing with [] to an expression of type '{0}'.", new object[] { name });
                        goto Label_22C6;
                    }
                    num4 = this.symbol_table[obj4.Id].TypeId;
                }
                else
                {
                    for (int k = num3; k >= 0; k--)
                    {
                        if ((this.symbol_table[k].Kind == MemberKind.Type) && (this.symbol_table[k].Name == elementTypeName))
                        {
                            num4 = k;
                            break;
                        }
                    }
                }
                if (num4 == 0)
                {
                    elementTypeName = CSLite_System.GetElementTypeName(this.symbol_table[num3].FullName);
                    bool upcase = this.GetUpcase();
                    MemberObject obj6 = this.FindType(this.RecreateLevelStack(this.n), elementTypeName, upcase);
                    if (obj6 == null)
                    {
                        this.scripter.CreateErrorObjectEx("CS0246. The type or namespace name '{0}' could not be found (are you missing a using directive or an assembly reference?).", new object[] { elementTypeName });
                        goto Label_22C6;
                    }
                    num4 = obj6.Id;
                }
                this.symbol_table[this.r.res].TypeId = num4;
            }
            Label_04A6:
            if (((op == this.OP_CREATE_INDEX_OBJECT) || (op == this.OP_ADD_INDEX)) || (op == this.OP_SETUP_INDEX_OBJECT))
            {
                goto Label_0079;
            }
            for (int i = 1; i <= 2; i++)
            {
                int num13;
                if (i == 1)
                {
                    num13 = this.r.arg1;
                }
                else
                {
                    num13 = this.r.arg2;
                }
                if (this.symbol_table[num13].Kind == MemberKind.Index)
                {
                    l.Clear();
                    int avalue = this.n;
                    while (true)
                    {
                        if ((this[avalue].op == this.OP_CREATE_INDEX_OBJECT) && (this[avalue].res == num13))
                        {
                            break;
                        }
                        avalue--;
                    }
                    int num15 = this[avalue].arg1;
                    l.Add(avalue);
                    int num16 = this.symbol_table[num15].TypeId;
                    PropertyObject obj8 = this.GetClassObject(num16).FindIndexer();
                    if (obj8 != null)
                    {
                        while (true)
                        {
                            if ((this[avalue].op == this.OP_SETUP_INDEX_OBJECT) && (this[avalue].arg1 == num13))
                            {
                                break;
                            }
                            if ((this[avalue].op == this.OP_ADD_INDEX) && (this[avalue].arg1 == num13))
                            {
                                l.Add(avalue);
                            }
                            avalue++;
                        }
                        l.Add(avalue);
                        if ((this.r.op == this.OP_ASSIGN) && (i == 1))
                        {
                            if (obj8.WriteId == 0)
                            {
                                this.scripter.CreateErrorObject("CS0154. The property or indexer '{0}' cannot be used in this context because it lacks the get accessor.");
                                break;
                            }
                            int num17 = this.r.arg2;
                            this.InsertOperators(this.n, obj8.ParamCount + 3);
                            this.n--;
                            this.n++;
                            this[this.n].op = this.OP_BEGIN_CALL;
                            this[this.n].arg1 = obj8.WriteId;
                            this[this.n].arg2 = 0;
                            this[this.n].res = 0;
                            for (int m = 1; m < (l.Count - 1); m++)
                            {
                                this.n++;
                                this[this.n].op = this.OP_PUSH;
                                this[this.n].arg1 = this[l[m]].arg2;
                                this[this.n].arg2 = 0;
                                this[this.n].res = obj8.WriteId;
                            }
                            this.n++;
                            this[this.n].op = this.OP_PUSH;
                            this[this.n].arg1 = num17;
                            this[this.n].arg2 = 0;
                            this[this.n].res = obj8.WriteId;
                            this.n++;
                            this[this.n].op = this.OP_PUSH;
                            this[this.n].arg1 = num15;
                            this[this.n].arg2 = 0;
                            this[this.n].res = 0;
                            this.n++;
                            this[this.n].op = this.OP_CALL_BASE;
                            this[this.n].arg1 = obj8.WriteId;
                            this[this.n].arg2 = l.Count - 1;
                            this[this.n].res = 0;
                            this.r = (ProgRec) this.prog[this.n];
                            op = this.r.op;
                        }
                        else
                        {
                            if (obj8.ReadId == 0)
                            {
                                this.scripter.CreateErrorObject("CS0154. The property or indexer '{0}' cannot be used in this context because it lacks the get accessor.");
                                break;
                            }
                            int num19 = this.AppVar(this.symbol_table[num13].Level, this.symbol_table[num13].TypeId);
                            if (i == 1)
                            {
                                this.r.arg1 = num19;
                            }
                            else
                            {
                                this.r.arg2 = num19;
                            }
                            this.InsertOperators(this.n, obj8.ParamCount + 3);
                            this.n--;
                            this.n++;
                            this[this.n].op = this.OP_BEGIN_CALL;
                            this[this.n].arg1 = obj8.ReadId;
                            this[this.n].arg2 = 0;
                            this[this.n].res = 0;
                            for (int num20 = 1; num20 < (l.Count - 1); num20++)
                            {
                                this.n++;
                                this[this.n].op = this.OP_PUSH;
                                this[this.n].arg1 = this[l[num20]].arg2;
                                this[this.n].arg2 = 0;
                                this[this.n].res = obj8.ReadId;
                            }
                            this.n++;
                            this[this.n].op = this.OP_PUSH;
                            this[this.n].arg1 = num15;
                            this[this.n].arg2 = 0;
                            this[this.n].res = 0;
                            this.n++;
                            this[this.n].op = this.OP_CALL_BASE;
                            this[this.n].arg1 = obj8.ReadId;
                            this[this.n].arg2 = l.Count - 2;
                            this[this.n].res = num19;
                            this.symbol_table[this[this.n].res].TypeId = this.symbol_table[obj8.ReadId].TypeId;
                            this.r = (ProgRec) this.prog[this.n];
                            op = this.r.op;
                        }
                        list4.AddFrom(l);
                    }
                }
            }
            if (op == this.OP_CREATE_METHOD)
            {
                num = this.r.arg1;
                goto Label_0079;
            }
            if (op != this.OP_CALL_SIMPLE)
            {
                if ((op == this.OP_CALL) || (op == this.OP_CALL_BASE))
                {
                    this.CheckOP_CALL(classObject, num, a, list2, pos);
                    if (!this.scripter.IsError())
                    {
                        goto Label_0079;
                    }
                    goto Label_22C6;
                }
                if (op == this.OP_CHECK_STRUCT_CONSTRUCTOR)
                {
                    ClassObject obj12 = this.GetClassObject(this.r.arg1);
                    if (obj12.IsStruct && !obj12.Imported)
                    {
                        FunctionObject obj13;
                        this.r.op = this.OP_CREATE_OBJECT;
                        int num35 = obj12.FindConstructorId(null, null, out obj13);
                        if (num35 == 0)
                        {
                            this.scripter.CreateErrorObjectEx("CS0143. The type '{0}' has no constructors defined.", new object[] { obj12.Name });
                        }
                        this.n++;
                        this.InsertOperators(this.n, 2);
                        this[this.n].op = this.OP_PUSH;
                        this[this.n].arg1 = this.r.res;
                        this[this.n].arg2 = 0;
                        this[this.n].res = 0;
                        this.n++;
                        this[this.n].op = this.OP_CALL;
                        this[this.n].arg1 = num35;
                        this[this.n].arg2 = 0;
                        this[this.n].res = 0;
                    }
                    else
                    {
                        this.r.op = this.OP_NOP;
                    }
                }
                else if (op == this.OP_INSERT_STRUCT_CONSTRUCTORS)
                {
                    ClassObject obj14 = this.GetClassObject(this.r.arg1);
                    for (int num36 = 0; num36 < obj14.Members.Count; num36++)
                    {
                        MemberObject obj15 = obj14.Members[num36];
                        if (obj15.Kind == MemberKind.Field)
                        {
                            int num37 = this.symbol_table[obj15.Id].TypeId;
                            ClassObject obj16 = this.GetClassObject(num37);
                            if (obj16.IsStruct && !obj16.Imported)
                            {
                                if (obj16.IsPascalArray)
                                {
                                    this.n++;
                                    this.InsertOperators(this.n, 1);
                                    this[this.n].op = this.OP_CREATE_OBJECT;
                                    this[this.n].arg1 = num37;
                                    this[this.n].arg2 = 0;
                                    this[this.n].res = obj15.Id;
                                }
                                else
                                {
                                    FunctionObject obj17;
                                    int num38 = obj16.FindConstructorId(null, null, out obj17);
                                    if (num38 == 0)
                                    {
                                        this.scripter.CreateErrorObjectEx("CS0143. The type '{0}' has no constructors defined.", new object[] { obj16.Name });
                                    }
                                    this.n++;
                                    this.InsertOperators(this.n, 3);
                                    this[this.n].op = this.OP_CREATE_OBJECT;
                                    this[this.n].arg1 = num37;
                                    this[this.n].arg2 = 0;
                                    this[this.n].res = obj15.Id;
                                    this.n++;
                                    this[this.n].op = this.OP_PUSH;
                                    this[this.n].arg1 = obj15.Id;
                                    this[this.n].arg2 = 0;
                                    this[this.n].res = 0;
                                    this.n++;
                                    this[this.n].op = this.OP_CALL;
                                    this[this.n].arg1 = num38;
                                    this[this.n].arg2 = 0;
                                    this[this.n].res = 0;
                                }
                            }
                        }
                    }
                }
                else
                {
                    if (op == this.OP_CAST)
                    {
                        this.CheckOP_CAST();
                        if (!this.scripter.IsError())
                        {
                            goto Label_0079;
                        }
                        goto Label_22C6;
                    }
                    if (op == this.OP_TO_SBYTE)
                    {
                        this.symbol_table[this.r.res].TypeId = 10;
                    }
                    else if (op == this.OP_TO_BYTE)
                    {
                        this.symbol_table[this.r.res].TypeId = 3;
                    }
                    else if (op == this.OP_TO_USHORT)
                    {
                        this.symbol_table[this.r.res].TypeId = 15;
                    }
                    else if (op == this.OP_TO_SHORT)
                    {
                        this.symbol_table[this.r.res].TypeId = 11;
                    }
                    else if (op == this.OP_TO_UINT)
                    {
                        this.symbol_table[this.r.res].TypeId = 13;
                    }
                    else if (op == this.OP_TO_INT)
                    {
                        this.symbol_table[this.r.res].TypeId = 8;
                    }
                    else if (op == this.OP_TO_ULONG)
                    {
                        this.symbol_table[this.r.res].TypeId = 14;
                    }
                    else if (op == this.OP_TO_LONG)
                    {
                        this.symbol_table[this.r.res].TypeId = 9;
                    }
                    else if (op == this.OP_TO_CHAR)
                    {
                        this.symbol_table[this.r.res].TypeId = 4;
                    }
                    else if (op == this.OP_TO_FLOAT)
                    {
                        this.symbol_table[this.r.res].TypeId = 7;
                    }
                    else if (op == this.OP_TO_DOUBLE)
                    {
                        this.symbol_table[this.r.res].TypeId = 6;
                    }
                    else if (op == this.OP_TO_DECIMAL)
                    {
                        this.symbol_table[this.r.res].TypeId = 5;
                    }
                    else if (op == this.OP_TO_STRING)
                    {
                        this.symbol_table[this.r.res].TypeId = 12;
                    }
                    else if (op == this.OP_TO_BOOLEAN)
                    {
                        this.symbol_table[this.r.res].TypeId = 2;
                    }
                    else
                    {
                        if (op == this.OP_INC)
                        {
                            this.CheckOP_INC();
                            if (!this.scripter.IsError())
                            {
                                goto Label_0079;
                            }
                            goto Label_22C6;
                        }
                        if (op == this.OP_DEC)
                        {
                            this.CheckOP_DEC();
                            if (!this.scripter.IsError())
                            {
                                goto Label_0079;
                            }
                            goto Label_22C6;
                        }
                        if (op == this.OP_ASSIGN_COND_TYPE)
                        {
                            this.CheckOP_ASSIGN_COND_TYPE();
                        }
                        else if (op == this.OP_ADD_EXPLICIT_INTERFACE)
                        {
                            this.OperAddExplicitInterface();
                        }
                        else if (op == this.OP_END_CLASS)
                        {
                            stack.Pop();
                            if (stack.Count > 0)
                            {
                                int num39 = stack.Peek();
                                classObject = this.GetClassObject(num39);
                            }
                            else
                            {
                                classObject = null;
                            }
                        }
                        else
                        {
                            if (op != this.OP_CREATE_CLASS)
                            {
                                if (op == this.OP_CREATE_OBJECT)
                                {
                                    ClassObject obj27 = this.GetClassObject(this.r.arg1);
                                    if (!obj27.Abstract && !obj27.IsInterface)
                                    {
                                        goto Label_0079;
                                    }
                                    this.scripter.CreateErrorObjectEx("CS0144. Cannot create an instance of the abstract class or interface '{0}'.", new object[] { obj27.Name });
                                }
                                else
                                {
                                    if (op == this.OP_END_USING)
                                    {
                                        if ((obj2 != null) && (obj2.Id == this.r.arg1))
                                        {
                                            obj2 = null;
                                        }
                                        goto Label_0079;
                                    }
                                    if (op == this.OP_ASSIGN)
                                    {
                                        this.CheckOP_ASSIGN(obj2);
                                        if (!this.scripter.IsError())
                                        {
                                            goto Label_0079;
                                        }
                                    }
                                    else
                                    {
                                        if (op == this.OP_UNARY_MINUS)
                                        {
                                            if (!this.SetupDetailedUnaryOperator(op, "-", this.detailed_negation_operators))
                                            {
                                                goto Label_22C6;
                                            }
                                            if (this[this.n].op != this.OP_CALL_SIMPLE)
                                            {
                                                this.r = this[this.n];
                                                int num48 = this.GetTypeId(this.r.arg1);
                                                int num49 = this.GetTypeId(this.r.res);
                                                if ((num48 != num49) && IsNumericTypeId(num49))
                                                {
                                                    this.InsertNumericConversion(num49, 1);
                                                }
                                            }
                                            goto Label_0079;
                                        }
                                        if (op == this.OP_NOT)
                                        {
                                            if (this.SetupDetailedUnaryOperator(op, "!", this.detailed_logical_negation_operators))
                                            {
                                                goto Label_0079;
                                            }
                                        }
                                        else
                                        {
                                            if (op == this.OP_COMPLEMENT)
                                            {
                                                if (!this.SetupDetailedUnaryOperator(op, "~", this.detailed_bitwise_complement_operators))
                                                {
                                                    goto Label_22C6;
                                                }
                                                if (this[this.n].op != this.OP_CALL_SIMPLE)
                                                {
                                                    this.r = this[this.n];
                                                    int num50 = this.GetTypeId(this.r.arg1);
                                                    int num51 = this.GetTypeId(this.r.res);
                                                    if ((num50 != num51) && IsNumericTypeId(num51))
                                                    {
                                                        this.InsertNumericConversion(num51, 1);
                                                    }
                                                }
                                                goto Label_0079;
                                            }
                                            if (op == this.OP_PLUS)
                                            {
                                                this.CheckOP_PLUS();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_MINUS)
                                            {
                                                this.CheckOP_MINUS();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_MULT)
                                            {
                                                this.CheckOP_MULT();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_EXPONENT)
                                            {
                                                this.CheckOP_EXP();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_DIV)
                                            {
                                                this.CheckOP_DIV();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_MOD)
                                            {
                                                this.CheckOP_MOD();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_LEFT_SHIFT)
                                            {
                                                this.CheckOP_LEFT_SHIFT();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_RIGHT_SHIFT)
                                            {
                                                this.CheckOP_RIGHT_SHIFT();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_BITWISE_AND)
                                            {
                                                this.CheckOP_BITWISE_AND();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_BITWISE_OR)
                                            {
                                                this.CheckOP_BITWISE_OR();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_BITWISE_XOR)
                                            {
                                                this.CheckOP_BITWISE_XOR();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_LOGICAL_AND)
                                            {
                                                this.CheckOP_LOGICAL_AND();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else if (op == this.OP_LOGICAL_OR)
                                            {
                                                this.CheckOP_LOGICAL_OR();
                                                if (!this.scripter.IsError())
                                                {
                                                    goto Label_0079;
                                                }
                                            }
                                            else
                                            {
                                                if (op == this.OP_LT)
                                                {
                                                    if (!this.SetupDetailedBinaryOperator(op, "<", this.detailed_lt_operators))
                                                    {
                                                        goto Label_22C6;
                                                    }
                                                    this.symbol_table[this.r.res].TypeId = 2;
                                                    goto Label_0079;
                                                }
                                                if (op == this.OP_LE)
                                                {
                                                    if (!this.SetupDetailedBinaryOperator(op, "<=", this.detailed_le_operators))
                                                    {
                                                        goto Label_22C6;
                                                    }
                                                    this.symbol_table[this.r.res].TypeId = 2;
                                                    goto Label_0079;
                                                }
                                                if (op == this.OP_GT)
                                                {
                                                    if (!this.SetupDetailedBinaryOperator(op, ">", this.detailed_gt_operators))
                                                    {
                                                        goto Label_22C6;
                                                    }
                                                    this.symbol_table[this.r.res].TypeId = 2;
                                                    goto Label_0079;
                                                }
                                                if (op == this.OP_GE)
                                                {
                                                    if (!this.SetupDetailedBinaryOperator(op, ">=", this.detailed_ge_operators))
                                                    {
                                                        goto Label_22C6;
                                                    }
                                                    this.symbol_table[this.r.res].TypeId = 2;
                                                    goto Label_0079;
                                                }
                                                if (op == this.OP_EQ)
                                                {
                                                    this.CheckOP_EQ();
                                                    if (!this.scripter.IsError())
                                                    {
                                                        goto Label_0079;
                                                    }
                                                }
                                                else if (op == this.OP_NE)
                                                {
                                                    this.CheckOP_NE();
                                                    if (!this.scripter.IsError())
                                                    {
                                                        goto Label_0079;
                                                    }
                                                }
                                                else
                                                {
                                                    if (op == this.OP_IS)
                                                    {
                                                        this.symbol_table[this.r.res].TypeId = 2;
                                                        goto Label_0079;
                                                    }
                                                    if (op == this.OP_AS)
                                                    {
                                                        if (this.symbol_table[this.r.arg2].Kind != MemberKind.Type)
                                                        {
                                                            this.scripter.CreateErrorObject("CS1031. Type expected.");
                                                            goto Label_22C6;
                                                        }
                                                        ClassObject obj28 = this.GetClassObject(this.symbol_table[this.r.arg1].TypeId);
                                                        ClassObject obj29 = this.GetClassObject(this.r.arg2);
                                                        if (obj29.IsValueType)
                                                        {
                                                            this.scripter.CreateErrorObjectEx("CS0077. The as operator must be used with a reference type ('{0}' is a value type).", new object[] { obj29.Name });
                                                            goto Label_22C6;
                                                        }
                                                        if (!this.scripter.conversion.ExistsImplicitReferenceConversion(obj29, obj28))
                                                        {
                                                            this.scripter.CreateErrorObjectEx("CS0039. Cannot convert type '{0}' to '{1}'.", new object[] { obj29.Name, obj28.Name });
                                                            goto Label_22C6;
                                                        }
                                                        this.symbol_table[this.r.res].TypeId = this.r.arg2;
                                                        goto Label_0079;
                                                    }
                                                    if (op == this.OP_CREATE_REFERENCE)
                                                    {
                                                        this.CheckOP_CREATE_REFERENCE(classObject);
                                                        if (this.scripter.IsError())
                                                        {
                                                            goto Label_22C6;
                                                        }
                                                        goto Label_0079;
                                                    }
                                                    if (op == this.OP_DECLARE_LOCAL_VARIABLE)
                                                    {
                                                        this.OperDeclareLocalVariable();
                                                        goto Label_0079;
                                                    }
                                                    if (op != this.OP_ADDRESS_OF)
                                                    {
                                                        goto Label_0079;
                                                    }
                                                    this.ProcessAddressOf();
                                                    if (!this.scripter.IsError())
                                                    {
                                                        goto Label_0079;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                goto Label_22C6;
                            }
                            bool flag3 = this.GetUpcase(this.n);
                            ClassObject obj18 = this.GetClassObject(this.r.arg1);
                            if (obj18.Class_Kind == ClassKind.Enum)
                            {
                                obj2 = obj18;
                            }
                            classObject = obj18;
                            stack.Push(classObject.Id);
                            if (obj18.IsClass || obj18.IsStruct)
                            {
                                int num40 = 0;
                                for (int num41 = 0; num41 < obj18.AncestorIds.Count; num41++)
                                {
                                    int num42 = obj18.AncestorIds[num41];
                                    ClassObject obj19 = this.GetClassObject(num42);
                                    if (!obj19.IsInterface)
                                    {
                                        num40++;
                                        if (num40 > 1)
                                        {
                                            this.scripter.CreateErrorObjectEx("CS0527. '{0}' : type in interface list is not an interface.", new object[] { obj19.Name });
                                            break;
                                        }
                                    }
                                }
                                IntegerList supportedInterfaceListIds = obj18.GetSupportedInterfaceListIds();
                                if (obj18.AncestorClass.HasModifier(Modifier.Abstract))
                                {
                                    supportedInterfaceListIds.Add(obj18.AncestorClass.Id);
                                }
                                for (int num43 = 0; num43 < supportedInterfaceListIds.Count; num43++)
                                {
                                    int num44 = supportedInterfaceListIds[num43];
                                    ClassObject obj20 = this.GetClassObject(num44);
                                    for (int num45 = 0; num45 < obj20.Members.Count; num45++)
                                    {
                                        MemberObject obj21 = obj20.Members[num45];
                                        if (obj21.HasModifier(Modifier.Abstract))
                                        {
                                            if (((obj21.Kind == MemberKind.Method) || (obj21.Kind == MemberKind.Constructor)) || (obj21.Kind == MemberKind.Destructor))
                                            {
                                                bool flag4 = false;
                                                FunctionObject fy = (FunctionObject) obj21;
                                                for (int num46 = 0; num46 < obj18.Members.Count; num46++)
                                                {
                                                    MemberObject obj23 = obj18.Members[num46];
                                                    if (obj23.Public && (obj21.Kind == obj23.Kind))
                                                    {
                                                        if (CSLite_System.CompareStrings(obj21.Name, obj23.Name, flag3))
                                                        {
                                                            FunctionObject fx = (FunctionObject) obj23;
                                                            if (FunctionObject.CompareHeaders(fx, fy))
                                                            {
                                                                flag4 = true;
                                                                break;
                                                            }
                                                        }
                                                        if (obj23.ImplementsId != 0)
                                                        {
                                                            string str6 = this.symbol_table[obj23.ImplementsId].Name;
                                                            if (CSLite_System.CompareStrings(obj21.Name, str6, flag3))
                                                            {
                                                                flag4 = true;
                                                                break;
                                                            }
                                                        }
                                                    }
                                                }
                                                if (flag4)
                                                {
                                                    continue;
                                                }
                                                if (obj20.IsInterface)
                                                {
                                                    this.scripter.CreateErrorObjectEx("CS0535. '{0}' does not implement interface member '{1}'.", new object[] { obj18.FullName, obj20.FullName + "." + fy.Name });
                                                }
                                                else if (obj20.IsClass)
                                                {
                                                    this.scripter.CreateErrorObjectEx("CS0534. '{0}' does not implement inherited abstract member '{1}'.", new object[] { obj18.FullName, obj20.FullName + "." + fy.Name });
                                                }
                                                break;
                                            }
                                            if (obj21.Kind == MemberKind.Property)
                                            {
                                                bool flag5 = false;
                                                PropertyObject obj25 = (PropertyObject) obj21;
                                                for (int num47 = 0; num47 < obj18.Members.Count; num47++)
                                                {
                                                    MemberObject obj26 = obj18.Members[num47];
                                                    if (obj26.Public && (obj21.Kind == obj26.Kind))
                                                    {
                                                        if (CSLite_System.CompareStrings(obj21.Name, obj26.Name, flag3))
                                                        {
                                                            flag5 = true;
                                                            break;
                                                        }
                                                        if (obj26.ImplementsId != 0)
                                                        {
                                                            string str7 = this.symbol_table[obj26.ImplementsId].Name;
                                                            if (CSLite_System.CompareStrings(obj21.Name, str7, flag3))
                                                            {
                                                                flag5 = true;
                                                                break;
                                                            }
                                                        }
                                                    }
                                                }
                                                if (!flag5)
                                                {
                                                    if (obj20.IsInterface)
                                                    {
                                                        this.scripter.CreateErrorObjectEx("CS0535. '{0}' does not implement interface member '{1}'.", new object[] { obj18.FullName, obj20.FullName + "." + obj25.Name });
                                                    }
                                                    else if (obj20.IsClass)
                                                    {
                                                        this.scripter.CreateErrorObjectEx("CS0534. '{0}' does not implement inherited abstract member '{1}'.", new object[] { obj18.FullName, obj20.FullName + "." + obj25.Name });
                                                    }
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                goto Label_0079;
            }
            this.r.op = this.OP_CALL;
            int id = this.r.arg1;
            if (this.symbol_table[id].Kind != MemberKind.Method)
            {
                goto Label_0079;
            }
            int num22 = this.r.arg2;
            a.Clear();
            list2.Clear();
            pos.Clear();
            if (num22 > 0)
            {
                int num23 = this.n - 1;
                do
                {
                    if ((this[num23].op == this.OP_PUSH) && (this[num23].res == id))
                    {
                        pos.Add(num23);
                        a.Add(this[num23].arg1);
                        list2.Add(this[num23].arg2);
                        if (a.Count == num22)
                        {
                            goto Label_0C8B;
                        }
                    }
                    num23--;
                }
                while (num23 != 0);
                this.scripter.CreateErrorObject("CS0001. Internal compiler error.");
                return;
            }
            Label_0C8B:
            obj9 = this.GetFunctionObject(id);
            bool flag2 = true;
            for (int j = 0; j < num22; j++)
            {
                int paramId = obj9.GetParamId(j);
                int num26 = a[j];
                if (!obj9.Imported)
                {
                    flag2 = ((int)obj9.GetParamMod(j) == list2[j]);
                }
                else
                {
                    flag2 = true;
                }
                if (!flag2)
                {
                    this.n = pos[j];
                    ParamMod paramMod = obj9.GetParamMod(j);
                    ParamMod mod2 = (ParamMod) list2[j];
                    int num27 = this.symbol_table[paramId].TypeId;
                    int num28 = this.symbol_table[num26].TypeId;
                    string str4 = this.symbol_table[num27].Name;
                    string str5 = this.symbol_table[num28].Name;
                    switch (paramMod)
                    {
                        case ParamMod.RetVal:
                            str4 = "ref " + str4;
                            break;

                        case ParamMod.Out:
                            str4 = "out " + str4;
                            break;
                    }
                    if (mod2 == ParamMod.RetVal)
                    {
                        str5 = "ref " + str5;
                    }
                    else if (mod2 == ParamMod.Out)
                    {
                        str5 = "out " + str5;
                    }
                    this.scripter.CreateErrorObjectEx("CS0029. Cannot impllicitly convert type '{0}' to '{1}'.", new object[] { str4, str5 });
                    break;
                }
                flag2 = this.scripter.MatchAssignment(paramId, num26);
                if (!flag2)
                {
                    this.n = pos[j];
                    int num29 = this.symbol_table[paramId].TypeId;
                    int num30 = this.symbol_table[num26].TypeId;
                    ClassObject obj10 = this.GetClassObject(num29);
                    ClassObject obj11 = this.GetClassObject(num30);
                    int num31 = obj10.FindOverloadableImplicitOperatorId(num26, paramId);
                    if (num31 > 0)
                    {
                        int currMethodId = this.GetCurrMethodId();
                        int num33 = this.AppVar(currMethodId, num29);
                        int res = this[this.n].res;
                        this[this.n].arg1 = num33;
                        this.InsertOperators(this.n, 3);
                        this[this.n].op = this.OP_PUSH;
                        this[this.n].arg1 = num26;
                        this[this.n].arg2 = 0;
                        this[this.n].res = num31;
                        this.n++;
                        this[this.n].op = this.OP_PUSH;
                        this[this.n].arg1 = obj10.Id;
                        this[this.n].arg2 = 0;
                        this[this.n].res = 0;
                        this.n++;
                        this[this.n].op = this.OP_CALL_SIMPLE;
                        this[this.n].arg1 = num31;
                        this[this.n].arg2 = 1;
                        this[this.n].res = num33;
                        while (this[this.n].arg1 != res)
                        {
                            this.n++;
                        }
                        goto Label_0079;
                    }
                    this.scripter.CreateErrorObjectEx("CS0029. Cannot impllicitly convert type '{0}' to '{1}'.", new object[] { obj11.Name, obj10.Name });
                    break;
                }
            }
            if (flag2)
            {
                goto Label_0079;
            }
            Label_22C6:
            num52 = 0;
            while (num52 < list4.Count)
            {
                this.n = list4[num52];
                this[this.n].op = this.OP_NOP;
                num52++;
            }
        }
Beispiel #17
0
        /// <summary>
        ///     获取对象
        /// </summary>
        /// <param name="cout"></param>
        /// <returns></returns>
        public T[] GetObject(int cout)
        {
            if (ObjectStack.Count == 0)
            {
                var p = new T[cout];

                for (var i = 0; i < cout; i++)
                {
                    p[i] = GetT();
                    if (GetObjectRunTime != null)
                    {
                        p[i] = GetObjectRunTime(p[i], this);
                    }
                }

                return(p);
            }
            else
            {
#if USEConcurrent
                var p = new T[cout];

                var lpcout = ObjectStack.TryPopRange(p);


                if (lpcout < cout)
                {
                    var x = cout - lpcout;

                    var xp = new T[x];

                    for (var i = 0; i < x; i++)
                    {
                        xp[i] = GetT();
                    }

                    Array.Copy(xp, 0, p, lpcout, x);
                }

                if (GetObjectRunTime != null)
                {
                    for (var i = 0; i < p.Length; i++)
                    {
                        p[i] = GetObjectRunTime(p[i], this);
                    }
                }


                return(p);
#else
#if  lockStack == true
                lock (lockStack)
                {
#endif

                T[] p = new T[cout];

                for (int i = 0; i < cout; i++)
                {
                    if (ObjectStack.Count > 0)
                    {
                        p[i] = ObjectStack.Pop();

                        if (p[i] == null)
                        {
                            p[i] = GetT();
                        }
                    }
                    else
                    {
                        p[i] = GetT();
                    }


                    if (GetObjectRunTime != null)
                    {
                        p[i] = GetObjectRunTime(p[i], this);
                    }
                }

                return(p);

#if  lockStack == true
            }
#endif
#endif
            }
        }
Beispiel #18
0
        /// <summary>
        ///     获取对象
        /// </summary>
        /// <returns></returns>
        public T GetObject()
        {
            if (ObjectStack.Count == 0)
            {
                var p = GetT();
                if (GetObjectRunTime != null)
                {
                    p = GetObjectRunTime(p, this);
                }
                I1++;
                return(p);
            }
            else
            {
#if USEConcurrent
                T p;

                if (ObjectStack.TryPop(out p))
                {
                    if (GetObjectRunTime != null)
                    {
                        p = GetObjectRunTime(p, this);
                    }

                    I2++;

                    return(p);
                }
                p = GetT();

                if (GetObjectRunTime != null)
                {
                    p = GetObjectRunTime(p, this);
                }

                return(p);
#else
                T p;

#if  lockStack == true
                lock (lockStack)
                {
#endif
                if (ObjectStack.Count > 0)
                {
                    i2++;

                    p = ObjectStack.Pop();

                    if (p == null)
                    {
                        p = GetT();
                    }

                    if (GetObjectRunTime != null)
                    {
                        p = GetObjectRunTime(p, this);
                    }

                    return(p);
                }
                else
                {
                    p = GetT();

                    if (GetObjectRunTime != null)
                    {
                        p = GetObjectRunTime(p, this);
                    }

                    return(p);
                }
#if  lockStack == true
            }
#endif
#endif
            }
        }
Beispiel #19
0
 public void RemoveEvalOpEx(int init_n, IntegerStack init_l)
 {
     if (!this.scripter.IsError())
     {
         IntegerStack stack;
         if (init_l == null)
         {
             stack = new IntegerStack();
         }
         else
         {
             stack = init_l.Clone();
         }
         for (int i = init_n + 1; i <= this.Card; i++)
         {
             bool flag;
             this.r = (ProgRec) this.prog[i];
             int op = this.r.op;
             this.n = i;
             if (op == this.OP_CREATE_METHOD)
             {
                 stack.Push(this.r.arg1);
                 int id = this.r.arg1;
                 int num4 = this.r.arg2;
                 MemberObject memberObject = this.GetMemberObject(id);
                 flag = memberObject.HasModifier(Modifier.New);
                 bool upcase = this.GetUpcase(this.n);
                 ClassObject classObject = this.GetClassObject(num4);
                 for (int j = 0; j < classObject.AncestorIds.Count; j++)
                 {
                     ClassObject obj4 = this.GetClassObject(classObject.AncestorIds[j]);
                     MemberObject memberByNameIndex = obj4.GetMemberByNameIndex(memberObject.NameIndex, upcase);
                     if (memberByNameIndex != null)
                     {
                         if ((!flag && !obj4.IsInterface) && (((!memberObject.HasModifier(Modifier.Override) || !memberByNameIndex.HasModifier(Modifier.Virtual)) && !memberObject.HasModifier(Modifier.Override)) && !memberObject.HasModifier(Modifier.Shadows)))
                         {
                             this.scripter.CreateWarningObjectEx("CS0108. The keyword new is required on '{0}' because it hides inherited member '{1}'", new object[] { memberObject.FullName, obj4.FullName + "." + memberObject.Name });
                         }
                     }
                     else if (flag)
                     {
                         this.scripter.CreateWarningObjectEx("CS0109. The member '{0}' does not hide an inherited member. The new keyword is not required.", new object[] { memberObject.FullName });
                     }
                 }
             }
             else if (op == this.OP_RET)
             {
                 stack.Pop();
             }
             else if (op == this.OP_BEGIN_USING)
             {
                 int res = this.r.arg1;
                 while (this.symbol_table[res].Kind == MemberKind.Alias)
                 {
                     MemberObject obj6 = this.GetMemberObject(res);
                     res = this[obj6.PCodeLine].res;
                 }
                 string fullName = this.symbol_table[res].FullName;
                 if (this.scripter.CheckForbiddenNamespace(fullName))
                 {
                     this.scripter.CreateErrorObjectEx("CSLite0006. Use of forbidden namespace '{0}'.", new object[] { fullName });
                 }
                 stack.Push(res);
             }
             else if (op == this.OP_END_USING)
             {
                 stack.Pop();
             }
             else if (op == this.OP_ADD_ANCESTOR)
             {
                 this.ProcessAddAncestor();
                 if (this.scripter.IsError())
                 {
                     break;
                 }
             }
             else if (((op == this.OP_CREATE_FIELD) || (op == this.OP_CREATE_EVENT)) || (op == this.OP_CREATE_PROPERTY))
             {
                 int num7 = this.r.arg1;
                 int num8 = this.r.arg2;
                 MemberObject obj7 = this.GetMemberObject(num7);
                 flag = obj7.HasModifier(Modifier.New);
                 ClassObject obj8 = this.GetClassObject(num8);
                 bool flag4 = this.GetUpcase(this.n);
                 for (int k = 0; k < obj8.AncestorIds.Count; k++)
                 {
                     ClassObject obj9 = this.GetClassObject(obj8.AncestorIds[k]);
                     if (obj9.GetMemberByNameIndex(obj7.NameIndex, flag4) != null)
                     {
                         if (!(((flag || obj9.IsInterface) || obj7.HasModifier(Modifier.Override)) || obj7.HasModifier(Modifier.Shadows)))
                         {
                             this.scripter.CreateWarningObjectEx("CS0108. The keyword new is required on '{0}' because it hides inherited member '{1}'", new object[] { obj7.FullName, obj9.FullName + "." + obj7.Name });
                         }
                     }
                     else if (flag)
                     {
                         this.scripter.CreateWarningObjectEx("CS0109. The member '{0}' does not hide an inherited member. The new keyword is not required.", new object[] { obj7.FullName });
                     }
                 }
             }
             else if (op == this.OP_EVAL_TYPE)
             {
                 this.ProcessEvalType(stack);
                 if (this.scripter.IsError())
                 {
                     break;
                 }
             }
             else if (op == this.OP_ADD_UNDERLYING_TYPE)
             {
                 int num10 = this.r.arg1;
                 int num11 = this.r.arg2;
                 ClassObject obj10 = this.GetClassObject(num10);
                 ClassObject obj11 = this.GetClassObject(num11);
                 obj10.UnderlyingType = obj11;
             }
             else if (op == this.OP_EVAL)
             {
                 if ((this[this.n + 1].op == this.OP_EVAL_TYPE) && (this[this.n + 1].res == this.r.res))
                 {
                     this.r.op = this.OP_NOP;
                 }
                 else
                 {
                     this.ProcessEvalOp(stack);
                     if (this.scripter.IsError())
                     {
                         break;
                     }
                 }
             }
         }
         if (!this.scripter.IsError())
         {
             for (int m = init_n + 1; m <= this.Card; m++)
             {
                 this.r = (ProgRec) this.prog[m];
                 int num13 = this.r.op;
                 this.n = m;
                 if (num13 == this.OP_EVAL_BASE_TYPE)
                 {
                     ClassObject obj12 = this.GetClassObject(this.r.arg1);
                     ClassObject ancestorClass = obj12.AncestorClass;
                     if (ancestorClass == null)
                     {
                         int num14 = 0x10;
                         ancestorClass = this.GetClassObject(num14);
                         obj12.AncestorIds.Add(num14);
                     }
                     this.ReplaceId(this.r.res, ancestorClass.Id);
                     if (this.r.arg2 != 0)
                     {
                         FunctionObject obj14;
                         int num15 = ancestorClass.FindConstructorId(null, null, out obj14);
                         if (num15 != 0)
                         {
                             this.ReplaceId(this.r.arg2, num15);
                         }
                     }
                     this.r.op = this.OP_NOP;
                 }
                 else if (num13 == this.OP_CAST)
                 {
                     this.symbol_table[this.r.res].TypeId = this.r.arg1;
                 }
                 else if (num13 == this.OP_ASSIGN_NAME)
                 {
                     this.symbol_table[this.r.res].NameIndex = this.symbol_table[this.r.arg2].NameIndex;
                 }
             }
         }
     }
 }
Beispiel #20
0
 public Code(BaseScripter scripter)
 {
     int num;
     this.goto_line = 0;
     this.Terminated = false;
     this.Paused = false;
     this.curr_stack_count = 0;
     this.debugging = true;
     this.scripter = scripter;
     this.symbol_table = scripter.symbol_table;
     this.Operators = new StringList(true);
     this.OP_DUMMY = -this.Operators.Add("DUMMY");
     this.OP_UPCASE_ON = -this.Operators.Add("UPCASE ON");
     this.OP_UPCASE_OFF = -this.Operators.Add("UPCASE OFF");
     this.OP_EXPLICIT_ON = -this.Operators.Add("EXPLICIT ON");
     this.OP_EXPLICIT_OFF = -this.Operators.Add("EXPLICIT OFF");
     this.OP_STRICT_ON = -this.Operators.Add("STRICT ON");
     this.OP_STRICT_OFF = -this.Operators.Add("STRICT OFF");
     this.OP_HALT = -this.Operators.Add("HALT");
     this.OP_PRINT = -this.Operators.Add("PRINT");
     this.OP_SEPARATOR = -this.Operators.Add("SEP");
     this.OP_DEFINE = -this.Operators.Add("DEFINE");
     this.OP_UNDEF = -this.Operators.Add("UNDEF");
     this.OP_START_REGION = -this.Operators.Add("START REGION");
     this.OP_END_REGION = -this.Operators.Add("END REGION");
     this.OP_BEGIN_MODULE = -this.Operators.Add("BEGIN MODULE");
     this.OP_END_MODULE = -this.Operators.Add("END MODULE");
     this.OP_ASSIGN_TYPE = -this.Operators.Add("ASSIGN TYPE");
     this.OP_ASSIGN_COND_TYPE = -this.Operators.Add("ASSIGN COND TYPE");
     this.OP_CREATE_REF_TYPE = -this.Operators.Add("CREATE REF TYPE");
     this.OP_SET_REF_TYPE = -this.Operators.Add("SET REF TYPE");
     this.OP_CREATE_NAMESPACE = -this.Operators.Add("CREATE NAMESPACE");
     this.OP_CREATE_CLASS = -this.Operators.Add("CREATE CLASS");
     this.OP_END_CLASS = -this.Operators.Add("END CLASS");
     this.OP_CREATE_FIELD = -this.Operators.Add("CREATE FIELD");
     this.OP_CREATE_PROPERTY = -this.Operators.Add("CREATE PROPERTY");
     this.OP_CREATE_EVENT = -this.Operators.Add("CREATE EVENT");
     this.OP_BEGIN_USING = -this.Operators.Add("BEGIN USING");
     this.OP_END_USING = -this.Operators.Add("END USING");
     this.OP_CREATE_USING_ALIAS = -this.Operators.Add("CREATE USING ALIAS");
     this.OP_CREATE_TYPE_REFERENCE = -this.Operators.Add("CREATE TYPE REFERENCE");
     this.OP_ADD_MODIFIER = -this.Operators.Add("ADD MODIFIER");
     this.OP_ADD_ANCESTOR = -this.Operators.Add("ADD ANCESTOR");
     this.OP_ADD_UNDERLYING_TYPE = -this.Operators.Add("ADD UNDERLYING TYPE");
     this.OP_ADD_READ_ACCESSOR = -this.Operators.Add("ADD READ ACCESSOR");
     this.OP_ADD_WRITE_ACCESSOR = -this.Operators.Add("ADD WRITE ACCESSOR");
     this.OP_SET_DEFAULT = -this.Operators.Add("SET DEFAULT");
     this.OP_ADD_ADD_ACCESSOR = -this.Operators.Add("ADD ADD ACCESSOR");
     this.OP_ADD_REMOVE_ACCESSOR = -this.Operators.Add("ADD REMOVE ACCESSOR");
     this.OP_ADD_PATTERN = -this.Operators.Add("ADD PATTERN");
     this.OP_ADD_IMPLEMENTS = -this.Operators.Add("ADD IMPLEMENTS");
     this.OP_ADD_HANDLES = -this.Operators.Add("ADD HANDLES");
     this.OP_BEGIN_CALL = -this.Operators.Add("BEGIN CALL");
     this.OP_EVAL = -this.Operators.Add("EVAL");
     this.OP_EVAL_TYPE = -this.Operators.Add("EVAL TYPE");
     this.OP_EVAL_BASE_TYPE = -this.Operators.Add("EVAL BASE TYPE");
     this.OP_ASSIGN_NAME = -this.Operators.Add("ASSIGN NAME");
     this.OP_ADD_MIN_VALUE = -this.Operators.Add("ADD MIN VALUE");
     this.OP_ADD_MAX_VALUE = -this.Operators.Add("ADD MAX VALUE");
     this.OP_ADD_ARRAY_RANGE = -this.Operators.Add("ADD ARRAY RANGE");
     this.OP_ADD_ARRAY_INDEX = -this.Operators.Add("ADD ARRAY INDEX");
     this.OP_CREATE_METHOD = -this.Operators.Add("CREATE METHOD");
     this.OP_INIT_METHOD = -this.Operators.Add("INIT METHOD");
     this.OP_END_METHOD = -this.Operators.Add("END METHOD");
     this.OP_ADD_PARAM = -this.Operators.Add("ADD PARAM");
     this.OP_ADD_PARAMS = -this.Operators.Add("ADD PARAMS");
     this.OP_ADD_DEFAULT_VALUE = -this.Operators.Add("ADD DEFAULT VALUE");
     this.OP_DECLARE_LOCAL_VARIABLE = -this.Operators.Add("DECLARE LOCAL VARIABLE");
     this.OP_DECLARE_LOCAL_VARIABLE_RUNTIME = -this.Operators.Add("DECLARE LOCAL VARIABLE RUNTIME");
     this.OP_DECLARE_LOCAL_SIMPLE = -this.Operators.Add("DECLARE LOCAL SIMPLE");
     this.OP_ADD_EXPLICIT_INTERFACE = -this.Operators.Add("ADD EXPLICIT INTERFACE");
     this.OP_ADD_EVENT_FIELD = -this.Operators.Add("ADD EVENT FIELD");
     this.OP_CALL_BASE = -this.Operators.Add("CALL BASE");
     this.OP_CALL_SIMPLE = -this.Operators.Add("CALL SIMPLE");
     this.OP_CHECK_STRUCT_CONSTRUCTOR = -this.Operators.Add("CHECK STRUCT CONSTRUCTOR");
     this.OP_INSERT_STRUCT_CONSTRUCTORS = -this.Operators.Add("INSERT STRUCT CONSTRUCTORS");
     this.OP_NOP = -this.Operators.Add("NOP");
     this.OP_INIT_STATIC_VAR = -this.Operators.Add("INIT STATIC VAR");
     this.OP_LABEL = -this.Operators.Add("LABEL");
     this.OP_ASSIGN = -this.Operators.Add("=");
     this.OP_ASSIGN_STRUCT = -this.Operators.Add("= (struct)");
     this.OP_BITWISE_AND = -this.Operators.Add("&");
     this.OP_BITWISE_XOR = -this.Operators.Add("^");
     this.OP_BITWISE_OR = -this.Operators.Add("|");
     this.OP_LOGICAL_OR = -this.Operators.Add("||");
     this.OP_LOGICAL_AND = -this.Operators.Add("&&");
     this.OP_PLUS = -this.Operators.Add("+");
     this.OP_INC = -this.Operators.Add("++");
     this.OP_MINUS = -this.Operators.Add("-");
     this.OP_DEC = -this.Operators.Add("--");
     this.OP_MULT = -this.Operators.Add("*");
     this.OP_EXPONENT = -this.Operators.Add("EXP");
     this.OP_MOD = -this.Operators.Add("%");
     this.OP_DIV = -this.Operators.Add("-");
     this.OP_EQ = -this.Operators.Add("==");
     this.OP_NE = -this.Operators.Add("<>");
     this.OP_GT = -this.Operators.Add(">");
     this.OP_LT = -this.Operators.Add("<");
     this.OP_GE = -this.Operators.Add(">=");
     this.OP_LE = -this.Operators.Add("<=");
     this.OP_IS = -this.Operators.Add("is");
     this.OP_AS = -this.Operators.Add("as");
     this.OP_LEFT_SHIFT = -this.Operators.Add("<<");
     this.OP_RIGHT_SHIFT = -this.Operators.Add(">>");
     this.OP_UNARY_PLUS = -this.Operators.Add("+ (unary)");
     this.OP_UNARY_MINUS = -this.Operators.Add("- (unary)");
     this.OP_NOT = -this.Operators.Add("not");
     this.OP_COMPLEMENT = -this.Operators.Add("~");
     this.OP_TRUE = -this.Operators.Add("true");
     this.OP_FALSE = -this.Operators.Add("false");
     this.OP_GO = -this.Operators.Add("GO");
     this.OP_GO_FALSE = -this.Operators.Add("GO FALSE");
     this.OP_GO_TRUE = -this.Operators.Add("GO TRUE");
     this.OP_GO_NULL = -this.Operators.Add("GO NULL");
     this.OP_GOTO_START = -this.Operators.Add("GOTO START");
     this.OP_GOTO_CONTINUE = -this.Operators.Add("GOTO CONTINUE");
     this.OP_TRY_ON = -this.Operators.Add("TRY ON");
     this.OP_TRY_OFF = -this.Operators.Add("TRY OFF");
     this.OP_THROW = -this.Operators.Add("THROW");
     this.OP_CATCH = -this.Operators.Add("CATCH");
     this.OP_FINALLY = -this.Operators.Add("FINALLY");
     this.OP_DISCARD_ERROR = -this.Operators.Add("DISCARD ERROR");
     this.OP_EXIT_ON_ERROR = -this.Operators.Add("EXIT ON ERROR");
     this.OP_ONERROR = -this.Operators.Add("ON ERROR");
     this.OP_RESUME = -this.Operators.Add("RESUME");
     this.OP_RESUME_NEXT = -this.Operators.Add("RESUME NEXT");
     this.OP_CREATE_ARRAY_INSTANCE = -this.Operators.Add("CREATE ARRAY INSTANCE");
     this.OP_CREATE_OBJECT = -this.Operators.Add("CREATE OBJECT");
     this.OP_CREATE_REFERENCE = -this.Operators.Add("CREATE REFERENCE");
     this.OP_SETUP_DELEGATE = -this.Operators.Add("SETUP DELEGATE");
     this.OP_ADD_DELEGATES = -this.Operators.Add("ADD DELEGATES");
     this.OP_SUB_DELEGATES = -this.Operators.Add("SUB DELEGATES");
     this.OP_EQ_DELEGATES = -this.Operators.Add("EQ DELEGATES");
     this.OP_NE_DELEGATES = -this.Operators.Add("NE DELEGATES");
     this.OP_ADDRESS_OF = -this.Operators.Add("ADDRESS OF");
     this.OP_CREATE_INDEX_OBJECT = -this.Operators.Add("CREATE INDEX OBJECT");
     this.OP_ADD_INDEX = -this.Operators.Add("ADD INDEX");
     this.OP_SETUP_INDEX_OBJECT = -this.Operators.Add("SETUP INDEX OBJECT");
     this.OP_PUSH = -this.Operators.Add("PUSH");
     this.OP_CALL = -this.Operators.Add("CALL");
     this.OP_CALL_VIRT = -this.Operators.Add("CALL VIRT");
     this.OP_DYNAMIC_INVOKE = -this.Operators.Add("DYNAMIC INVOKE");
     this.OP_CALL_ADD_EVENT = -this.Operators.Add("CALL ADD EVENT");
     this.OP_RAISE_EVENT = -this.Operators.Add("RAISE EVENT");
     this.OP_FIND_FIRST_DELEGATE = -this.Operators.Add("FIND FIRST DELEGATE");
     this.OP_FIND_NEXT_DELEGATE = -this.Operators.Add("FIND NEXT DELEGATE");
     this.OP_RET = -this.Operators.Add("RET");
     this.OP_EXIT_SUB = -this.Operators.Add("EXIT SUB");
     this.OP_GET_PARAM_VALUE = -this.Operators.Add("GET PARAM VALUE");
     this.OP_CHECKED = -this.Operators.Add("CHECKED");
     this.OP_RESTORE_CHECKED_STATE = -this.Operators.Add("RESTORE CHECKED STATE");
     this.OP_DISPOSE = -this.Operators.Add("DISPOSE");
     this.OP_TYPEOF = -this.Operators.Add("TYPEOF");
     this.OP_LOCK = -this.Operators.Add("LOCK");
     this.OP_UNLOCK = -this.Operators.Add("UNLOCK");
     this.OP_CAST = -this.Operators.Add("CAST");
     this.OP_TO_SBYTE = -this.Operators.Add("TO SBYTE");
     this.OP_TO_BYTE = -this.Operators.Add("TO BYTE");
     this.OP_TO_USHORT = -this.Operators.Add("TO USHORT");
     this.OP_TO_SHORT = -this.Operators.Add("TO SHORT");
     this.OP_TO_UINT = -this.Operators.Add("TO UINT");
     this.OP_TO_INT = -this.Operators.Add("TO INT");
     this.OP_TO_ULONG = -this.Operators.Add("TO ULONG");
     this.OP_TO_LONG = -this.Operators.Add("TO LONG");
     this.OP_TO_CHAR = -this.Operators.Add("TO CHAR");
     this.OP_TO_FLOAT = -this.Operators.Add("TO FLOAT");
     this.OP_TO_DOUBLE = -this.Operators.Add("TO DOUBLE");
     this.OP_TO_DECIMAL = -this.Operators.Add("TO DECIMAL");
     this.OP_TO_STRING = -this.Operators.Add("TO STRING");
     this.OP_TO_BOOLEAN = -this.Operators.Add("TO BOOLEAN");
     this.OP_TO_ENUM = -this.Operators.Add("TO ENUM");
     this.OP_TO_CHAR_ARRAY = -this.Operators.Add("TO CHAR[]");
     this.OP_NEGATION_INT = -this.Operators.Add("-(unary int)");
     this.OP_NEGATION_LONG = -this.Operators.Add("-(unary long)");
     this.OP_NEGATION_FLOAT = -this.Operators.Add("-(unary float)");
     this.OP_NEGATION_DOUBLE = -this.Operators.Add("-(unary double)");
     this.OP_NEGATION_DECIMAL = -this.Operators.Add("-(unary decimal)");
     this.OP_LOGICAL_NEGATION_BOOL = -this.Operators.Add("!(bool)");
     this.OP_BITWISE_COMPLEMENT_INT = -this.Operators.Add("~(int)");
     this.OP_BITWISE_COMPLEMENT_UINT = -this.Operators.Add("~(uint)");
     this.OP_BITWISE_COMPLEMENT_LONG = -this.Operators.Add("~(long)");
     this.OP_BITWISE_COMPLEMENT_ULONG = -this.Operators.Add("~(ulong)");
     this.OP_INC_SBYTE = -this.Operators.Add("++(sbyte)");
     this.OP_INC_BYTE = -this.Operators.Add("++(byte)");
     this.OP_INC_SHORT = -this.Operators.Add("++(short)");
     this.OP_INC_USHORT = -this.Operators.Add("++(ushort)");
     this.OP_INC_INT = -this.Operators.Add("++(int)");
     this.OP_INC_UINT = -this.Operators.Add("++(uint)");
     this.OP_INC_LONG = -this.Operators.Add("++(long)");
     this.OP_INC_ULONG = -this.Operators.Add("++(ulong)");
     this.OP_INC_CHAR = -this.Operators.Add("++(char)");
     this.OP_INC_FLOAT = -this.Operators.Add("++(float)");
     this.OP_INC_DOUBLE = -this.Operators.Add("++(double)");
     this.OP_INC_DECIMAL = -this.Operators.Add("++(decimal)");
     this.OP_DEC_SBYTE = -this.Operators.Add("--(sbyte)");
     this.OP_DEC_BYTE = -this.Operators.Add("--(byte)");
     this.OP_DEC_SHORT = -this.Operators.Add("--(short)");
     this.OP_DEC_USHORT = -this.Operators.Add("--(ushort)");
     this.OP_DEC_INT = -this.Operators.Add("--(int)");
     this.OP_DEC_UINT = -this.Operators.Add("--(uint)");
     this.OP_DEC_LONG = -this.Operators.Add("--(long)");
     this.OP_DEC_ULONG = -this.Operators.Add("--(ulong)");
     this.OP_DEC_CHAR = -this.Operators.Add("--(char)");
     this.OP_DEC_FLOAT = -this.Operators.Add("--(float)");
     this.OP_DEC_DOUBLE = -this.Operators.Add("--(double)");
     this.OP_DEC_DECIMAL = -this.Operators.Add("--(decimal)");
     this.OP_ADDITION_INT = -this.Operators.Add("+(int)");
     this.OP_ADDITION_UINT = -this.Operators.Add("+(uint)");
     this.OP_ADDITION_LONG = -this.Operators.Add("+(long)");
     this.OP_ADDITION_ULONG = -this.Operators.Add("+(ulong)");
     this.OP_ADDITION_FLOAT = -this.Operators.Add("+(float)");
     this.OP_ADDITION_DOUBLE = -this.Operators.Add("+(double)");
     this.OP_ADDITION_DECIMAL = -this.Operators.Add("+(decimal)");
     this.OP_ADDITION_STRING = -this.Operators.Add("+(string)");
     this.OP_SUBTRACTION_INT = -this.Operators.Add("-(int)");
     this.OP_SUBTRACTION_UINT = -this.Operators.Add("-(uint)");
     this.OP_SUBTRACTION_LONG = -this.Operators.Add("-(long)");
     this.OP_SUBTRACTION_ULONG = -this.Operators.Add("-(ulong)");
     this.OP_SUBTRACTION_FLOAT = -this.Operators.Add("-(float)");
     this.OP_SUBTRACTION_DOUBLE = -this.Operators.Add("-(double)");
     this.OP_SUBTRACTION_DECIMAL = -this.Operators.Add("-(decimal)");
     this.OP_MULTIPLICATION_INT = -this.Operators.Add("*(int)");
     this.OP_MULTIPLICATION_UINT = -this.Operators.Add("*(uint)");
     this.OP_MULTIPLICATION_LONG = -this.Operators.Add("*(long)");
     this.OP_MULTIPLICATION_ULONG = -this.Operators.Add("*(ulong)");
     this.OP_MULTIPLICATION_FLOAT = -this.Operators.Add("*(float)");
     this.OP_MULTIPLICATION_DOUBLE = -this.Operators.Add("*(double)");
     this.OP_MULTIPLICATION_DECIMAL = -this.Operators.Add("*(decimal)");
     this.OP_EXPONENT_INT = -this.Operators.Add("EXPONENT(int)");
     this.OP_EXPONENT_UINT = -this.Operators.Add("EXPONENT(uint)");
     this.OP_EXPONENT_LONG = -this.Operators.Add("EXPONENT(long)");
     this.OP_EXPONENT_ULONG = -this.Operators.Add("EXPONENT(ulong)");
     this.OP_EXPONENT_FLOAT = -this.Operators.Add("EXPONENT(float)");
     this.OP_EXPONENT_DOUBLE = -this.Operators.Add("EXPONENT(double)");
     this.OP_EXPONENT_DECIMAL = -this.Operators.Add("EXPONENT(decimal)");
     this.OP_DIVISION_INT = -this.Operators.Add("/(int)");
     this.OP_DIVISION_UINT = -this.Operators.Add("/(uint)");
     this.OP_DIVISION_LONG = -this.Operators.Add("/(long)");
     this.OP_DIVISION_ULONG = -this.Operators.Add("/(ulong)");
     this.OP_DIVISION_FLOAT = -this.Operators.Add("/(float)");
     this.OP_DIVISION_DOUBLE = -this.Operators.Add("/(double)");
     this.OP_DIVISION_DECIMAL = -this.Operators.Add("/(decimal)");
     this.OP_REMAINDER_INT = -this.Operators.Add("%(int)");
     this.OP_REMAINDER_UINT = -this.Operators.Add("%(uint)");
     this.OP_REMAINDER_LONG = -this.Operators.Add("%(long)");
     this.OP_REMAINDER_ULONG = -this.Operators.Add("%(ulong)");
     this.OP_REMAINDER_FLOAT = -this.Operators.Add("%(float)");
     this.OP_REMAINDER_DOUBLE = -this.Operators.Add("%(double)");
     this.OP_REMAINDER_DECIMAL = -this.Operators.Add("%(decimal)");
     this.OP_LEFT_SHIFT_INT = -this.Operators.Add("<<(int)");
     this.OP_LEFT_SHIFT_UINT = -this.Operators.Add("<<(uint)");
     this.OP_LEFT_SHIFT_LONG = -this.Operators.Add("<<(long)");
     this.OP_LEFT_SHIFT_ULONG = -this.Operators.Add("<<(ulong)");
     this.OP_RIGHT_SHIFT_INT = -this.Operators.Add(">>(int)");
     this.OP_RIGHT_SHIFT_UINT = -this.Operators.Add(">>(uint)");
     this.OP_RIGHT_SHIFT_LONG = -this.Operators.Add(">>(long)");
     this.OP_RIGHT_SHIFT_ULONG = -this.Operators.Add(">>(ulong)");
     this.OP_BITWISE_AND_INT = -this.Operators.Add("&(int)");
     this.OP_BITWISE_AND_UINT = -this.Operators.Add("&(uint)");
     this.OP_BITWISE_AND_LONG = -this.Operators.Add("&(long)");
     this.OP_BITWISE_AND_ULONG = -this.Operators.Add("&(ulong)");
     this.OP_BITWISE_AND_BOOL = -this.Operators.Add("&(bool)");
     this.OP_BITWISE_OR_INT = -this.Operators.Add("|(int)");
     this.OP_BITWISE_OR_UINT = -this.Operators.Add("|(uint)");
     this.OP_BITWISE_OR_LONG = -this.Operators.Add("|(long)");
     this.OP_BITWISE_OR_ULONG = -this.Operators.Add("|(ulong)");
     this.OP_BITWISE_OR_BOOL = -this.Operators.Add("|(bool)");
     this.OP_BITWISE_XOR_INT = -this.Operators.Add("^(int)");
     this.OP_BITWISE_XOR_UINT = -this.Operators.Add("^(uint)");
     this.OP_BITWISE_XOR_LONG = -this.Operators.Add("^(long)");
     this.OP_BITWISE_XOR_ULONG = -this.Operators.Add("^(ulong)");
     this.OP_BITWISE_XOR_BOOL = -this.Operators.Add("^(bool)");
     this.OP_LT_INT = -this.Operators.Add("<(int)");
     this.OP_LT_UINT = -this.Operators.Add("<(uint)");
     this.OP_LT_LONG = -this.Operators.Add("<(long)");
     this.OP_LT_ULONG = -this.Operators.Add("<(ulong)");
     this.OP_LT_FLOAT = -this.Operators.Add("<(float)");
     this.OP_LT_DOUBLE = -this.Operators.Add("<(double)");
     this.OP_LT_DECIMAL = -this.Operators.Add("<(decimal)");
     this.OP_LT_STRING = -this.Operators.Add("<(string)");
     this.OP_LE_INT = -this.Operators.Add("<=(int)");
     this.OP_LE_UINT = -this.Operators.Add("<=(uint)");
     this.OP_LE_LONG = -this.Operators.Add("<=(long)");
     this.OP_LE_ULONG = -this.Operators.Add("<=(ulong)");
     this.OP_LE_FLOAT = -this.Operators.Add("<=(float)");
     this.OP_LE_DOUBLE = -this.Operators.Add("<=(double)");
     this.OP_LE_DECIMAL = -this.Operators.Add("<=(decimal)");
     this.OP_LE_STRING = -this.Operators.Add("<=(string)");
     this.OP_GT_INT = -this.Operators.Add(">(int)");
     this.OP_GT_UINT = -this.Operators.Add(">(uint)");
     this.OP_GT_LONG = -this.Operators.Add(">(long)");
     this.OP_GT_ULONG = -this.Operators.Add(">(ulong)");
     this.OP_GT_FLOAT = -this.Operators.Add(">(float)");
     this.OP_GT_DOUBLE = -this.Operators.Add(">(double)");
     this.OP_GT_DECIMAL = -this.Operators.Add(">(decimal)");
     this.OP_GT_STRING = -this.Operators.Add(">(string)");
     this.OP_GE_INT = -this.Operators.Add(">=(int)");
     this.OP_GE_UINT = -this.Operators.Add(">=(uint)");
     this.OP_GE_LONG = -this.Operators.Add(">=(long)");
     this.OP_GE_ULONG = -this.Operators.Add(">=(ulong)");
     this.OP_GE_FLOAT = -this.Operators.Add(">=(float)");
     this.OP_GE_DOUBLE = -this.Operators.Add(">=(double)");
     this.OP_GE_DECIMAL = -this.Operators.Add(">=(decimal)");
     this.OP_GE_STRING = -this.Operators.Add(">=(string)");
     this.OP_EQ_INT = -this.Operators.Add("==(int)");
     this.OP_EQ_UINT = -this.Operators.Add("==(uint)");
     this.OP_EQ_LONG = -this.Operators.Add("==(long)");
     this.OP_EQ_ULONG = -this.Operators.Add("==(ulong)");
     this.OP_EQ_FLOAT = -this.Operators.Add("==(float)");
     this.OP_EQ_DOUBLE = -this.Operators.Add("==(double)");
     this.OP_EQ_DECIMAL = -this.Operators.Add("==(decimal)");
     this.OP_EQ_STRING = -this.Operators.Add("==(string)");
     this.OP_EQ_BOOL = -this.Operators.Add("==(bool)");
     this.OP_EQ_OBJECT = -this.Operators.Add("==(object)");
     this.OP_NE_INT = -this.Operators.Add("!=(int)");
     this.OP_NE_UINT = -this.Operators.Add("!=(uint)");
     this.OP_NE_LONG = -this.Operators.Add("!=(long)");
     this.OP_NE_ULONG = -this.Operators.Add("!=(ulong)");
     this.OP_NE_FLOAT = -this.Operators.Add("!=(float)");
     this.OP_NE_DOUBLE = -this.Operators.Add("!=(double)");
     this.OP_NE_DECIMAL = -this.Operators.Add("!=(decimal)");
     this.OP_NE_STRING = -this.Operators.Add("!=(string)");
     this.OP_NE_BOOL = -this.Operators.Add("!=(bool)");
     this.OP_NE_OBJECT = -this.Operators.Add("!=(object)");
     this.OP_SWAPPED_ARGUMENTS = -this.Operators.Add("SWAPPED ARG");
     this.overloadable_unary_operators_str = new Hashtable();
     this.overloadable_unary_operators_str.Add(this.OP_UNARY_PLUS, "op_UnaryPlus");
     this.overloadable_unary_operators_str.Add(this.OP_UNARY_MINUS, "op_UnaryNegation");
     this.overloadable_unary_operators_str.Add(this.OP_NOT, "op_LogicalNot");
     this.overloadable_unary_operators_str.Add(this.OP_COMPLEMENT, "op_OnesComplement");
     this.overloadable_unary_operators_str.Add(this.OP_INC, "op_Increment");
     this.overloadable_unary_operators_str.Add(this.OP_DEC, "op_Decrement");
     this.overloadable_unary_operators_str.Add(this.OP_TRUE, "op_True");
     this.overloadable_unary_operators_str.Add(this.OP_FALSE, "op_False");
     this.overloadable_binary_operators_str = new Hashtable();
     this.overloadable_binary_operators_str.Add(this.OP_PLUS, "op_Addition");
     this.overloadable_binary_operators_str.Add(this.OP_MINUS, "op_Subtraction");
     this.overloadable_binary_operators_str.Add(this.OP_MULT, "op_Multiply");
     this.overloadable_binary_operators_str.Add(this.OP_DIV, "op_Division");
     this.overloadable_binary_operators_str.Add(this.OP_MOD, "op_Modulus");
     this.overloadable_binary_operators_str.Add(this.OP_BITWISE_AND, "op_BitwiseAnd");
     this.overloadable_binary_operators_str.Add(this.OP_BITWISE_OR, "op_BitwiseOr");
     this.overloadable_binary_operators_str.Add(this.OP_BITWISE_XOR, "op_ExclusiveOr");
     this.overloadable_binary_operators_str.Add(this.OP_LEFT_SHIFT, "op_LeftShift");
     this.overloadable_binary_operators_str.Add(this.OP_RIGHT_SHIFT, "op_RightShift");
     this.overloadable_binary_operators_str.Add(this.OP_EQ, "op_Equality");
     this.overloadable_binary_operators_str.Add(this.OP_NE, "op_Inequality");
     this.overloadable_binary_operators_str.Add(this.OP_GT, "op_GreaterThan");
     this.overloadable_binary_operators_str.Add(this.OP_LT, "op_LessThan");
     this.overloadable_binary_operators_str.Add(this.OP_GE, "op_GreaterThanOrEqual");
     this.overloadable_binary_operators_str.Add(this.OP_LE, "op_LessThanOrEqual");
     this.detailed_operators = new Contact_Integers(200);
     this.detailed_negation_operators = new Contact_Integers(5);
     this.detailed_negation_operators.Add(8, this.OP_NEGATION_INT);
     this.detailed_negation_operators.Add(9, this.OP_NEGATION_LONG);
     this.detailed_negation_operators.Add(7, this.OP_NEGATION_FLOAT);
     this.detailed_negation_operators.Add(6, this.OP_NEGATION_DOUBLE);
     this.detailed_negation_operators.Add(5, this.OP_NEGATION_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_negation_operators);
     this.detailed_logical_negation_operators = new Contact_Integers(1);
     this.detailed_logical_negation_operators.Add(2, this.OP_LOGICAL_NEGATION_BOOL);
     this.detailed_operators.AddFrom(this.detailed_logical_negation_operators);
     this.detailed_bitwise_complement_operators = new Contact_Integers(4);
     this.detailed_bitwise_complement_operators.Add(8, this.OP_BITWISE_COMPLEMENT_INT);
     this.detailed_bitwise_complement_operators.Add(13, this.OP_BITWISE_COMPLEMENT_UINT);
     this.detailed_bitwise_complement_operators.Add(9, this.OP_BITWISE_COMPLEMENT_LONG);
     this.detailed_bitwise_complement_operators.Add(14, this.OP_BITWISE_COMPLEMENT_ULONG);
     this.detailed_operators.AddFrom(this.detailed_bitwise_complement_operators);
     this.detailed_inc_operators = new Contact_Integers(12);
     this.detailed_inc_operators.Add(10, this.OP_INC_SBYTE);
     this.detailed_inc_operators.Add(3, this.OP_INC_BYTE);
     this.detailed_inc_operators.Add(11, this.OP_INC_SHORT);
     this.detailed_inc_operators.Add(15, this.OP_INC_USHORT);
     this.detailed_inc_operators.Add(8, this.OP_INC_INT);
     this.detailed_inc_operators.Add(13, this.OP_INC_UINT);
     this.detailed_inc_operators.Add(9, this.OP_INC_LONG);
     this.detailed_inc_operators.Add(14, this.OP_INC_ULONG);
     this.detailed_inc_operators.Add(4, this.OP_INC_CHAR);
     this.detailed_inc_operators.Add(7, this.OP_INC_FLOAT);
     this.detailed_inc_operators.Add(6, this.OP_INC_DOUBLE);
     this.detailed_inc_operators.Add(5, this.OP_INC_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_inc_operators);
     this.detailed_dec_operators = new Contact_Integers(12);
     this.detailed_dec_operators.Add(10, this.OP_DEC_SBYTE);
     this.detailed_dec_operators.Add(3, this.OP_DEC_BYTE);
     this.detailed_dec_operators.Add(11, this.OP_DEC_SHORT);
     this.detailed_dec_operators.Add(15, this.OP_DEC_USHORT);
     this.detailed_dec_operators.Add(8, this.OP_DEC_INT);
     this.detailed_dec_operators.Add(13, this.OP_DEC_UINT);
     this.detailed_dec_operators.Add(9, this.OP_DEC_LONG);
     this.detailed_dec_operators.Add(14, this.OP_DEC_ULONG);
     this.detailed_dec_operators.Add(4, this.OP_DEC_CHAR);
     this.detailed_dec_operators.Add(7, this.OP_DEC_FLOAT);
     this.detailed_dec_operators.Add(6, this.OP_DEC_DOUBLE);
     this.detailed_dec_operators.Add(5, this.OP_DEC_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_dec_operators);
     this.detailed_addition_operators = new Contact_Integers(8);
     this.detailed_addition_operators.Add(8, this.OP_ADDITION_INT);
     this.detailed_addition_operators.Add(13, this.OP_ADDITION_UINT);
     this.detailed_addition_operators.Add(9, this.OP_ADDITION_LONG);
     this.detailed_addition_operators.Add(14, this.OP_ADDITION_ULONG);
     this.detailed_addition_operators.Add(7, this.OP_ADDITION_FLOAT);
     this.detailed_addition_operators.Add(6, this.OP_ADDITION_DOUBLE);
     this.detailed_addition_operators.Add(5, this.OP_ADDITION_DECIMAL);
     this.detailed_addition_operators.Add(12, this.OP_ADDITION_STRING);
     this.detailed_operators.AddFrom(this.detailed_addition_operators);
     this.detailed_subtraction_operators = new Contact_Integers(7);
     this.detailed_subtraction_operators.Add(8, this.OP_SUBTRACTION_INT);
     this.detailed_subtraction_operators.Add(13, this.OP_SUBTRACTION_UINT);
     this.detailed_subtraction_operators.Add(9, this.OP_SUBTRACTION_LONG);
     this.detailed_subtraction_operators.Add(14, this.OP_SUBTRACTION_ULONG);
     this.detailed_subtraction_operators.Add(7, this.OP_SUBTRACTION_FLOAT);
     this.detailed_subtraction_operators.Add(6, this.OP_SUBTRACTION_DOUBLE);
     this.detailed_subtraction_operators.Add(5, this.OP_SUBTRACTION_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_subtraction_operators);
     this.detailed_multiplication_operators = new Contact_Integers(7);
     this.detailed_multiplication_operators.Add(8, this.OP_MULTIPLICATION_INT);
     this.detailed_multiplication_operators.Add(13, this.OP_MULTIPLICATION_UINT);
     this.detailed_multiplication_operators.Add(9, this.OP_MULTIPLICATION_LONG);
     this.detailed_multiplication_operators.Add(14, this.OP_MULTIPLICATION_ULONG);
     this.detailed_multiplication_operators.Add(7, this.OP_MULTIPLICATION_FLOAT);
     this.detailed_multiplication_operators.Add(6, this.OP_MULTIPLICATION_DOUBLE);
     this.detailed_multiplication_operators.Add(5, this.OP_MULTIPLICATION_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_multiplication_operators);
     this.detailed_exponent_operators = new Contact_Integers(7);
     this.detailed_exponent_operators.Add(8, this.OP_EXPONENT_INT);
     this.detailed_exponent_operators.Add(13, this.OP_EXPONENT_UINT);
     this.detailed_exponent_operators.Add(9, this.OP_EXPONENT_LONG);
     this.detailed_exponent_operators.Add(14, this.OP_EXPONENT_ULONG);
     this.detailed_exponent_operators.Add(7, this.OP_EXPONENT_FLOAT);
     this.detailed_exponent_operators.Add(6, this.OP_EXPONENT_DOUBLE);
     this.detailed_exponent_operators.Add(5, this.OP_EXPONENT_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_exponent_operators);
     this.detailed_division_operators = new Contact_Integers(7);
     this.detailed_division_operators.Add(8, this.OP_DIVISION_INT);
     this.detailed_division_operators.Add(13, this.OP_DIVISION_UINT);
     this.detailed_division_operators.Add(9, this.OP_DIVISION_LONG);
     this.detailed_division_operators.Add(14, this.OP_DIVISION_ULONG);
     this.detailed_division_operators.Add(7, this.OP_DIVISION_FLOAT);
     this.detailed_division_operators.Add(6, this.OP_DIVISION_DOUBLE);
     this.detailed_division_operators.Add(5, this.OP_DIVISION_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_division_operators);
     this.detailed_remainder_operators = new Contact_Integers(7);
     this.detailed_remainder_operators.Add(8, this.OP_REMAINDER_INT);
     this.detailed_remainder_operators.Add(13, this.OP_REMAINDER_UINT);
     this.detailed_remainder_operators.Add(9, this.OP_REMAINDER_LONG);
     this.detailed_remainder_operators.Add(14, this.OP_REMAINDER_ULONG);
     this.detailed_remainder_operators.Add(7, this.OP_REMAINDER_FLOAT);
     this.detailed_remainder_operators.Add(6, this.OP_REMAINDER_DOUBLE);
     this.detailed_remainder_operators.Add(5, this.OP_REMAINDER_DECIMAL);
     this.detailed_operators.AddFrom(this.detailed_remainder_operators);
     this.detailed_left_shift_operators = new Contact_Integers(4);
     this.detailed_left_shift_operators.Add(8, this.OP_LEFT_SHIFT_INT);
     this.detailed_left_shift_operators.Add(13, this.OP_LEFT_SHIFT_UINT);
     this.detailed_left_shift_operators.Add(9, this.OP_LEFT_SHIFT_LONG);
     this.detailed_left_shift_operators.Add(14, this.OP_LEFT_SHIFT_ULONG);
     this.detailed_operators.AddFrom(this.detailed_left_shift_operators);
     this.detailed_right_shift_operators = new Contact_Integers(4);
     this.detailed_right_shift_operators.Add(8, this.OP_RIGHT_SHIFT_INT);
     this.detailed_right_shift_operators.Add(13, this.OP_RIGHT_SHIFT_UINT);
     this.detailed_right_shift_operators.Add(9, this.OP_RIGHT_SHIFT_LONG);
     this.detailed_right_shift_operators.Add(14, this.OP_RIGHT_SHIFT_ULONG);
     this.detailed_operators.AddFrom(this.detailed_right_shift_operators);
     this.detailed_bitwise_and_operators = new Contact_Integers(5);
     this.detailed_bitwise_and_operators.Add(8, this.OP_BITWISE_AND_INT);
     this.detailed_bitwise_and_operators.Add(13, this.OP_BITWISE_AND_UINT);
     this.detailed_bitwise_and_operators.Add(9, this.OP_BITWISE_AND_LONG);
     this.detailed_bitwise_and_operators.Add(14, this.OP_BITWISE_AND_ULONG);
     this.detailed_bitwise_and_operators.Add(2, this.OP_BITWISE_AND_BOOL);
     this.detailed_operators.AddFrom(this.detailed_bitwise_and_operators);
     this.detailed_bitwise_or_operators = new Contact_Integers(5);
     this.detailed_bitwise_or_operators.Add(8, this.OP_BITWISE_OR_INT);
     this.detailed_bitwise_or_operators.Add(13, this.OP_BITWISE_OR_UINT);
     this.detailed_bitwise_or_operators.Add(9, this.OP_BITWISE_OR_LONG);
     this.detailed_bitwise_or_operators.Add(14, this.OP_BITWISE_OR_ULONG);
     this.detailed_bitwise_or_operators.Add(2, this.OP_BITWISE_OR_BOOL);
     this.detailed_operators.AddFrom(this.detailed_bitwise_or_operators);
     this.detailed_bitwise_xor_operators = new Contact_Integers(5);
     this.detailed_bitwise_xor_operators.Add(8, this.OP_BITWISE_XOR_INT);
     this.detailed_bitwise_xor_operators.Add(13, this.OP_BITWISE_XOR_UINT);
     this.detailed_bitwise_xor_operators.Add(9, this.OP_BITWISE_XOR_LONG);
     this.detailed_bitwise_xor_operators.Add(14, this.OP_BITWISE_XOR_ULONG);
     this.detailed_bitwise_xor_operators.Add(2, this.OP_BITWISE_XOR_BOOL);
     this.detailed_operators.AddFrom(this.detailed_bitwise_xor_operators);
     this.detailed_lt_operators = new Contact_Integers(8);
     this.detailed_lt_operators.Add(8, this.OP_LT_INT);
     this.detailed_lt_operators.Add(13, this.OP_LT_UINT);
     this.detailed_lt_operators.Add(9, this.OP_LT_LONG);
     this.detailed_lt_operators.Add(14, this.OP_LT_ULONG);
     this.detailed_lt_operators.Add(7, this.OP_LT_FLOAT);
     this.detailed_lt_operators.Add(6, this.OP_LT_DOUBLE);
     this.detailed_lt_operators.Add(5, this.OP_LT_DECIMAL);
     this.detailed_lt_operators.Add(12, this.OP_LT_STRING);
     this.detailed_operators.AddFrom(this.detailed_lt_operators);
     this.detailed_le_operators = new Contact_Integers(8);
     this.detailed_le_operators.Add(8, this.OP_LE_INT);
     this.detailed_le_operators.Add(13, this.OP_LE_UINT);
     this.detailed_le_operators.Add(9, this.OP_LE_LONG);
     this.detailed_le_operators.Add(14, this.OP_LE_ULONG);
     this.detailed_le_operators.Add(7, this.OP_LE_FLOAT);
     this.detailed_le_operators.Add(6, this.OP_LE_DOUBLE);
     this.detailed_le_operators.Add(5, this.OP_LE_DECIMAL);
     this.detailed_le_operators.Add(12, this.OP_LE_STRING);
     this.detailed_operators.AddFrom(this.detailed_le_operators);
     this.detailed_gt_operators = new Contact_Integers(8);
     this.detailed_gt_operators.Add(8, this.OP_GT_INT);
     this.detailed_gt_operators.Add(13, this.OP_GT_UINT);
     this.detailed_gt_operators.Add(9, this.OP_GT_LONG);
     this.detailed_gt_operators.Add(14, this.OP_GT_ULONG);
     this.detailed_gt_operators.Add(7, this.OP_GT_FLOAT);
     this.detailed_gt_operators.Add(6, this.OP_GT_DOUBLE);
     this.detailed_gt_operators.Add(5, this.OP_GT_DECIMAL);
     this.detailed_gt_operators.Add(12, this.OP_GT_STRING);
     this.detailed_operators.AddFrom(this.detailed_gt_operators);
     this.detailed_ge_operators = new Contact_Integers(8);
     this.detailed_ge_operators.Add(8, this.OP_GE_INT);
     this.detailed_ge_operators.Add(13, this.OP_GE_UINT);
     this.detailed_ge_operators.Add(9, this.OP_GE_LONG);
     this.detailed_ge_operators.Add(14, this.OP_GE_ULONG);
     this.detailed_ge_operators.Add(7, this.OP_GE_FLOAT);
     this.detailed_ge_operators.Add(6, this.OP_GE_DOUBLE);
     this.detailed_ge_operators.Add(5, this.OP_GE_DECIMAL);
     this.detailed_ge_operators.Add(12, this.OP_GE_STRING);
     this.detailed_operators.AddFrom(this.detailed_ge_operators);
     this.detailed_eq_operators = new Contact_Integers(10);
     this.detailed_eq_operators.Add(8, this.OP_EQ_INT);
     this.detailed_eq_operators.Add(13, this.OP_EQ_UINT);
     this.detailed_eq_operators.Add(9, this.OP_EQ_LONG);
     this.detailed_eq_operators.Add(14, this.OP_EQ_ULONG);
     this.detailed_eq_operators.Add(7, this.OP_EQ_FLOAT);
     this.detailed_eq_operators.Add(6, this.OP_EQ_DOUBLE);
     this.detailed_eq_operators.Add(5, this.OP_EQ_DECIMAL);
     this.detailed_eq_operators.Add(12, this.OP_EQ_STRING);
     this.detailed_eq_operators.Add(2, this.OP_EQ_BOOL);
     this.detailed_eq_operators.Add(0x10, this.OP_EQ_OBJECT);
     this.detailed_operators.AddFrom(this.detailed_eq_operators);
     this.detailed_ne_operators = new Contact_Integers(10);
     this.detailed_ne_operators.Add(8, this.OP_NE_INT);
     this.detailed_ne_operators.Add(13, this.OP_NE_UINT);
     this.detailed_ne_operators.Add(9, this.OP_NE_LONG);
     this.detailed_ne_operators.Add(14, this.OP_NE_ULONG);
     this.detailed_ne_operators.Add(7, this.OP_NE_FLOAT);
     this.detailed_ne_operators.Add(6, this.OP_NE_DOUBLE);
     this.detailed_ne_operators.Add(5, this.OP_NE_DECIMAL);
     this.detailed_ne_operators.Add(12, this.OP_NE_STRING);
     this.detailed_ne_operators.Add(2, this.OP_NE_BOOL);
     this.detailed_ne_operators.Add(0x10, this.OP_NE_OBJECT);
     this.detailed_operators.AddFrom(this.detailed_ne_operators);
     this.stack = new ObjectStack();
     this.state_stack = new IntegerStack();
     this.try_stack = new TryStack();
     this.checked_stack = new ObjectStack();
     this.custom_ex_list = new CSLite_TypedList(false);
     this.breakpoint_list = new BreakpointList(scripter);
     this.callstack = new CallStack(scripter);
     this.resume_stack = new IntegerStack();
     this.get_item_list = new ArrayList();
     this.arrProc = new ArrayList();
     for (num = 0; num < 0x3e8; num++)
     {
         this.arrProc.Add(null);
     }
     this.arrProc[-this.OP_BEGIN_MODULE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_END_MODULE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_CHECKED] = new Oper(this.OperChecked);
     this.arrProc[-this.OP_RESTORE_CHECKED_STATE] = new Oper(this.OperRestoreCheckedState);
     this.arrProc[-this.OP_LOCK] = new Oper(this.OperLock);
     this.arrProc[-this.OP_UNLOCK] = new Oper(this.OperUnlock);
     this.arrProc[-this.OP_DISPOSE] = new Oper(this.OperDispose);
     this.arrProc[-this.OP_TYPEOF] = new Oper(this.OperTypeOf);
     this.arrProc[-this.OP_CREATE_CLASS] = new Oper(this.OperCreateClass);
     this.arrProc[-this.OP_END_CLASS] = new Oper(this.OperNop);
     this.arrProc[-this.OP_CREATE_OBJECT] = new Oper(this.OperCreateObject);
     this.arrProc[-this.OP_CREATE_REFERENCE] = new Oper(this.OperCreateReference);
     this.arrProc[-this.OP_CREATE_ARRAY_INSTANCE] = new Oper(this.OperCreateArrayInstance);
     this.arrProc[-this.OP_SETUP_DELEGATE] = new Oper(this.OperSetupDelegate);
     this.arrProc[-this.OP_ADD_DELEGATES] = new Oper(this.OperAddDelegates);
     this.arrProc[-this.OP_SUB_DELEGATES] = new Oper(this.OperSubDelegates);
     this.arrProc[-this.OP_EQ_DELEGATES] = new Oper(this.OperEqDelegates);
     this.arrProc[-this.OP_NE_DELEGATES] = new Oper(this.OperNeDelegates);
     this.arrProc[-this.OP_ADDRESS_OF] = new Oper(this.OperNop);
     this.arrProc[-this.OP_CREATE_INDEX_OBJECT] = new Oper(this.OperCreateIndexObject);
     this.arrProc[-this.OP_ADD_INDEX] = new Oper(this.OperAddIndex);
     this.arrProc[-this.OP_SETUP_INDEX_OBJECT] = new Oper(this.OperSetupIndexObject);
     this.arrProc[-this.OP_CREATE_TYPE_REFERENCE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_CREATE_FIELD] = new Oper(this.OperCreateField);
     this.arrProc[-this.OP_CREATE_PROPERTY] = new Oper(this.OperCreateProperty);
     this.arrProc[-this.OP_CREATE_EVENT] = new Oper(this.OperCreateEvent);
     this.arrProc[-this.OP_CREATE_NAMESPACE] = new Oper(this.OperCreateNamespace);
     this.arrProc[-this.OP_BEGIN_USING] = new Oper(this.OperNop);
     this.arrProc[-this.OP_END_USING] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_MODIFIER] = new Oper(this.OperAddModifier);
     this.arrProc[-this.OP_ADD_ANCESTOR] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_UNDERLYING_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_READ_ACCESSOR] = new Oper(this.OperAddReadAccessor);
     this.arrProc[-this.OP_ADD_WRITE_ACCESSOR] = new Oper(this.OperAddWriteAccessor);
     this.arrProc[-this.OP_SET_DEFAULT] = new Oper(this.OperSetDefault);
     this.arrProc[-this.OP_ADD_ADD_ACCESSOR] = new Oper(this.OperAddAddAccessor);
     this.arrProc[-this.OP_ADD_REMOVE_ACCESSOR] = new Oper(this.OperAddRemoveAccessor);
     this.arrProc[-this.OP_ADD_PATTERN] = new Oper(this.OperAddPattern);
     this.arrProc[-this.OP_ADD_IMPLEMENTS] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_HANDLES] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_MIN_VALUE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_MAX_VALUE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_ARRAY_RANGE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ADD_ARRAY_INDEX] = new Oper(this.OperNop);
     this.arrProc[-this.OP_BEGIN_CALL] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ASSIGN_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ASSIGN_COND_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_CREATE_USING_ALIAS] = new Oper(this.OperCreateUsingAlias);
     this.arrProc[-this.OP_CREATE_REF_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_SET_REF_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_EVAL] = new Oper(this.OperNop);
     this.arrProc[-this.OP_EVAL_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_EVAL_BASE_TYPE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ASSIGN_NAME] = new Oper(this.OperNop);
     this.arrProc[-this.OP_NOP] = new Oper(this.OperNop);
     this.arrProc[-this.OP_INIT_STATIC_VAR] = new Oper(this.OperNop);
     this.arrProc[-this.OP_LABEL] = new Oper(this.OperNop);
     this.arrProc[-this.OP_ASSIGN] = new Oper(this.OperAssign);
     this.arrProc[-this.OP_ASSIGN_STRUCT] = new Oper(this.OperAssignStruct);
     this.arrProc[-this.OP_PLUS] = new Oper(this.OperPlus);
     this.arrProc[-this.OP_INC] = new Oper(this.OperPlus);
     this.arrProc[-this.OP_MINUS] = new Oper(this.OperMinus);
     this.arrProc[-this.OP_DEC] = new Oper(this.OperMinus);
     this.arrProc[-this.OP_MULT] = new Oper(this.OperMult);
     this.arrProc[-this.OP_EXPONENT] = new Oper(this.OperExp);
     this.arrProc[-this.OP_DIV] = new Oper(this.OperDiv);
     this.arrProc[-this.OP_EQ] = new Oper(this.OperEq);
     this.arrProc[-this.OP_NE] = new Oper(this.OperNe);
     this.arrProc[-this.OP_GT] = new Oper(this.OperGt);
     this.arrProc[-this.OP_GE] = new Oper(this.OperGe);
     this.arrProc[-this.OP_LT] = new Oper(this.OperLt);
     this.arrProc[-this.OP_LE] = new Oper(this.OperLe);
     this.arrProc[-this.OP_IS] = new Oper(this.OperIs);
     this.arrProc[-this.OP_AS] = new Oper(this.OperAs);
     this.arrProc[-this.OP_UPCASE_ON] = new Oper(this.OperNop);
     this.arrProc[-this.OP_UPCASE_OFF] = new Oper(this.OperNop);
     this.arrProc[-this.OP_EXPLICIT_ON] = new Oper(this.OperNop);
     this.arrProc[-this.OP_EXPLICIT_OFF] = new Oper(this.OperNop);
     this.arrProc[-this.OP_STRICT_ON] = new Oper(this.OperNop);
     this.arrProc[-this.OP_STRICT_OFF] = new Oper(this.OperNop);
     this.arrProc[-this.OP_HALT] = new Oper(this.OperHalt);
     this.arrProc[-this.OP_PRINT] = new Oper(this.OperPrint);
     this.arrProc[-this.OP_GO] = new Oper(this.OperGo);
     this.arrProc[-this.OP_GO_FALSE] = new Oper(this.OperGoFalse);
     this.arrProc[-this.OP_GO_TRUE] = new Oper(this.OperGoTrue);
     this.arrProc[-this.OP_GO_NULL] = new Oper(this.OperGoNull);
     this.arrProc[-this.OP_GOTO_START] = new Oper(this.OperGotoStart);
     this.arrProc[-this.OP_GOTO_CONTINUE] = new Oper(this.OperGotoContinue);
     this.arrProc[-this.OP_CREATE_METHOD] = new Oper(this.OperCreateMethod);
     this.arrProc[-this.OP_ADD_EXPLICIT_INTERFACE] = new Oper(this.OperAddExplicitInterface);
     this.arrProc[-this.OP_ADD_PARAM] = new Oper(this.OperAddParam);
     this.arrProc[-this.OP_ADD_PARAMS] = new Oper(this.OperAddParams);
     this.arrProc[-this.OP_ADD_DEFAULT_VALUE] = new Oper(this.OperAddDefaultValue);
     this.arrProc[-this.OP_INIT_METHOD] = new Oper(this.OperInitMethod);
     this.arrProc[-this.OP_DECLARE_LOCAL_VARIABLE] = new Oper(this.OperDeclareLocalVariable);
     this.arrProc[-this.OP_DECLARE_LOCAL_VARIABLE_RUNTIME] = new Oper(this.OperNop);
     this.arrProc[-this.OP_DECLARE_LOCAL_SIMPLE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_END_METHOD] = new Oper(this.OperEndMethod);
     this.arrProc[-this.OP_ADD_EVENT_FIELD] = new Oper(this.OperAddEventField);
     this.arrProc[-this.OP_CALL] = new Oper(this.OperCall);
     this.arrProc[-this.OP_CALL_BASE] = new Oper(this.OperCallBase);
     this.arrProc[-this.OP_CALL_SIMPLE] = new Oper(this.OperCall);
     this.arrProc[-this.OP_CALL_VIRT] = new Oper(this.OperCallVirt);
     this.arrProc[-this.OP_DYNAMIC_INVOKE] = new Oper(this.OperDynamicInvoke);
     this.arrProc[-this.OP_CHECK_STRUCT_CONSTRUCTOR] = new Oper(this.OperNop);
     this.arrProc[-this.OP_INSERT_STRUCT_CONSTRUCTORS] = new Oper(this.OperNop);
     this.arrProc[-this.OP_CALL_ADD_EVENT] = new Oper(this.OperCallAddEvent);
     this.arrProc[-this.OP_RAISE_EVENT] = new Oper(this.OperNop);
     this.arrProc[-this.OP_FIND_FIRST_DELEGATE] = new Oper(this.OperFindFirstDelegate);
     this.arrProc[-this.OP_FIND_NEXT_DELEGATE] = new Oper(this.OperFindNextDelegate);
     this.arrProc[-this.OP_PUSH] = new Oper(this.OperPush);
     this.arrProc[-this.OP_RET] = new Oper(this.OperRet);
     this.arrProc[-this.OP_EXIT_SUB] = new Oper(this.OperExitSub);
     this.arrProc[-this.OP_GET_PARAM_VALUE] = new Oper(this.OperGetParamValue);
     this.arrProc[-this.OP_CAST] = new Oper(this.OperCast);
     this.arrProc[-this.OP_TO_SBYTE] = new Oper(this.OperToSbyte);
     this.arrProc[-this.OP_TO_BYTE] = new Oper(this.OperToByte);
     this.arrProc[-this.OP_TO_USHORT] = new Oper(this.OperToUshort);
     this.arrProc[-this.OP_TO_SHORT] = new Oper(this.OperToShort);
     this.arrProc[-this.OP_TO_UINT] = new Oper(this.OperToUint);
     this.arrProc[-this.OP_TO_INT] = new Oper(this.OperToInt);
     this.arrProc[-this.OP_TO_ULONG] = new Oper(this.OperToUlong);
     this.arrProc[-this.OP_TO_LONG] = new Oper(this.OperToLong);
     this.arrProc[-this.OP_TO_CHAR] = new Oper(this.OperToChar);
     this.arrProc[-this.OP_TO_FLOAT] = new Oper(this.OperToFloat);
     this.arrProc[-this.OP_TO_DOUBLE] = new Oper(this.OperToDouble);
     this.arrProc[-this.OP_TO_DECIMAL] = new Oper(this.OperToDecimal);
     this.arrProc[-this.OP_TO_STRING] = new Oper(this.OperToString);
     this.arrProc[-this.OP_TO_BOOLEAN] = new Oper(this.OperToBoolean);
     this.arrProc[-this.OP_TO_ENUM] = new Oper(this.OperToEnum);
     this.arrProc[-this.OP_TO_CHAR_ARRAY] = new Oper(this.OperToCharArray);
     this.arrProc[-this.OP_TRY_ON] = new Oper(this.OperTryOn);
     this.arrProc[-this.OP_TRY_OFF] = new Oper(this.OperTryOff);
     this.arrProc[-this.OP_THROW] = new Oper(this.OperThrow);
     this.arrProc[-this.OP_CATCH] = new Oper(this.OperCatch);
     this.arrProc[-this.OP_FINALLY] = new Oper(this.OperFinally);
     this.arrProc[-this.OP_DISCARD_ERROR] = new Oper(this.OperDiscardError);
     this.arrProc[-this.OP_EXIT_ON_ERROR] = new Oper(this.OperExitOnError);
     this.arrProc[-this.OP_ONERROR] = new Oper(this.OperOnError);
     this.arrProc[-this.OP_RESUME] = new Oper(this.OperResume);
     this.arrProc[-this.OP_RESUME_NEXT] = new Oper(this.OperResumeNext);
     this.arrProc[-this.OP_SEPARATOR] = new Oper(this.OperNop);
     this.arrProc[-this.OP_DEFINE] = new Oper(this.OperNop);
     this.arrProc[-this.OP_UNDEF] = new Oper(this.OperNop);
     this.arrProc[-this.OP_START_REGION] = new Oper(this.OperNop);
     this.arrProc[-this.OP_END_REGION] = new Oper(this.OperNop);
     this.arrProc[-this.OP_NEGATION_INT] = new Oper(this.OperNegationInt);
     this.arrProc[-this.OP_NEGATION_LONG] = new Oper(this.OperNegationLong);
     this.arrProc[-this.OP_NEGATION_FLOAT] = new Oper(this.OperNegationFloat);
     this.arrProc[-this.OP_NEGATION_DOUBLE] = new Oper(this.OperNegationDouble);
     this.arrProc[-this.OP_NEGATION_DECIMAL] = new Oper(this.OperNegationDecimal);
     this.arrProc[-this.OP_LOGICAL_NEGATION_BOOL] = new Oper(this.OperLogicalNegationBool);
     this.arrProc[-this.OP_BITWISE_COMPLEMENT_INT] = new Oper(this.OperBitwiseComplementInt);
     this.arrProc[-this.OP_BITWISE_COMPLEMENT_UINT] = new Oper(this.OperBitwiseComplementUint);
     this.arrProc[-this.OP_BITWISE_COMPLEMENT_LONG] = new Oper(this.OperBitwiseComplementLong);
     this.arrProc[-this.OP_BITWISE_COMPLEMENT_ULONG] = new Oper(this.OperBitwiseComplementUlong);
     this.arrProc[-this.OP_INC_SBYTE] = new Oper(this.OperIncSbyte);
     this.arrProc[-this.OP_INC_BYTE] = new Oper(this.OperIncByte);
     this.arrProc[-this.OP_INC_SHORT] = new Oper(this.OperIncShort);
     this.arrProc[-this.OP_INC_USHORT] = new Oper(this.OperIncUshort);
     this.arrProc[-this.OP_INC_INT] = new Oper(this.OperIncInt);
     this.arrProc[-this.OP_INC_UINT] = new Oper(this.OperIncUint);
     this.arrProc[-this.OP_INC_LONG] = new Oper(this.OperIncLong);
     this.arrProc[-this.OP_INC_ULONG] = new Oper(this.OperIncUlong);
     this.arrProc[-this.OP_INC_CHAR] = new Oper(this.OperIncChar);
     this.arrProc[-this.OP_INC_FLOAT] = new Oper(this.OperIncFloat);
     this.arrProc[-this.OP_INC_DOUBLE] = new Oper(this.OperIncDouble);
     this.arrProc[-this.OP_INC_DECIMAL] = new Oper(this.OperIncDecimal);
     this.arrProc[-this.OP_DEC_SBYTE] = new Oper(this.OperDecSbyte);
     this.arrProc[-this.OP_DEC_BYTE] = new Oper(this.OperDecByte);
     this.arrProc[-this.OP_DEC_SHORT] = new Oper(this.OperDecShort);
     this.arrProc[-this.OP_DEC_USHORT] = new Oper(this.OperDecUshort);
     this.arrProc[-this.OP_DEC_INT] = new Oper(this.OperDecInt);
     this.arrProc[-this.OP_DEC_UINT] = new Oper(this.OperDecUint);
     this.arrProc[-this.OP_DEC_LONG] = new Oper(this.OperDecLong);
     this.arrProc[-this.OP_DEC_ULONG] = new Oper(this.OperDecUlong);
     this.arrProc[-this.OP_DEC_CHAR] = new Oper(this.OperDecChar);
     this.arrProc[-this.OP_DEC_FLOAT] = new Oper(this.OperDecFloat);
     this.arrProc[-this.OP_DEC_DOUBLE] = new Oper(this.OperDecDouble);
     this.arrProc[-this.OP_DEC_DECIMAL] = new Oper(this.OperDecDecimal);
     this.arrProc[-this.OP_ADDITION_INT] = new Oper(this.OperAdditionInt);
     this.arrProc[-this.OP_ADDITION_UINT] = new Oper(this.OperAdditionUint);
     this.arrProc[-this.OP_ADDITION_LONG] = new Oper(this.OperAdditionLong);
     this.arrProc[-this.OP_ADDITION_ULONG] = new Oper(this.OperAdditionUlong);
     this.arrProc[-this.OP_ADDITION_FLOAT] = new Oper(this.OperAdditionFloat);
     this.arrProc[-this.OP_ADDITION_DOUBLE] = new Oper(this.OperAdditionDouble);
     this.arrProc[-this.OP_ADDITION_DECIMAL] = new Oper(this.OperAdditionDecimal);
     this.arrProc[-this.OP_ADDITION_STRING] = new Oper(this.OperAdditionString);
     this.arrProc[-this.OP_SUBTRACTION_INT] = new Oper(this.OperSubtractionInt);
     this.arrProc[-this.OP_SUBTRACTION_UINT] = new Oper(this.OperSubtractionUint);
     this.arrProc[-this.OP_SUBTRACTION_LONG] = new Oper(this.OperSubtractionLong);
     this.arrProc[-this.OP_SUBTRACTION_ULONG] = new Oper(this.OperSubtractionUlong);
     this.arrProc[-this.OP_SUBTRACTION_FLOAT] = new Oper(this.OperSubtractionFloat);
     this.arrProc[-this.OP_SUBTRACTION_DOUBLE] = new Oper(this.OperSubtractionDouble);
     this.arrProc[-this.OP_SUBTRACTION_DECIMAL] = new Oper(this.OperSubtractionDecimal);
     this.arrProc[-this.OP_MULTIPLICATION_INT] = new Oper(this.OperMultiplicationInt);
     this.arrProc[-this.OP_MULTIPLICATION_UINT] = new Oper(this.OperMultiplicationUint);
     this.arrProc[-this.OP_MULTIPLICATION_LONG] = new Oper(this.OperMultiplicationLong);
     this.arrProc[-this.OP_MULTIPLICATION_ULONG] = new Oper(this.OperMultiplicationUlong);
     this.arrProc[-this.OP_MULTIPLICATION_FLOAT] = new Oper(this.OperMultiplicationFloat);
     this.arrProc[-this.OP_MULTIPLICATION_DOUBLE] = new Oper(this.OperMultiplicationDouble);
     this.arrProc[-this.OP_MULTIPLICATION_DECIMAL] = new Oper(this.OperMultiplicationDecimal);
     this.arrProc[-this.OP_EXPONENT_INT] = new Oper(this.OperExponentInt);
     this.arrProc[-this.OP_EXPONENT_UINT] = new Oper(this.OperExponentUint);
     this.arrProc[-this.OP_EXPONENT_LONG] = new Oper(this.OperExponentLong);
     this.arrProc[-this.OP_EXPONENT_ULONG] = new Oper(this.OperExponentUlong);
     this.arrProc[-this.OP_EXPONENT_FLOAT] = new Oper(this.OperExponentFloat);
     this.arrProc[-this.OP_EXPONENT_DOUBLE] = new Oper(this.OperExponentDouble);
     this.arrProc[-this.OP_EXPONENT_DECIMAL] = new Oper(this.OperExponentDecimal);
     this.arrProc[-this.OP_DIVISION_INT] = new Oper(this.OperDivisionInt);
     this.arrProc[-this.OP_DIVISION_UINT] = new Oper(this.OperDivisionUint);
     this.arrProc[-this.OP_DIVISION_LONG] = new Oper(this.OperDivisionLong);
     this.arrProc[-this.OP_DIVISION_ULONG] = new Oper(this.OperDivisionUlong);
     this.arrProc[-this.OP_DIVISION_FLOAT] = new Oper(this.OperDivisionFloat);
     this.arrProc[-this.OP_DIVISION_DOUBLE] = new Oper(this.OperDivisionDouble);
     this.arrProc[-this.OP_DIVISION_DECIMAL] = new Oper(this.OperDivisionDecimal);
     this.arrProc[-this.OP_REMAINDER_INT] = new Oper(this.OperRemainderInt);
     this.arrProc[-this.OP_REMAINDER_UINT] = new Oper(this.OperRemainderUint);
     this.arrProc[-this.OP_REMAINDER_LONG] = new Oper(this.OperRemainderLong);
     this.arrProc[-this.OP_REMAINDER_ULONG] = new Oper(this.OperRemainderUlong);
     this.arrProc[-this.OP_REMAINDER_FLOAT] = new Oper(this.OperRemainderFloat);
     this.arrProc[-this.OP_REMAINDER_DOUBLE] = new Oper(this.OperRemainderDouble);
     this.arrProc[-this.OP_REMAINDER_DECIMAL] = new Oper(this.OperRemainderDecimal);
     this.arrProc[-this.OP_LEFT_SHIFT_INT] = new Oper(this.OperLeftShiftInt);
     this.arrProc[-this.OP_LEFT_SHIFT_UINT] = new Oper(this.OperLeftShiftUint);
     this.arrProc[-this.OP_LEFT_SHIFT_LONG] = new Oper(this.OperLeftShiftLong);
     this.arrProc[-this.OP_LEFT_SHIFT_ULONG] = new Oper(this.OperLeftShiftUlong);
     this.arrProc[-this.OP_RIGHT_SHIFT_INT] = new Oper(this.OperRightShiftInt);
     this.arrProc[-this.OP_RIGHT_SHIFT_UINT] = new Oper(this.OperRightShiftUint);
     this.arrProc[-this.OP_RIGHT_SHIFT_LONG] = new Oper(this.OperRightShiftLong);
     this.arrProc[-this.OP_RIGHT_SHIFT_ULONG] = new Oper(this.OperRightShiftUlong);
     this.arrProc[-this.OP_BITWISE_AND_INT] = new Oper(this.OperBitwiseAndInt);
     this.arrProc[-this.OP_BITWISE_AND_UINT] = new Oper(this.OperBitwiseAndUint);
     this.arrProc[-this.OP_BITWISE_AND_LONG] = new Oper(this.OperBitwiseAndLong);
     this.arrProc[-this.OP_BITWISE_AND_ULONG] = new Oper(this.OperBitwiseAndUlong);
     this.arrProc[-this.OP_BITWISE_AND_BOOL] = new Oper(this.OperBitwiseAndBool);
     this.arrProc[-this.OP_BITWISE_OR_INT] = new Oper(this.OperBitwiseOrInt);
     this.arrProc[-this.OP_BITWISE_OR_UINT] = new Oper(this.OperBitwiseOrUint);
     this.arrProc[-this.OP_BITWISE_OR_LONG] = new Oper(this.OperBitwiseOrLong);
     this.arrProc[-this.OP_BITWISE_OR_ULONG] = new Oper(this.OperBitwiseOrUlong);
     this.arrProc[-this.OP_BITWISE_OR_BOOL] = new Oper(this.OperBitwiseOrBool);
     this.arrProc[-this.OP_BITWISE_XOR_INT] = new Oper(this.OperBitwiseXorInt);
     this.arrProc[-this.OP_BITWISE_XOR_UINT] = new Oper(this.OperBitwiseXorUint);
     this.arrProc[-this.OP_BITWISE_XOR_LONG] = new Oper(this.OperBitwiseXorLong);
     this.arrProc[-this.OP_BITWISE_XOR_ULONG] = new Oper(this.OperBitwiseXorUlong);
     this.arrProc[-this.OP_BITWISE_XOR_BOOL] = new Oper(this.OperBitwiseXorBool);
     this.arrProc[-this.OP_LT_INT] = new Oper(this.OperLessThanInt);
     this.arrProc[-this.OP_LT_UINT] = new Oper(this.OperLessThanUint);
     this.arrProc[-this.OP_LT_LONG] = new Oper(this.OperLessThanLong);
     this.arrProc[-this.OP_LT_ULONG] = new Oper(this.OperLessThanUlong);
     this.arrProc[-this.OP_LT_FLOAT] = new Oper(this.OperLessThanFloat);
     this.arrProc[-this.OP_LT_DOUBLE] = new Oper(this.OperLessThanDouble);
     this.arrProc[-this.OP_LT_DECIMAL] = new Oper(this.OperLessThanDecimal);
     this.arrProc[-this.OP_LT_STRING] = new Oper(this.OperLessThanString);
     this.arrProc[-this.OP_LE_INT] = new Oper(this.OperLessThanOrEqualInt);
     this.arrProc[-this.OP_LE_UINT] = new Oper(this.OperLessThanOrEqualUint);
     this.arrProc[-this.OP_LE_LONG] = new Oper(this.OperLessThanOrEqualLong);
     this.arrProc[-this.OP_LE_ULONG] = new Oper(this.OperLessThanOrEqualUlong);
     this.arrProc[-this.OP_LE_FLOAT] = new Oper(this.OperLessThanOrEqualFloat);
     this.arrProc[-this.OP_LE_DOUBLE] = new Oper(this.OperLessThanOrEqualDouble);
     this.arrProc[-this.OP_LE_DECIMAL] = new Oper(this.OperLessThanOrEqualDecimal);
     this.arrProc[-this.OP_LE_STRING] = new Oper(this.OperLessThanOrEqualString);
     this.arrProc[-this.OP_GT_INT] = new Oper(this.OperGreaterThanInt);
     this.arrProc[-this.OP_GT_UINT] = new Oper(this.OperGreaterThanUint);
     this.arrProc[-this.OP_GT_LONG] = new Oper(this.OperGreaterThanLong);
     this.arrProc[-this.OP_GT_ULONG] = new Oper(this.OperGreaterThanUlong);
     this.arrProc[-this.OP_GT_FLOAT] = new Oper(this.OperGreaterThanFloat);
     this.arrProc[-this.OP_GT_DOUBLE] = new Oper(this.OperGreaterThanDouble);
     this.arrProc[-this.OP_GT_DECIMAL] = new Oper(this.OperGreaterThanDecimal);
     this.arrProc[-this.OP_GT_STRING] = new Oper(this.OperGreaterThanString);
     this.arrProc[-this.OP_GE_INT] = new Oper(this.OperGreaterThanOrEqualInt);
     this.arrProc[-this.OP_GE_UINT] = new Oper(this.OperGreaterThanOrEqualUint);
     this.arrProc[-this.OP_GE_LONG] = new Oper(this.OperGreaterThanOrEqualLong);
     this.arrProc[-this.OP_GE_ULONG] = new Oper(this.OperGreaterThanOrEqualUlong);
     this.arrProc[-this.OP_GE_FLOAT] = new Oper(this.OperGreaterThanOrEqualFloat);
     this.arrProc[-this.OP_GE_DOUBLE] = new Oper(this.OperGreaterThanOrEqualDouble);
     this.arrProc[-this.OP_GE_DECIMAL] = new Oper(this.OperGreaterThanOrEqualDecimal);
     this.arrProc[-this.OP_GE_STRING] = new Oper(this.OperGreaterThanOrEqualString);
     this.arrProc[-this.OP_EQ_INT] = new Oper(this.OperEqualityInt);
     this.arrProc[-this.OP_EQ_UINT] = new Oper(this.OperEqualityUint);
     this.arrProc[-this.OP_EQ_LONG] = new Oper(this.OperEqualityLong);
     this.arrProc[-this.OP_EQ_ULONG] = new Oper(this.OperEqualityUlong);
     this.arrProc[-this.OP_EQ_FLOAT] = new Oper(this.OperEqualityFloat);
     this.arrProc[-this.OP_EQ_DOUBLE] = new Oper(this.OperEqualityDouble);
     this.arrProc[-this.OP_EQ_DECIMAL] = new Oper(this.OperEqualityDecimal);
     this.arrProc[-this.OP_EQ_STRING] = new Oper(this.OperEqualityString);
     this.arrProc[-this.OP_EQ_BOOL] = new Oper(this.OperEqualityBool);
     this.arrProc[-this.OP_EQ_OBJECT] = new Oper(this.OperEqualityObject);
     this.arrProc[-this.OP_NE_INT] = new Oper(this.OperInequalityInt);
     this.arrProc[-this.OP_NE_UINT] = new Oper(this.OperInequalityUint);
     this.arrProc[-this.OP_NE_LONG] = new Oper(this.OperInequalityLong);
     this.arrProc[-this.OP_NE_ULONG] = new Oper(this.OperInequalityUlong);
     this.arrProc[-this.OP_NE_FLOAT] = new Oper(this.OperInequalityFloat);
     this.arrProc[-this.OP_NE_DOUBLE] = new Oper(this.OperInequalityDouble);
     this.arrProc[-this.OP_NE_DECIMAL] = new Oper(this.OperInequalityDecimal);
     this.arrProc[-this.OP_NE_STRING] = new Oper(this.OperInequalityString);
     this.arrProc[-this.OP_NE_BOOL] = new Oper(this.OperInequalityBool);
     this.arrProc[-this.OP_NE_OBJECT] = new Oper(this.OperInequalityObject);
     this.arrProc[-this.OP_SWAPPED_ARGUMENTS] = new Oper(this.OperSwappedArguments);
     this.prog = new ArrayList();
     for (num = 0; num < 0x3e8; num++)
     {
         this.prog.Add(new ProgRec());
     }
     this.n = 0;
     this.card = 0;
 }