public IntegerStack Clone()
{
IntegerStack stack = new IntegerStack();
for (int i = 0; i < base.Count; i++)
{
stack.Add(base.Items[i]);
}
return stack;
}
public BaseScanner(BaseParser parser)
{
this.token = new Token(this);
this.history = new IntegerStack();
this.def_stack = new IntegerStack();
this.parser = parser;
NumberFormatInfo currentInfo = NumberFormatInfo.CurrentInfo;
this.DecimalSeparator = currentInfo.NumberDecimalSeparator;
}
public SymbolTable(BaseScripter scripter)
{
this.scripter = scripter;
this.state_stack = new IntegerStack();
this.a = new ArrayList();
for (int i = 0; i < 0x3e8; i++)
{
this.a.Add(new SymbolRec(scripter, i));
}
}
private void Parse_SwitchStmt()
{
int label = base.NewLabel();
int num2 = base.NewLabel();
IntegerList list = new IntegerList(true);
IntegerList list2 = new IntegerList(true);
IntegerStack stack = new IntegerStack();
int num3 = base.NewVar();
this.Gen(base.code.OP_ASSIGN, num3, base.TRUE_id, num3);
base.BreakStack.Push(label);
this.Match("switch");
base.BeginBlock();
this.Match('(');
int num4 = this.Parse_Expression();
this.Match(')');
this.Match('{');
Label_008D:
if (base.IsCurrText("case"))
{
this.Match("case");
stack.Push(base.NewLabel());
int avalue = this.Parse_Expression();
list.AddObject(avalue, stack.Peek());
this.Gen(base.code.OP_EQ, num4, avalue, num3);
this.Gen(base.code.OP_GO_TRUE, stack.Peek(), num3, 0);
}
else
{
if (!base.IsCurrText("default"))
{
while (stack.Count > 0)
{
base.SetLabelHere(stack.Peek());
stack.Pop();
}
int num6 = base.NewLabel();
this.Gen(base.code.OP_GO_FALSE, num6, num3, 0);
while ((!base.IsCurrText("case") && !base.IsCurrText("default")) && !base.IsCurrText('}'))
{
if (base.IsCurrText("goto"))
{
this.Match("goto");
if (base.IsCurrText("case"))
{
this.Match("case");
int num7 = this.Parse_Expression();
this.Gen(base.code.OP_GOTO_START, 0, 0, 0);
list2.AddObject(num7, base.CodeCard);
this.Match(';');
}
else if (base.IsCurrText("default"))
{
this.Match("default");
this.Gen(base.code.OP_GOTO_START, num2, 0, 0);
this.Match(';');
}
else
{
int num8 = this.Parse_Ident();
this.Gen(base.code.OP_GOTO_START, num8, 0, 0);
this.Match(';');
}
}
else
{
this.Parse_Stmt();
}
}
base.SetLabelHere(num6);
if (base.IsCurrText('}'))
{
base.BreakStack.Pop();
base.SetLabelHere(label);
base.EndBlock();
this.Match('}');
for (int i = 0; i < list2.Count; i++)
{
int id = list2[i];
int n = (int) list2.Objects[i];
object val = base.GetVal(id);
bool flag = false;
for (int j = 0; j < list.Count; j++)
{
int num13 = list[j];
int num14 = (int) list.Objects[j];
object obj3 = base.GetVal(num13);
if ((val.GetType() == obj3.GetType()) && (val == obj3))
{
flag = true;
base.GenAt(n, base.code.OP_GOTO_START, num14, 0, 0);
break;
}
}
if (!flag)
{
base.CodeCard = n;
base.RaiseErrorEx(true, "CS0159. No such label '{0}' within the scope of the goto statement.", new object[] { val.ToString() });
}
}
return;
}
goto Label_008D;
}
this.Match("default");
base.SetLabelHere(num2);
this.Gen(base.code.OP_ASSIGN, num3, base.TRUE_id, num3);
}
this.Match(':');
goto Label_008D;
}
public VB_Parser()
{
base.language = "VB";
base.scanner = new VB_Scanner(this);
base.upcase = true;
base.AllowKeywordsInMemberAccessExpressions = true;
this.variable_initializers = new IntegerList(false);
this.static_variable_initializers = new IntegerList(false);
this.param_ids = new IntegerList(true);
this.param_type_ids = new IntegerList(true);
this.param_mods = new IntegerList(true);
this.local_variables = new IntegerList(false);
this.total_modifier_list = new StringList(false);
this.total_modifier_list.AddObject("Public", Modifier.Public);
this.total_modifier_list.AddObject("Protected", Modifier.Protected);
this.total_modifier_list.AddObject("Internal", Modifier.Internal);
this.total_modifier_list.AddObject("Private", Modifier.Private);
this.total_modifier_list.AddObject("Shared", Modifier.Static);
this.total_modifier_list.AddObject("Overridable", Modifier.Virtual);
this.total_modifier_list.AddObject("NotOverridable", Modifier.Sealed);
this.total_modifier_list.AddObject("MustOverride", Modifier.Abstract);
this.total_modifier_list.AddObject("Overrides", Modifier.Override);
this.total_modifier_list.AddObject("Overloads", Modifier.Overloads);
this.total_modifier_list.AddObject("ReadOnly", Modifier.ReadOnly);
this.total_modifier_list.AddObject("Friend", Modifier.Friend);
this.total_modifier_list.AddObject("Default", Modifier.Default);
this.total_modifier_list.AddObject("MustInherit", Modifier.Abstract);
this.total_modifier_list.AddObject("Shadows", Modifier.Shadows);
this.total_modifier_list.AddObject("NotInheritable", Modifier.Sealed);
this.total_modifier_list.AddObject("WithEvents", Modifier.WithEvents);
base.keywords.Add("AddHandler");
base.keywords.Add("AddressOf");
base.keywords.Add("Alias");
base.keywords.Add("And");
base.keywords.Add("AndAlso");
base.keywords.Add("Ansi");
base.keywords.Add("As");
base.keywords.Add("Assembly");
base.keywords.Add("Auto");
base.keywords.Add("Boolean");
base.keywords.Add("ByRef");
base.keywords.Add("Byte");
base.keywords.Add("ByVal");
base.keywords.Add("Call");
base.keywords.Add("Case");
base.keywords.Add("Catch");
base.keywords.Add("CBool");
base.keywords.Add("CByte");
base.keywords.Add("CChar");
base.keywords.Add("CDate");
base.keywords.Add("CDbl");
base.keywords.Add("CDec");
base.keywords.Add("Char");
base.keywords.Add("CInt");
base.keywords.Add("Class");
base.keywords.Add("CLng");
base.keywords.Add("CObj");
base.keywords.Add("Const");
base.keywords.Add("CShort");
base.keywords.Add("CSng");
base.keywords.Add("CStr");
base.keywords.Add("CType");
base.keywords.Add("Date");
base.keywords.Add("Decimal");
base.keywords.Add("Declare");
base.keywords.Add("Default");
base.keywords.Add("Delegate");
base.keywords.Add("Dim");
base.keywords.Add("DirectCast");
base.keywords.Add("Do");
base.keywords.Add("Double");
base.keywords.Add("Each");
base.keywords.Add("Else");
base.keywords.Add("ElseIf");
base.keywords.Add("End");
base.keywords.Add("EndIf");
base.keywords.Add("Enum");
base.keywords.Add("Erase");
base.keywords.Add("Error");
base.keywords.Add("Event");
base.keywords.Add("Exit");
base.keywords.Add("False");
base.keywords.Add("Finally");
base.keywords.Add("For");
base.keywords.Add("Friend");
base.keywords.Add("Function");
base.keywords.Add("Get");
base.keywords.Add("GoSub");
base.keywords.Add("GoTo");
base.keywords.Add("Handles");
base.keywords.Add("If");
base.keywords.Add("Implements");
base.keywords.Add("Imports");
base.keywords.Add("In");
base.keywords.Add("Inherits");
base.keywords.Add("Integer");
base.keywords.Add("Interface");
base.keywords.Add("Is");
base.keywords.Add("Let");
base.keywords.Add("Lib");
base.keywords.Add("Like");
base.keywords.Add("Long");
base.keywords.Add("Loop");
base.keywords.Add("Me");
base.keywords.Add("Mod");
base.keywords.Add("Module");
base.keywords.Add("MustInherit");
base.keywords.Add("MustOverride");
base.keywords.Add("MyBase");
base.keywords.Add("MyClass");
base.keywords.Add("Namespace");
base.keywords.Add("New");
base.keywords.Add("Next");
base.keywords.Add("Not");
base.keywords.Add("Nothing");
base.keywords.Add("NotInheritable");
base.keywords.Add("NotOverridable");
base.keywords.Add("Object");
base.keywords.Add("On");
base.keywords.Add("Option");
base.keywords.Add("Optional");
base.keywords.Add("Or");
base.keywords.Add("Else");
base.keywords.Add("Overloads");
base.keywords.Add("Overridable");
base.keywords.Add("Overrides");
base.keywords.Add("ParamArray");
base.keywords.Add("Preserve");
base.keywords.Add("Private");
base.keywords.Add("Property");
base.keywords.Add("Protected");
base.keywords.Add("Public");
base.keywords.Add("RaiseEvent");
base.keywords.Add("ReadOnly");
base.keywords.Add("ReDim");
base.keywords.Add("REM");
base.keywords.Add("RemoveHandler");
base.keywords.Add("Resume");
base.keywords.Add("Return");
base.keywords.Add("Select");
base.keywords.Add("Set");
base.keywords.Add("Shadows");
base.keywords.Add("Shared");
base.keywords.Add("Short");
base.keywords.Add("Single");
base.keywords.Add("Static");
base.keywords.Add("Step");
base.keywords.Add("Stop");
base.keywords.Add("String");
base.keywords.Add("Structure");
base.keywords.Add("Sub");
base.keywords.Add("SyncLock");
base.keywords.Add("Then");
base.keywords.Add("Throw");
base.keywords.Add("To");
base.keywords.Add("True");
base.keywords.Add("Try");
base.keywords.Add("TypeOf");
base.keywords.Add("Unicode");
base.keywords.Add("Until");
base.keywords.Add("Variant");
base.keywords.Add("Wend");
base.keywords.Add("When");
base.keywords.Add("While");
base.keywords.Add("With");
base.keywords.Add("WithEvents");
base.keywords.Add("WriteOnly");
base.keywords.Add("Xor");
base.keywords.Add("print");
base.keywords.Add("println");
this.enum_modifiers = new ModifierList();
this.enum_modifiers.Add(Modifier.New);
this.enum_modifiers.Add(Modifier.Public);
this.enum_modifiers.Add(Modifier.Protected);
this.enum_modifiers.Add(Modifier.Internal);
this.enum_modifiers.Add(Modifier.Private);
this.class_modifiers = new ModifierList();
this.class_modifiers.Add(Modifier.New);
this.class_modifiers.Add(Modifier.Public);
this.class_modifiers.Add(Modifier.Protected);
this.class_modifiers.Add(Modifier.Internal);
this.class_modifiers.Add(Modifier.Private);
this.class_modifiers.Add(Modifier.Abstract);
this.class_modifiers.Add(Modifier.Sealed);
this.class_modifiers.Add(Modifier.Friend);
this.structure_modifiers = new ModifierList();
this.structure_modifiers.Add(Modifier.Public);
this.structure_modifiers.Add(Modifier.Protected);
this.structure_modifiers.Add(Modifier.Internal);
this.structure_modifiers.Add(Modifier.Private);
this.structure_modifiers.Add(Modifier.Friend);
this.structure_modifiers.Add(Modifier.New);
this.interface_modifiers = new ModifierList();
this.interface_modifiers.Add(Modifier.New);
this.interface_modifiers.Add(Modifier.Public);
this.interface_modifiers.Add(Modifier.Protected);
this.interface_modifiers.Add(Modifier.Internal);
this.interface_modifiers.Add(Modifier.Private);
this.interface_modifiers.Add(Modifier.Friend);
this.event_modifiers = new ModifierList();
this.event_modifiers.Add(Modifier.Public);
this.event_modifiers.Add(Modifier.Protected);
this.event_modifiers.Add(Modifier.Internal);
this.event_modifiers.Add(Modifier.Private);
this.event_modifiers.Add(Modifier.New);
this.event_modifiers.Add(Modifier.Static);
this.method_modifiers = new ModifierList();
this.method_modifiers.Add(Modifier.Public);
this.method_modifiers.Add(Modifier.Protected);
this.method_modifiers.Add(Modifier.Internal);
this.method_modifiers.Add(Modifier.Private);
this.method_modifiers.Add(Modifier.New);
this.method_modifiers.Add(Modifier.Static);
this.method_modifiers.Add(Modifier.Virtual);
this.method_modifiers.Add(Modifier.Sealed);
this.method_modifiers.Add(Modifier.Abstract);
this.method_modifiers.Add(Modifier.Override);
this.method_modifiers.Add(Modifier.Overloads);
this.method_modifiers.Add(Modifier.Friend);
this.method_modifiers.Add(Modifier.Shadows);
this.property_modifiers = this.method_modifiers.Clone();
this.property_modifiers.Add(Modifier.Default);
this.property_modifiers.Add(Modifier.ReadOnly);
this.property_modifiers.Add(Modifier.WriteOnly);
this.constructor_modifiers = new ModifierList();
this.constructor_modifiers.Add(Modifier.Public);
this.constructor_modifiers.Add(Modifier.Protected);
this.constructor_modifiers.Add(Modifier.Internal);
this.constructor_modifiers.Add(Modifier.Private);
this.constructor_modifiers.Add(Modifier.Static);
this.constructor_modifiers.Add(Modifier.Friend);
this.delegate_modifiers = new ModifierList();
this.delegate_modifiers.Add(Modifier.Public);
this.delegate_modifiers.Add(Modifier.Protected);
this.delegate_modifiers.Add(Modifier.Internal);
this.delegate_modifiers.Add(Modifier.Private);
this.delegate_modifiers.Add(Modifier.Static);
this.delegate_modifiers.Add(Modifier.Friend);
this.delegate_modifiers.Add(Modifier.Shadows);
this.integral_types = new CSLite_Types();
this.integral_types.Add("Byte", StandardType.Byte);
this.integral_types.Add("Short", StandardType.Short);
this.integral_types.Add("Integer", StandardType.Int);
this.integral_types.Add("Long", StandardType.Long);
this.for_loop_stack = new ForLoopStack();
this.exit_kind_stack = new IntegerStack();
this.with_stack = new IntegerStack();
}
private ClassObject GetCurrentClass(IntegerStack l)
{
for (int i = l.Count - 1; i >= 0; i--)
{
MemberObject memberObject = this.GetMemberObject(l[i]);
if (memberObject.Kind == MemberKind.Type)
{
return (memberObject as ClassObject);
}
}
return null;
}
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;
}
private MemberObject FindType(IntegerStack l, string type_name, bool upcase)
{
int num;
string str = CSLite_System.ExtractPrefixName(type_name, out num);
if (num >= 0)
{
if (str == "bool")
{
str = "Boolean" + type_name.Substring(num);
}
else if (str == "byte")
{
str = "Byte" + type_name.Substring(num);
}
else if (str == "char")
{
str = "Char" + type_name.Substring(num);
}
else if (str == "decimal")
{
str = "Decimal" + type_name.Substring(num);
}
else if (str == "double")
{
str = "double" + type_name.Substring(num);
}
else if (str == "single")
{
str = "Single" + type_name.Substring(num);
}
else if (str == "int")
{
str = "Int32" + type_name.Substring(num);
}
else if (str == "long")
{
str = "Int64" + type_name.Substring(num);
}
else if (str == "sbyte")
{
str = "SByte" + type_name.Substring(num);
}
else if (str == "short")
{
str = "Int16" + type_name.Substring(num);
}
else if (str == "string")
{
str = "String" + type_name.Substring(num);
}
else if (str == "uint")
{
str = "UInt32" + type_name.Substring(num);
}
else if (str == "ulong")
{
str = "UInt64" + type_name.Substring(num);
}
else if (str == "ushort")
{
str = "UInt16" + type_name.Substring(num);
}
else
{
str = type_name;
}
}
string typeName = str;
Type t = Type.GetType(typeName);
if (t == null)
{
t = this.scripter.FindAvailableType(typeName, upcase);
}
if (t != null)
{
int id = this.symbol_table.RegisterType(t, true);
return this.GetMemberObject(id);
}
for (int i = l.Count - 1; i >= 0; i--)
{
int num4 = l[i];
typeName = this.symbol_table[num4].FullName + "." + str;
t = Type.GetType(typeName);
if (t == null)
{
t = this.scripter.FindAvailableType(typeName, upcase);
}
if (t != null)
{
int num5 = this.symbol_table.RegisterType(t, true);
return this.GetMemberObject(num5);
}
}
return null;
}
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;
}
}
}
}
}
public IntegerStack RecreateLevelStack(int init_n)
{
Module module = this.GetModule(init_n);
if (module == null)
{
return null;
}
IntegerStack stack = new IntegerStack();
for (int i = module.P1; i <= module.P2; i++)
{
if (this[i].op == this.OP_CREATE_METHOD)
{
stack.Push(this[i].arg1);
}
else if (this[i].op == this.OP_END_METHOD)
{
stack.Pop();
}
else if (this[i].op == this.OP_BEGIN_USING)
{
stack.Push(this[i].arg1);
}
else if (this[i].op == this.OP_END_USING)
{
stack.Pop();
}
if (i == init_n)
{
return stack;
}
}
return stack;
}
public void ProcessEvalType(IntegerStack l)
{
bool upcase = this.GetUpcase();
int nameIndex = this.symbol_table[this.r.res].NameIndex;
string name = this.symbol_table[this.r.res].Name;
if (this.scripter.IsStandardType(this.r.res))
{
if (this.NextInstruction(this.n).op == this.OP_CREATE_TYPE_REFERENCE)
{
name = name + "." + this.symbol_table[this.NextInstruction(this.n).res].Name;
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[] { name });
}
else
{
this.r.op = this.OP_NOP;
}
return;
}
MemberObject memberByNameIndex = null;
for (int i = l.Count - 1; i >= 0; i--)
{
MemberObject memberObject = this.GetMemberObject(l[i]);
if (memberObject.Kind == MemberKind.Type)
{
if (memberObject.NameIndex == nameIndex)
{
memberByNameIndex = memberObject;
break;
}
memberByNameIndex = memberObject.GetMemberByNameIndex(nameIndex, upcase);
if (memberByNameIndex != null)
{
if (memberByNameIndex.Kind == MemberKind.Alias)
{
int id = memberByNameIndex.Id;
while (this.symbol_table[id].Kind == MemberKind.Alias)
{
memberByNameIndex = this.GetMemberObject(id);
id = this[memberByNameIndex.PCodeLine].res;
}
memberByNameIndex = this.GetMemberObject(id);
nameIndex = memberByNameIndex.NameIndex;
}
if ((memberByNameIndex.Kind == MemberKind.Type) && ((memberByNameIndex.NameIndex == nameIndex) || (upcase && (memberByNameIndex != null))))
{
break;
}
}
}
}
if (memberByNameIndex == null)
{
int startIndex = CSLite_System.PosCh('[', name);
if (startIndex > 0)
{
if (this.GetClassObject(this.r.arg1).Imported)
{
memberByNameIndex = this.FindType(l, name, upcase);
}
if (memberByNameIndex == null)
{
string str2 = "Object" + name.Substring(startIndex);
memberByNameIndex = this.FindType(l, str2, upcase);
if (memberByNameIndex != null)
{
int num5 = this.symbol_table.AppVar();
this.symbol_table[num5].Name = name;
this.symbol_table[num5].Kind = MemberKind.Type;
int num6 = 0;
ClassObject obj5 = new ClassObject(this.scripter, num5, num6, ClassKind.Array);
obj5.Imported = true;
obj5.ImportedType = (memberByNameIndex as ClassObject).ImportedType;
obj5.RType = (memberByNameIndex as ClassObject).ImportedType;
this.PutVal(num5, obj5);
this.GetClassObject(num6).AddMember(obj5);
memberByNameIndex = obj5;
}
}
}
}
if (memberByNameIndex == null)
{
memberByNameIndex = this.FindType(l, name, upcase);
}
if (memberByNameIndex == 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[] { name });
return;
}
this.r.op = this.OP_NOP;
Label_02F4:
this.n++;
ProgRec rec = (ProgRec) this.prog[this.n];
if (rec.op == this.OP_SEPARATOR)
{
goto Label_02F4;
}
if (rec.op == this.OP_CREATE_TYPE_REFERENCE)
{
this.r.op = this.OP_NOP;
this.r = (ProgRec) this.prog[this.n];
MemberObject obj7 = this.GetMemberObject(memberByNameIndex.Id);
if (obj7.Kind != MemberKind.Type)
{
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[] { name });
}
else
{
nameIndex = this.symbol_table[this.r.res].NameIndex;
memberByNameIndex = obj7.GetMemberByNameIndex(nameIndex, upcase);
if (memberByNameIndex != null)
{
goto Label_02F4;
}
name = this.symbol_table[this.r.res].FullName;
if (memberByNameIndex == null)
{
memberByNameIndex = this.FindType(l, name, upcase);
}
if (memberByNameIndex != null)
{
goto Label_02F4;
}
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[] { name });
}
}
if (memberByNameIndex != null)
{
this.scripter.CheckForbiddenType(memberByNameIndex.Id);
}
this.r.op = this.OP_NOP;
if (!this.scripter.IsError())
{
this.ReplaceIdEx(this.r.res, memberByNameIndex.Id, this.n, true);
}
}
public void ProcessEvalOp(IntegerStack l)
{
bool upcase = this.GetUpcase();
int nameIndex = this.symbol_table[this.r.res].NameIndex;
int res = this.r.res;
string name = this.symbol_table[res].Name;
MemberObject memberByNameIndex = null;
for (int i = l.Count - 1; i >= 0; i--)
{
MemberObject memberObject = this.GetMemberObject(l[i]);
memberByNameIndex = memberObject.GetMemberByNameIndex(nameIndex, upcase);
if ((memberByNameIndex != null) && ((memberByNameIndex.Kind != MemberKind.Constructor) || (i == (l.Count - 1))))
{
int id = l.Peek();
MemberObject obj4 = this.GetMemberObject(id);
if (obj4.Static)
{
if (memberByNameIndex.Static)
{
this.r.op = this.OP_NOP;
this.ReplaceIdEx(this.r.res, memberByNameIndex.Id, this.n, true);
break;
}
if (this.GetCurrentClass(l).IsOuterMemberId(memberByNameIndex.Id))
{
this.scripter.CreateErrorObjectEx("CS0038. Cannot access a nonstatic member of outer type '{0}' via nested type '{1}'.", new object[] { memberObject.Name, this.GetCurrentClass(l).Name });
break;
}
memberByNameIndex = null;
}
else
{
if (memberByNameIndex.Static)
{
this.r.op = this.OP_NOP;
this.ReplaceIdEx(this.r.res, memberByNameIndex.Id, this.n, true);
}
else if (this.GetCurrentClass(l).IsOuterMemberId(memberByNameIndex.Id))
{
this.scripter.CreateErrorObjectEx("CS0038. Cannot access a nonstatic member of outer type '{0}' via nested type '{1}'.", new object[] { memberObject.Name, this.GetCurrentClass(l).Name });
}
else if (obj4.Kind == MemberKind.Type)
{
this.r.op = this.OP_NOP;
}
else
{
FunctionObject obj5 = (FunctionObject) obj4;
this.r.op = this.OP_CREATE_REFERENCE;
this.r.arg1 = obj5.ThisId;
this.symbol_table[this.r.res].Level = this.r.arg1;
this.symbol_table[this.r.res].Kind = MemberKind.Ref;
this.symbol_table[this.r.res].TypeId = this.symbol_table[memberByNameIndex.Id].TypeId;
}
break;
}
}
}
if (memberByNameIndex == null)
{
memberByNameIndex = this.FindType(l, name, upcase);
if (memberByNameIndex != null)
{
this.r.op = this.OP_NOP;
this.ReplaceIdEx(this.r.res, memberByNameIndex.Id, this.n, true);
}
else if (this.symbol_table[res].Kind == MemberKind.Label)
{
int num5 = this.EvalLabel(res);
if (num5 == 0)
{
this.scripter.CreateErrorObjectEx("Undeclared identifier '{0}'", new object[] { name });
}
else
{
this.r.op = this.OP_NOP;
this.ReplaceIdEx(this.r.res, num5, this.n, true);
}
}
else
{
bool flag2 = false;
if (!this.GetExplicit(this.n))
{
int level = this.symbol_table[this.r.res].Level;
if ((this[this.n + 1].op == this.OP_ASSIGN) && (this[this.n + 1].arg1 == this.r.res))
{
this.r.op = this.OP_DECLARE_LOCAL_VARIABLE;
this.r.arg1 = this.r.res;
this.r.arg2 = level;
flag2 = true;
}
else
{
string str2 = this.symbol_table[this.r.res].Name;
for (int j = this.n; j >= 1; j--)
{
if (this[j].op == this.OP_DECLARE_LOCAL_VARIABLE)
{
if (this[j].arg2 != level)
{
break;
}
int num8 = this[j].arg1;
string str3 = this.symbol_table[num8].Name;
if (CSLite_System.CompareStrings(str2, str3, upcase))
{
this.r.op = this.OP_NOP;
this.ReplaceId(this.r.res, num8);
flag2 = true;
break;
}
}
}
}
}
if (!flag2)
{
if (this.PascalOrBasic(this.n))
{
for (int k = 1; k <= this.card; k++)
{
if (this[k].op == this.OP_CREATE_CLASS)
{
ClassObject classObject = this.GetClassObject(this[k].arg1);
if (classObject.Static)
{
memberByNameIndex = classObject.GetMemberByNameIndex(nameIndex, upcase);
if (memberByNameIndex != null)
{
this.r.op = this.OP_NOP;
this.ReplaceId(this.r.res, memberByNameIndex.Id);
return;
}
}
}
}
}
if (this.scripter.DefaultInstanceMethods)
{
foreach (string str4 in this.scripter.UserInstances.Keys)
{
Type t = this.scripter.UserInstances[str4].GetType();
foreach (MethodInfo info in t.GetMethods())
{
if (!CSLite_System.CompareStrings(name, info.Name, upcase))
{
continue;
}
int num10 = 0;
for (int m = 1; m <= this.symbol_table.Card; m++)
{
if (((this.symbol_table[m].Level == 0) && (this.symbol_table[m].Kind == MemberKind.Var)) && (CSLite_System.CompareStrings(this.symbol_table[m].Name, str4, upcase) && (this.symbol_table[m].Val != null)))
{
num10 = m;
break;
}
}
if (num10 != 0)
{
int num12 = this.symbol_table.RegisterType(t, false);
this.r.op = this.OP_CREATE_REFERENCE;
this.r.arg1 = num10;
this.symbol_table[this.r.res].Level = this.r.arg1;
this.symbol_table[this.r.res].Kind = MemberKind.Ref;
this.symbol_table[this.r.res].TypeId = num12;
return;
}
}
foreach (PropertyInfo info2 in t.GetProperties())
{
if (!CSLite_System.CompareStrings(name, info2.Name, upcase))
{
continue;
}
int num13 = 0;
for (int n = 1; n <= this.symbol_table.Card; n++)
{
if (((this.symbol_table[n].Level == 0) && (this.symbol_table[n].Kind == MemberKind.Var)) && (CSLite_System.CompareStrings(this.symbol_table[n].Name, str4, upcase) && (this.symbol_table[n].Val != null)))
{
num13 = n;
break;
}
}
if (num13 != 0)
{
int num15 = this.symbol_table.RegisterType(t, false);
this.r.op = this.OP_CREATE_REFERENCE;
this.r.arg1 = num13;
this.symbol_table[this.r.res].Level = this.r.arg1;
this.symbol_table[this.r.res].Kind = MemberKind.Ref;
this.symbol_table[this.r.res].TypeId = num15;
return;
}
}
}
}
this.scripter.CreateErrorObjectEx("Undeclared identifier '{0}'", new object[] { name });
}
}
}
}
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++;
}
}
