diff options
Diffstat (limited to 'runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs')
| -rw-r--r-- | runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs | 2621 |
1 files changed, 2621 insertions, 0 deletions
diff --git a/runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs b/runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs new file mode 100644 index 0000000..0e60298 --- /dev/null +++ b/runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs @@ -0,0 +1,2621 @@ +using System; +using System.Linq; +using System.Reflection; + +namespace UnitTestProject.RefVm +{ + // Token: 0x02000059 RID: 89 + internal abstract class VariantBase // \u000F + { + // Token: 0x0600034A RID: 842 + public abstract object GetValueAbstract(); // \u000F\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x0600034B RID: 843 + public abstract void SetValueAbstract(object o); // \u000F\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x0600034C RID: 844 + public enum Vtc + { + Tc0VariantBaseHolder, + Tc1Bool, + Tc2Array, + Tc3Method, + Tc4FieldInfo, + Tc5Enum, + Tc6Char, + Tc7Ulong, + Tc8Float, + Tc9Uint, + Tc10Ushort, + Tc11ValueType, + Tc12Sbyte, + Tc13UIntPtr, + Tc14Byte, + Tc15Short, + Tc16String, + Tc17IntPtr, + Tc18Object, + Tc19Int, + Tc20MdArrayValue, + Tc21Double, + Tc22SdArrayValue, + Tc23LocalsIdxHolder, + Tc24Long + } + + public abstract Vtc GetTypeCode(); // \u000F\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x0600034D RID: 845 + public abstract VariantBase CopyFrom(VariantBase t); // \u000F\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x0600034E RID: 846 + public abstract VariantBase Clone(); // \u000F\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x0600034F RID: 847 RVA: 0x000153EC File Offset: 0x000135EC + public virtual bool IsAddr() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return false; + } + + // Token: 0x06000350 RID: 848 RVA: 0x000153F0 File Offset: 0x000135F0 + public Type GetVariantType() // \u0002 + { + return _type; + } + + // Token: 0x06000351 RID: 849 RVA: 0x000153F8 File Offset: 0x000135F8 + public void SetVariantType(Type val) // \u0002 + { + _type = val; + } + + // Token: 0x04000186 RID: 390 + private Type _type; // \u0002 + + // bug was fixed and unit tested (было превращение Enum в число без учета переполнения) + public static long SignedLongFromEnum(EnumVariant src) + { + var val = src.GetValue(); + switch (Convert.GetTypeCode(val)) + { + /*case TypeCode.SByte: + case TypeCode.Int16: + case TypeCode.Int32: + case TypeCode.Int64:*/ + default: + return Convert.ToInt64(val); + case TypeCode.Byte: + case TypeCode.UInt16: + case TypeCode.UInt32: + case TypeCode.UInt64: + return (long)Convert.ToUInt64(val); + } + } + + public static VariantBase SignedVariantFromEnum(EnumVariant src) + { + var val = src.GetValue(); + switch (Convert.GetTypeCode(val)) + { + case TypeCode.SByte: + case TypeCode.Int16: + case TypeCode.Int32: + var i = Convert.ToInt32(val); + var reti = new IntVariant(); + reti.SetValue(i); + return reti; + case TypeCode.Int64: + var l = Convert.ToInt64(val); + var retl = new LongVariant(); + retl.SetValue(l); + return retl; + case TypeCode.Byte: + case TypeCode.UInt16: + case TypeCode.UInt32: + var u = Convert.ToUInt32(val); + var retu = new IntVariant(); + retu.SetValue((int)u); + return retu; + //case TypeCode.UInt64: + default: + var ul = Convert.ToUInt64(val); + var retul = new LongVariant(); + retul.SetValue((long)ul); + return retul; + } + } + } + // Token: 0x02000003 RID: 3 + internal sealed class ArrayVariant : VariantBase // \u0002\u2000 + { + // Token: 0x06000009 RID: 9 RVA: 0x000021A8 File Offset: 0x000003A8 + public Array GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600000A RID: 10 RVA: 0x000021B0 File Offset: 0x000003B0 + public void SetValue(Array val) // \u0002 + { + _value = val; + } + + // Token: 0x0600000B RID: 11 RVA: 0x000021BC File Offset: 0x000003BC + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x0600000C RID: 12 RVA: 0x000021C4 File Offset: 0x000003C4 + public override void SetValueAbstract(object o) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue((Array)o); + } + + // Token: 0x0600000D RID: 13 RVA: 0x000021D4 File Offset: 0x000003D4 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new ArrayVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetType()); + return ret; + } + + // Token: 0x0600000E RID: 14 RVA: 0x000021F4 File Offset: 0x000003F4 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc2Array; + } + + // Token: 0x0600000F RID: 15 RVA: 0x000021F8 File Offset: 0x000003F8 + public override VariantBase CopyFrom(VariantBase src) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(src.GetVariantType()); + var num = src.GetTypeCode(); + if (num != Vtc.Tc2Array) + { + if (num != Vtc.Tc18Object) + { + throw new ArgumentOutOfRangeException(); + } + SetValue((Array)((ObjectVariant)src).GetValue()); + } + else + { + SetValue(((ArrayVariant)src).GetValue()); + } + return this; + } + + // Token: 0x04000001 RID: 1 + private Array _value; // \u0002 + } + + // Token: 0x0200002B RID: 43 + internal sealed class ObjectVariant : VariantBase // \u0006\u2002 + { + // Token: 0x0600013E RID: 318 RVA: 0x00006458 File Offset: 0x00004658 + public object GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600013F RID: 319 RVA: 0x00006460 File Offset: 0x00004660 + public void SetValue(object val) // \u0002 + { + _value = val; + } + + // Token: 0x06000140 RID: 320 RVA: 0x0000646C File Offset: 0x0000466C + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000141 RID: 321 RVA: 0x00006474 File Offset: 0x00004674 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue(val); + } + + // Token: 0x06000142 RID: 322 RVA: 0x00006480 File Offset: 0x00004680 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc18Object; + } + + // Token: 0x06000143 RID: 323 RVA: 0x00006484 File Offset: 0x00004684 + public override VariantBase CopyFrom(VariantBase src) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(src.GetVariantType()); + SetValue(src.GetValueAbstract()); + return this; + } + + // Token: 0x06000144 RID: 324 RVA: 0x000064AC File Offset: 0x000046AC + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new ObjectVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0400004E RID: 78 + private object _value; + } + + // Token: 0x02000004 RID: 4 + internal sealed class ShortVariant : VariantBase + { + // Token: 0x06000011 RID: 17 RVA: 0x00002260 File Offset: 0x00000460 + public short GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000012 RID: 18 RVA: 0x00002268 File Offset: 0x00000468 + public void SetValue(short val) // \u0002 + { + _value = val; + } + + // Token: 0x06000013 RID: 19 RVA: 0x00002274 File Offset: 0x00000474 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000014 RID: 20 RVA: 0x00002284 File Offset: 0x00000484 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is int) + { + SetValue((short)(int)val); + return; + } + if (val is long) + { + SetValue((short)(long)val); + return; + } + if (val is ushort) + { + SetValue((short)(ushort)val); + return; + } + if (val is uint) + { + SetValue((short)(uint)val); + return; + } + if (val is ulong) + { + SetValue((short)(ulong)val); + return; + } + if (val is float) + { + SetValue((short)(float)val); + return; + } + if (val is double) + { + SetValue((short)(double)val); + return; + } + SetValue(Convert.ToInt16(val)); + } + + // Token: 0x06000015 RID: 21 RVA: 0x00002338 File Offset: 0x00000538 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new ShortVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000016 RID: 22 RVA: 0x00002358 File Offset: 0x00000558 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc15Short; + } + + // Token: 0x06000017 RID: 23 RVA: 0x0000235C File Offset: 0x0000055C + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToInt16(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((short)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((short)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue((short)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue((short)((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue(((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue(((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((short)(int)((IntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToInt16(((ObjectVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((short)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((short)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((short)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000002 RID: 2 + private short _value; // \u0002 + } + + // Token: 0x02000005 RID: 5 + internal sealed class MethodVariant : VariantBase // \u0002\u2002 + { + // Token: 0x06000019 RID: 25 RVA: 0x00002538 File Offset: 0x00000738 + public MethodBase GetValue() //\u0002 + { + return _value; + } + + // Token: 0x0600001A RID: 26 RVA: 0x00002540 File Offset: 0x00000740 + public void SetValue(MethodBase val) //\u0002 + { + _value = val; + } + + // Token: 0x0600001B RID: 27 RVA: 0x0000254C File Offset: 0x0000074C + public IntPtr GetFunctionPointer() // \u0002 + { + return GetValue().MethodHandle.GetFunctionPointer(); + } + + // Token: 0x0600001C RID: 28 RVA: 0x0000256C File Offset: 0x0000076C + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x0600001D RID: 29 RVA: 0x00002574 File Offset: 0x00000774 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue((MethodBase)val); + } + + // Token: 0x0600001E RID: 30 RVA: 0x00002584 File Offset: 0x00000784 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc3Method; + } + + // Token: 0x0600001F RID: 31 RVA: 0x00002588 File Offset: 0x00000788 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num == Vtc.Tc3Method) + { + SetValue(((MethodVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x06000020 RID: 32 RVA: 0x000025C8 File Offset: 0x000007C8 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new MethodVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000003 RID: 3 + private MethodBase _value; + } + + // Token: 0x02000008 RID: 8 + internal sealed class StringVariant : VariantBase // \u0002\u2005 + { + // Token: 0x0600002B RID: 43 RVA: 0x000026BC File Offset: 0x000008BC + public string GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600002C RID: 44 RVA: 0x000026C4 File Offset: 0x000008C4 + public void SetValue(string val) // \u0002 + { + _value = val; + } + + // Token: 0x0600002D RID: 45 RVA: 0x000026D0 File Offset: 0x000008D0 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x0600002E RID: 46 RVA: 0x000026D8 File Offset: 0x000008D8 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue((string)val); + } + + // Token: 0x0600002F RID: 47 RVA: 0x000026E8 File Offset: 0x000008E8 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc16String; + } + + // Token: 0x06000030 RID: 48 RVA: 0x000026EC File Offset: 0x000008EC + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num != Vtc.Tc16String) + { + if (num != Vtc.Tc18Object) + { + throw new ArgumentOutOfRangeException(); + } + SetValue((string)((ObjectVariant)val).GetValue()); + } + else + { + SetValue(((StringVariant)val).GetValue()); + } + return this; + } + + // Token: 0x06000031 RID: 49 RVA: 0x0000274C File Offset: 0x0000094C + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new StringVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000007 RID: 7 + private string _value; + } + + // Token: 0x0200000F RID: 15 + internal sealed class BoolVariant : VariantBase // \u0003\u2000 + { + // Token: 0x06000062 RID: 98 RVA: 0x00003470 File Offset: 0x00001670 + public bool GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000063 RID: 99 RVA: 0x00003478 File Offset: 0x00001678 + public void SetValue(bool val) // \u0002 + { + _value = val; + } + + // Token: 0x06000064 RID: 100 RVA: 0x00003484 File Offset: 0x00001684 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000065 RID: 101 RVA: 0x00003494 File Offset: 0x00001694 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue(Convert.ToBoolean(val)); + } + + // Token: 0x06000066 RID: 102 RVA: 0x000034A4 File Offset: 0x000016A4 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc1Bool; + } + + // Token: 0x06000067 RID: 103 RVA: 0x000034A8 File Offset: 0x000016A8 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(((BoolVariant)val).GetValue()); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToBoolean(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue(Convert.ToBoolean(((UlongVariant)val).GetValue())); + return this; + case Vtc.Tc9Uint: + SetValue(Convert.ToBoolean(((UintVariant)val).GetValue())); + return this; + case Vtc.Tc10Ushort: + SetValue(Convert.ToBoolean(((UshortVariant)val).GetValue())); + return this; + case Vtc.Tc12Sbyte: + SetValue(Convert.ToBoolean(((SbyteVariant)val).GetValue())); + return this; + case Vtc.Tc13UIntPtr: + SetValue(Convert.ToBoolean(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue(Convert.ToBoolean(((ByteVariant)val).GetValue())); + return this; + case Vtc.Tc15Short: + SetValue(Convert.ToBoolean(((ShortVariant)val).GetValue())); + return this; + case Vtc.Tc17IntPtr: + SetValue(Convert.ToBoolean(((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToBoolean(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue(Convert.ToBoolean(((IntVariant)val).GetValue())); + return this; + case Vtc.Tc24Long: + SetValue(Convert.ToBoolean(((LongVariant)val).GetValue())); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x06000068 RID: 104 RVA: 0x00003694 File Offset: 0x00001894 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new BoolVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000017 RID: 23 + private bool _value; + } + + // Token: 0x02000010 RID: 16 + internal sealed class IntVariant : VariantBase // \u0003\u2001 + { + // Token: 0x0600006A RID: 106 RVA: 0x000036BC File Offset: 0x000018BC + public int GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600006B RID: 107 RVA: 0x000036C4 File Offset: 0x000018C4 + public void SetValue(int val) // \u0002 + { + + _value = val; + } + + // Token: 0x0600006C RID: 108 RVA: 0x000036D0 File Offset: 0x000018D0 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x0600006D RID: 109 RVA: 0x000036E0 File Offset: 0x000018E0 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is long) + { + SetValue((int)((long)val)); + return; + } + if (val is ushort) + { + SetValue((ushort)val); + return; + } + if (val is uint) + { + SetValue((int)((uint)val)); + return; + } + if (val is ulong) + { + SetValue((int)((ulong)val)); + return; + } + if (val is float) + { + SetValue((int)((float)val)); + return; + } + if (val is double) + { + SetValue((int)((double)val)); + return; + } + SetValue(Convert.ToInt32(val)); + } + + // Token: 0x0600006E RID: 110 RVA: 0x0000377C File Offset: 0x0000197C + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new IntVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0600006F RID: 111 RVA: 0x0000379C File Offset: 0x0000199C + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc19Int; + } + + // Token: 0x06000070 RID: 112 RVA: 0x000037A0 File Offset: 0x000019A0 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToInt32(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((int)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((int)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue((int)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue(((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((int)((uint)((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue(((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((int)((IntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToInt32(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue(((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((int)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue(Convert.ToInt32(((LongVariant)val).GetValue())); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000018 RID: 24 + private int _value; + } + + // Token: 0x02000011 RID: 17 + internal sealed class IntPtrVariant : VariantBase // \u0003\u2002 + { + // Token: 0x06000072 RID: 114 RVA: 0x00003998 File Offset: 0x00001B98 + public IntPtr GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000073 RID: 115 RVA: 0x000039A0 File Offset: 0x00001BA0 + public void SetValue(IntPtr val) // \u0002 + { + _value = val; + } + + // Token: 0x06000074 RID: 116 RVA: 0x000039AC File Offset: 0x00001BAC + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new IntPtrVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000075 RID: 117 RVA: 0x000039CC File Offset: 0x00001BCC + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000076 RID: 118 RVA: 0x000039DC File Offset: 0x00001BDC + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue((IntPtr)val); + } + + // Token: 0x06000077 RID: 119 RVA: 0x000039EC File Offset: 0x00001BEC + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc17IntPtr; + } + + // Token: 0x06000078 RID: 120 RVA: 0x000039F0 File Offset: 0x00001BF0 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc3Method: + { + var mv = (MethodVariant)val; + SetValue(mv.GetFunctionPointer()); + return this; + } + case Vtc.Tc5Enum: + SetValue(new IntPtr(Convert.ToInt64(((EnumVariant)val).GetValue()))); + return this; + case Vtc.Tc7Ulong: + SetValue((IntPtr)((long)((UlongVariant)val).GetValue())); + return this; + case Vtc.Tc8Float: + SetValue((IntPtr)((long)((FloatVariant)val).GetValue())); + return this; + case Vtc.Tc9Uint: + SetValue((IntPtr)((long)((UintVariant)val).GetValue())); + return this; + case Vtc.Tc10Ushort: + SetValue((IntPtr)((int)((UshortVariant)val).GetValue())); + return this; + case Vtc.Tc12Sbyte: + SetValue((IntPtr)((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue((IntPtr)((int)((ByteVariant)val).GetValue())); + return this; + case Vtc.Tc15Short: + SetValue((IntPtr)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue(((IntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue((IntPtr)((UIntPtrVariant)val).GetValue().ToUInt64()); + return this; + case Vtc.Tc19Int: + SetValue((IntPtr)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((IntPtr)((long)((DoubleVariant)val).GetValue())); + return this; + case Vtc.Tc24Long: + SetValue((IntPtr)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000019 RID: 25 + private IntPtr _value; + } + + // Token: 0x02000014 RID: 20 + internal sealed class ValueTypeVariant : VariantBase // \u0003\u2005 + { + // Token: 0x06000086 RID: 134 RVA: 0x00003CF0 File Offset: 0x00001EF0 + public ValueTypeVariant(object val) + { + if (val != null && !(val is ValueType)) + { + throw new ArgumentException(); + } + _value = val; + } + + // Token: 0x06000087 RID: 135 RVA: 0x00003D10 File Offset: 0x00001F10 + public object GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000088 RID: 136 RVA: 0x00003D18 File Offset: 0x00001F18 + public void SetValue(object val) // \u0002 + { + if (val != null && !(val is ValueType)) + { + throw new ArgumentException(); + } + _value = val; + } + + // Token: 0x06000089 RID: 137 RVA: 0x00003D34 File Offset: 0x00001F34 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x0600008A RID: 138 RVA: 0x00003D3C File Offset: 0x00001F3C + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue(val); + } + + // Token: 0x0600008B RID: 139 RVA: 0x00003D48 File Offset: 0x00001F48 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc11ValueType; + } + + // Token: 0x0600008C RID: 140 RVA: 0x00003D4C File Offset: 0x00001F4C + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num != Vtc.Tc11ValueType) + { + if (num != Vtc.Tc18Object) + { + SetValue(val.GetTypeCode()); + } + else + { + SetValue(((UIntPtrVariant)val).GetValue()); + } + } + else if (GetValue() != null) + { + var obj = ((ValueTypeVariant)val).GetValue(); + var type = GetValue().GetType(); + // ReSharper disable once UseMethodIsInstanceOfType + if (obj != null && !type.IsPrimitive && !type.IsEnum && type.IsAssignableFrom(obj.GetType())) + { + var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); + foreach (var fieldInfo in fields) + { + fieldInfo.SetValue(GetValue(), fieldInfo.GetValue(obj)); + } + } + else + { + SetValue(obj); + } + } + else + { + SetValue(((ValueTypeVariant)val).GetValue()); + } + return this; + } + + // Token: 0x0600008D RID: 141 RVA: 0x00003E38 File Offset: 0x00002038 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new ValueTypeVariant(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0400001D RID: 29 + private object _value; + } + + // Token: 0x0200001C RID: 28 + internal sealed class CharVariant : VariantBase // \u0005\u2000 + { + // Token: 0x060000A9 RID: 169 RVA: 0x000042D0 File Offset: 0x000024D0 + public char GetValue() // \u0002 + { + return _value; + } + + // Token: 0x060000AA RID: 170 RVA: 0x000042D8 File Offset: 0x000024D8 + public void SetValue(char val) // \u0002 + { + _value = val; + } + + // Token: 0x060000AB RID: 171 RVA: 0x000042E4 File Offset: 0x000024E4 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x060000AC RID: 172 RVA: 0x000042F4 File Offset: 0x000024F4 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue(Convert.ToChar(val)); + } + + // Token: 0x060000AD RID: 173 RVA: 0x00004304 File Offset: 0x00002504 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc6Char; + } + + // Token: 0x060000AE RID: 174 RVA: 0x00004308 File Offset: 0x00002508 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToChar(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToChar(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc6Char: + SetValue(((CharVariant)val).GetValue()); + return this; + case Vtc.Tc7Ulong: + SetValue((char)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue((char)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue((char)((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue((char)((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((char)((uint)((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue((char)((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue((char)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((char)((int)((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToChar(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((char)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((char)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x060000AF RID: 175 RVA: 0x000044E0 File Offset: 0x000026E0 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new CharVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000026 RID: 38 + private char _value; + } + + // Token: 0x0200001D RID: 29 + internal sealed class LongVariant : VariantBase // \u0005\u2001 + { + // Token: 0x060000B1 RID: 177 RVA: 0x00004508 File Offset: 0x00002708 + public long GetValue() // \u0002 + { + return _value; + } + + // Token: 0x060000B2 RID: 178 RVA: 0x00004510 File Offset: 0x00002710 + public void SetValue(long val) // \u0002 + { + _value = val; + } + + // Token: 0x060000B3 RID: 179 RVA: 0x0000451C File Offset: 0x0000271C + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x060000B4 RID: 180 RVA: 0x0000452C File Offset: 0x0000272C + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is ulong) + { + SetValue((long)((ulong)val)); + return; + } + if (val is float) + { + SetValue((long)((float)val)); + return; + } + if (val is double) + { + SetValue((long)((double)val)); + return; + } + SetValue(Convert.ToInt64(val)); + } + + // Token: 0x060000B5 RID: 181 RVA: 0x00004588 File Offset: 0x00002788 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new LongVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x060000B6 RID: 182 RVA: 0x000045A8 File Offset: 0x000027A8 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc24Long; + } + + // Token: 0x060000B7 RID: 183 RVA: 0x000045AC File Offset: 0x000027AC + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToInt64(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((long)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((long)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue(((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue(((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((long)((ulong)((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue(((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((long)((IntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToInt64(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue(((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((long)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue(((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000027 RID: 39 + private long _value; + } + + // Token: 0x0200001E RID: 30 + internal sealed class UIntPtrVariant : VariantBase // \u0005\u2002 + { + // Token: 0x060000B9 RID: 185 RVA: 0x000047A4 File Offset: 0x000029A4 + public UIntPtr GetValue() // \u0002 + { + return _value; + } + + // Token: 0x060000BA RID: 186 RVA: 0x000047AC File Offset: 0x000029AC + public void SetValue(UIntPtr val) // \u0002 + { + _value = val; + } + + // Token: 0x060000BB RID: 187 RVA: 0x000047B8 File Offset: 0x000029B8 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new UIntPtrVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x060000BC RID: 188 RVA: 0x000047D8 File Offset: 0x000029D8 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x060000BD RID: 189 RVA: 0x000047E8 File Offset: 0x000029E8 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue((UIntPtr)val); + } + + // Token: 0x060000BE RID: 190 RVA: 0x000047F8 File Offset: 0x000029F8 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc13UIntPtr; + } + + // Token: 0x060000BF RID: 191 RVA: 0x000047FC File Offset: 0x000029FC + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc5Enum: + SetValue(new UIntPtr(Convert.ToUInt64(((EnumVariant)val).GetValue()))); + return this; + case Vtc.Tc7Ulong: + SetValue((UIntPtr)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((UIntPtr)((ulong)((FloatVariant)val).GetValue())); + return this; + case Vtc.Tc9Uint: + SetValue((UIntPtr)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue((UIntPtr)((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue(((UIntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue((UIntPtr)((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue(((UIntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc19Int: + SetValue((UIntPtr)((ulong)((IntVariant)val).GetValue())); + return this; + case Vtc.Tc21Double: + SetValue((UIntPtr)((ulong)((DoubleVariant)val).GetValue())); + return this; + case Vtc.Tc24Long: + SetValue((UIntPtr)((ulong)((LongVariant)val).GetValue())); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000028 RID: 40 + private UIntPtr _value; + } + + // Token: 0x02000029 RID: 41 + internal sealed class DoubleVariant : VariantBase // \u0006\u2000 + { + // Token: 0x0600012E RID: 302 RVA: 0x00005F98 File Offset: 0x00004198 + public double GetValue() + { + return _value; + } + + // Token: 0x0600012F RID: 303 RVA: 0x00005FA0 File Offset: 0x000041A0 + public void SetValue(double val) + { + _value = val; + } + + // Token: 0x06000130 RID: 304 RVA: 0x00005FAC File Offset: 0x000041AC + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000131 RID: 305 RVA: 0x00005FBC File Offset: 0x000041BC + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue(Convert.ToDouble(val)); + } + + // Token: 0x06000132 RID: 306 RVA: 0x00005FCC File Offset: 0x000041CC + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new DoubleVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000133 RID: 307 RVA: 0x00005FEC File Offset: 0x000041EC + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc21Double; + } + + // Token: 0x06000134 RID: 308 RVA: 0x00005FF0 File Offset: 0x000041F0 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc7Ulong: + SetValue(((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue(((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue(((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue(((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue(((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue((double)((UIntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc19Int: + SetValue(((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue(((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue(((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x0400004C RID: 76 + private double _value; + } + + // Token: 0x0200002A RID: 42 + internal sealed class UshortVariant : VariantBase // \u0006\u2001 + { + // Token: 0x06000136 RID: 310 RVA: 0x00006164 File Offset: 0x00004364 + public ushort GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000137 RID: 311 RVA: 0x0000616C File Offset: 0x0000436C + public void SetValue(ushort val) // \u0002 + { + _value = val; + } + + // Token: 0x06000138 RID: 312 RVA: 0x00006178 File Offset: 0x00004378 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000139 RID: 313 RVA: 0x00006188 File Offset: 0x00004388 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is short) + { + SetValue((ushort)((short)val)); + return; + } + if (val is int) + { + SetValue((ushort)((int)val)); + return; + } + if (val is long) + { + SetValue((ushort)((long)val)); + return; + } + if (val is uint) + { + SetValue((ushort)((uint)val)); + return; + } + if (val is ulong) + { + SetValue((ushort)((ulong)val)); + return; + } + if (val is float) + { + SetValue((ushort)((float)val)); + return; + } + if (val is double) + { + SetValue((ushort)((double)val)); + return; + } + SetValue(Convert.ToUInt16(val)); + } + + // Token: 0x0600013A RID: 314 RVA: 0x0000623C File Offset: 0x0000443C + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new UshortVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0600013B RID: 315 RVA: 0x0000625C File Offset: 0x0000445C + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc10Ushort; + } + + // Token: 0x0600013C RID: 316 RVA: 0x00006260 File Offset: 0x00004460 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToUInt16(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((ushort)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((ushort)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue((ushort)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue((ushort)((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((ushort)((uint)((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue((ushort)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((ushort)((int)((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToUInt16(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((ushort)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((ushort)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((ushort)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x0400004D RID: 77 + private ushort _value; + } + + // Token: 0x02000043 RID: 67 + internal sealed class EnumVariant : VariantBase // \u0008\u2000 + { + // Token: 0x060002E6 RID: 742 RVA: 0x00013F1C File Offset: 0x0001211C + public EnumVariant(Enum val) + { + if (val == null) + { + throw new ArgumentException(); + } + _value = val; + } + + // Token: 0x060002E7 RID: 743 RVA: 0x00013F34 File Offset: 0x00012134 + public Enum GetValue() // \u0002 + { + return _value; + } + + // Token: 0x060002E8 RID: 744 RVA: 0x00013F3C File Offset: 0x0001213C + public void SetValue(Enum val) // \u0002 + { + if (val == null) + { + throw new ArgumentException(); + } + _value = val; + } + + // Token: 0x060002E9 RID: 745 RVA: 0x00013F50 File Offset: 0x00012150 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x060002EA RID: 746 RVA: 0x00013F58 File Offset: 0x00012158 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue((Enum)Enum.Parse(GetValue().GetType(), val.ToString())); + } + + // Token: 0x060002EB RID: 747 RVA: 0x00013F88 File Offset: 0x00012188 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc5Enum; + } + + // Token: 0x060002EC RID: 748 RVA: 0x00013F8C File Offset: 0x0001218C + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + switch (num) + { + case Vtc.Tc5Enum: + { + var type = _value.GetType(); + var @enum = ((EnumVariant)val).GetValue(); + if (@enum.GetType() == type) + { + SetValue(@enum); + return this; + } + SetValue((Enum)Enum.ToObject(type, @enum)); + return this; + } + case Vtc.Tc6Char: + case Vtc.Tc8Float: + case Vtc.Tc11ValueType: + case Vtc.Tc13UIntPtr: + case Vtc.Tc16String: + case Vtc.Tc17IntPtr: + break; + case Vtc.Tc7Ulong: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((UlongVariant)val).GetValue())); + return this; + case Vtc.Tc9Uint: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((UintVariant)val).GetValue())); + return this; + case Vtc.Tc10Ushort: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((UshortVariant)val).GetValue())); + return this; + case Vtc.Tc12Sbyte: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((SbyteVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((ByteVariant)val).GetValue())); + return this; + case Vtc.Tc15Short: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((ShortVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((Enum)Enum.ToObject(_value.GetType(), ((IntVariant)val).GetValue())); + return this; + default: + if (num == Vtc.Tc24Long) + { + SetValue((Enum)Enum.ToObject(_value.GetType(), ((LongVariant)val).GetValue())); + return this; + } + break; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x060002ED RID: 749 RVA: 0x000141C0 File Offset: 0x000123C0 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new EnumVariant(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000172 RID: 370 + private Enum _value; + } + + // Token: 0x02000044 RID: 68 + internal sealed class SbyteVariant : VariantBase // \u0008\u2001 + { + // Token: 0x060002EF RID: 751 RVA: 0x000141E4 File Offset: 0x000123E4 + public sbyte GetValue() // \u0002 + { + return _value; + } + + // Token: 0x060002F0 RID: 752 RVA: 0x000141EC File Offset: 0x000123EC + public void SetValue(sbyte val) // \u0002 + { + _value = val; + } + + // Token: 0x060002F1 RID: 753 RVA: 0x000141F8 File Offset: 0x000123F8 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x060002F2 RID: 754 RVA: 0x00014208 File Offset: 0x00012408 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is byte) + { + SetValue((sbyte)((byte)val)); + return; + } + if (val is short) + { + SetValue((sbyte)((short)val)); + return; + } + if (val is int) + { + SetValue((sbyte)((int)val)); + return; + } + if (val is long) + { + SetValue((sbyte)((long)val)); + return; + } + if (val is ushort) + { + SetValue((sbyte)((ushort)val)); + return; + } + if (val is uint) + { + SetValue((sbyte)((uint)val)); + return; + } + if (val is ulong) + { + SetValue((sbyte)((ulong)val)); + return; + } + if (val is float) + { + SetValue((sbyte)((float)val)); + return; + } + if (val is double) + { + SetValue((sbyte)((double)val)); + return; + } + SetValue(Convert.ToSByte(val)); + } + + // Token: 0x060002F3 RID: 755 RVA: 0x000142E8 File Offset: 0x000124E8 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new SbyteVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x060002F4 RID: 756 RVA: 0x00014308 File Offset: 0x00012508 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc12Sbyte; + } + + // Token: 0x060002F5 RID: 757 RVA: 0x0001430C File Offset: 0x0001250C + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToSByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToSByte(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((sbyte)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((sbyte)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue((sbyte)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue((sbyte)((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue(((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue((sbyte)((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue((sbyte)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((sbyte)((int)((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToSByte(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((sbyte)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((sbyte)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((sbyte)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000173 RID: 371 + private sbyte _value; + } + + // Token: 0x0200004E RID: 78 + internal sealed class FloatVariant : VariantBase // \u000E\u2000 + { + // Token: 0x06000326 RID: 806 RVA: 0x00014CA4 File Offset: 0x00012EA4 + public float GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000327 RID: 807 RVA: 0x00014CAC File Offset: 0x00012EAC + public void SetValue(float val) // \u0002 + { + _value = val; + } + + // Token: 0x06000328 RID: 808 RVA: 0x00014CB8 File Offset: 0x00012EB8 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000329 RID: 809 RVA: 0x00014CC8 File Offset: 0x00012EC8 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetValue(Convert.ToSingle(val)); + } + + // Token: 0x0600032A RID: 810 RVA: 0x00014CD8 File Offset: 0x00012ED8 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new FloatVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0600032B RID: 811 RVA: 0x00014CF8 File Offset: 0x00012EF8 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc8Float; + } + + // Token: 0x0600032C RID: 812 RVA: 0x00014CFC File Offset: 0x00012EFC + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc5Enum: + SetValue(Convert.ToSingle(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue(((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue(((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue(((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue(((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue(((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc18Object: + SetValue((float)((UIntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc19Int: + SetValue(((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((float)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue(((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x0400017E RID: 382 + private float _value; + } + + // Token: 0x0200004F RID: 79 + internal sealed class UintVariant : VariantBase // \u000E\u2001 + { + // Token: 0x0600032E RID: 814 RVA: 0x00014E94 File Offset: 0x00013094 + public uint GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600032F RID: 815 RVA: 0x00014E9C File Offset: 0x0001309C + public void SetValue(uint val) // \u0002 + { + _value = val; + } + + // Token: 0x06000330 RID: 816 RVA: 0x00014EA8 File Offset: 0x000130A8 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000331 RID: 817 RVA: 0x00014EB8 File Offset: 0x000130B8 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is short) + { + SetValue((uint)((short)val)); + return; + } + if (val is int) + { + SetValue((uint)((int)val)); + return; + } + if (val is long) + { + SetValue((uint)((long)val)); + return; + } + if (val is ulong) + { + SetValue((uint)((ulong)val)); + return; + } + if (val is float) + { + SetValue((uint)((float)val)); + return; + } + if (val is double) + { + SetValue((uint)((double)val)); + return; + } + SetValue(Convert.ToUInt32(val)); + } + + // Token: 0x06000332 RID: 818 RVA: 0x00014F54 File Offset: 0x00013154 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new UintVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000333 RID: 819 RVA: 0x00014F74 File Offset: 0x00013174 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc9Uint; + } + + // Token: 0x06000334 RID: 820 RVA: 0x00014F78 File Offset: 0x00013178 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToUInt32(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((uint)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((uint)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue(((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue((uint)((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((uint)((UIntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue((uint)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((uint)((int)((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToUInt32(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((uint)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((uint)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((uint)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x0400017F RID: 383 + private uint _value; + } + + // Token: 0x0200005A RID: 90 + internal sealed class ByteVariant : VariantBase // \u000F\u2000 + { + // Token: 0x06000353 RID: 851 RVA: 0x0001540C File Offset: 0x0001360C + public byte GetValue() // \u0002 + { + return _value; + } + + // Token: 0x06000354 RID: 852 RVA: 0x00015414 File Offset: 0x00013614 + public void SetValue(byte val) // \u0002 + { + _value = val; + } + + // Token: 0x06000355 RID: 853 RVA: 0x00015420 File Offset: 0x00013620 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new ByteVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000356 RID: 854 RVA: 0x00015440 File Offset: 0x00013640 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x06000357 RID: 855 RVA: 0x00015450 File Offset: 0x00013650 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is short) + { + SetValue((byte)((short)val)); + return; + } + if (val is int) + { + SetValue((byte)((int)val)); + return; + } + if (val is long) + { + SetValue((byte)((long)val)); + return; + } + if (val is ushort) + { + SetValue((byte)((ushort)val)); + return; + } + if (val is uint) + { + SetValue((byte)((uint)val)); + return; + } + if (val is ulong) + { + SetValue((byte)((ulong)val)); + return; + } + if (val is float) + { + SetValue((byte)((float)val)); + return; + } + if (val is double) + { + SetValue((byte)((double)val)); + return; + } + SetValue(Convert.ToByte(val)); + } + + // Token: 0x06000358 RID: 856 RVA: 0x0001551C File Offset: 0x0001371C + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc14Byte; + } + + // Token: 0x06000359 RID: 857 RVA: 0x00015520 File Offset: 0x00013720 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToByte(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue((byte)((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((byte)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue((byte)((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue((byte)((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue((byte)((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((byte)((uint)((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue((byte)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((byte)((int)((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToByte(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((byte)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((byte)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((byte)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000187 RID: 391 + private byte _value; + } + + // Token: 0x0200005B RID: 91 + internal sealed class UlongVariant : VariantBase // \u000F\u2001 + { + // Token: 0x0600035B RID: 859 RVA: 0x00015718 File Offset: 0x00013918 + public ulong GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600035C RID: 860 RVA: 0x00015720 File Offset: 0x00013920 + public void SetValue(ulong val) // \u0002 + { + _value = val; + } + + // Token: 0x0600035D RID: 861 RVA: 0x0001572C File Offset: 0x0001392C + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return GetValue(); + } + + // Token: 0x0600035E RID: 862 RVA: 0x0001573C File Offset: 0x0001393C + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + if (val is short) + { + SetValue((ulong)(short)val); + return; + } + if (val is int) + { + SetValue((ulong)(int)val); + return; + } + if (val is long) + { + SetValue((ulong)((long)val)); + return; + } + if (val is float) + { + SetValue((ulong)((float)val)); + return; + } + if (val is double) + { + SetValue((ulong)((double)val)); + return; + } + SetValue(Convert.ToUInt64(val)); + } + + // Token: 0x0600035F RID: 863 RVA: 0x000157C4 File Offset: 0x000139C4 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new UlongVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000360 RID: 864 RVA: 0x000157E4 File Offset: 0x000139E4 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc7Ulong; + } + + // Token: 0x06000361 RID: 865 RVA: 0x000157E8 File Offset: 0x000139E8 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + switch (val.GetTypeCode()) + { + case Vtc.Tc1Bool: + SetValue(Convert.ToByte(((BoolVariant)val).GetValue())); + return this; + case Vtc.Tc5Enum: + SetValue(Convert.ToUInt64(((EnumVariant)val).GetValue())); + return this; + case Vtc.Tc7Ulong: + SetValue(((UlongVariant)val).GetValue()); + return this; + case Vtc.Tc8Float: + SetValue((ulong)((FloatVariant)val).GetValue()); + return this; + case Vtc.Tc9Uint: + SetValue(((UintVariant)val).GetValue()); + return this; + case Vtc.Tc10Ushort: + SetValue(((UshortVariant)val).GetValue()); + return this; + case Vtc.Tc12Sbyte: + SetValue((ulong)((SbyteVariant)val).GetValue()); + return this; + case Vtc.Tc13UIntPtr: + SetValue((ulong)((UIntPtrVariant)val).GetValue()); + return this; + case Vtc.Tc14Byte: + SetValue(((ByteVariant)val).GetValue()); + return this; + case Vtc.Tc15Short: + SetValue((ulong)((ShortVariant)val).GetValue()); + return this; + case Vtc.Tc17IntPtr: + SetValue((ulong)((long)((IntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc18Object: + SetValue(Convert.ToUInt64(((UIntPtrVariant)val).GetValue())); + return this; + case Vtc.Tc19Int: + SetValue((ulong)((IntVariant)val).GetValue()); + return this; + case Vtc.Tc21Double: + SetValue((ulong)((DoubleVariant)val).GetValue()); + return this; + case Vtc.Tc24Long: + SetValue((ulong)((LongVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x04000188 RID: 392 + private ulong _value; + } + + // Token: 0x0200005C RID: 92 + internal abstract class ReferenceVariantBase : VariantBase // \u000F\u2002 + { + // Token: 0x06000363 RID: 867 RVA: 0x000159E0 File Offset: 0x00013BE0 + public override object GetValueAbstract() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + throw new InvalidOperationException(); + } + + // Token: 0x06000364 RID: 868 RVA: 0x000159E8 File Offset: 0x00013BE8 + public override void SetValueAbstract(object val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + throw new InvalidOperationException(); + } + + // Token: 0x06000365 RID: 869 RVA: 0x000159F0 File Offset: 0x00013BF0 + public override bool IsAddr() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return true; + } + } + + // Token: 0x02000007 RID: 7 + internal sealed class FieldInfoVariant : ReferenceVariantBase // \u0002\u2004 + { + // Token: 0x06000023 RID: 35 RVA: 0x00002600 File Offset: 0x00000800 + public object GetObject() // \u0002 + { + return _obj; + } + + // Token: 0x06000024 RID: 36 RVA: 0x00002608 File Offset: 0x00000808 + public void SetObject(object val) // \u0002 + { + _obj = val; + } + + // Token: 0x06000025 RID: 37 RVA: 0x00002614 File Offset: 0x00000814 + public FieldInfo GetValue() // \u0002 + { + return _field; + } + + // Token: 0x06000026 RID: 38 RVA: 0x0000261C File Offset: 0x0000081C + public void SetValue(FieldInfo val) // \u0002 + { + _field = val; + } + + // Token: 0x06000027 RID: 39 RVA: 0x00002628 File Offset: 0x00000828 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc4FieldInfo; + } + + // Token: 0x06000028 RID: 40 RVA: 0x0000262C File Offset: 0x0000082C + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num == Vtc.Tc4FieldInfo) + { + SetObject(((FieldInfoVariant)val).GetObject()); + SetValue(((FieldInfoVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x06000029 RID: 41 RVA: 0x0000267C File Offset: 0x0000087C + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new FieldInfoVariant(); + ret.SetObject(_obj); + ret.SetValue(_field); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000005 RID: 5 + private object _obj; // \u0002 + + // Token: 0x04000006 RID: 6 + private FieldInfo _field; // \u0003 + } + + // Token: 0x02000012 RID: 18 + internal sealed class VariantBaseHolder : ReferenceVariantBase // \u0003\u2003 + { + // Token: 0x0600007A RID: 122 RVA: 0x00003BF0 File Offset: 0x00001DF0 + public VariantBase GetValue() // \u0002 + { + return _value; + } + + // Token: 0x0600007B RID: 123 RVA: 0x00003BF8 File Offset: 0x00001DF8 + public void SetValue(VariantBase val) // \u0002 + { + _value = val; + } + + // Token: 0x0600007C RID: 124 RVA: 0x00003C04 File Offset: 0x00001E04 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc0VariantBaseHolder; + } + + // Token: 0x0600007D RID: 125 RVA: 0x00003C08 File Offset: 0x00001E08 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + if (val.GetTypeCode() == Vtc.Tc0VariantBaseHolder) + { + SetValue(((VariantBaseHolder)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x0600007E RID: 126 RVA: 0x00003C48 File Offset: 0x00001E48 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new VariantBaseHolder(); + ret.SetValue(GetValue()); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0400001A RID: 26 + private VariantBase _value; + } + + // Token: 0x02000020 RID: 32 + internal sealed class LocalsIdxHolderVariant : ReferenceVariantBase // \u0005\u2004 + { + // Token: 0x060000C6 RID: 198 RVA: 0x000049A8 File Offset: 0x00002BA8 + public int GetValue() // \u0002 + { + return _value; + } + + // Token: 0x060000C7 RID: 199 RVA: 0x000049B0 File Offset: 0x00002BB0 + public void SetValue(int val) // \u0002 + { + _value = val; + } + + // Token: 0x060000C8 RID: 200 RVA: 0x000049BC File Offset: 0x00002BBC + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc23LocalsIdxHolder; + } + + // Token: 0x060000C9 RID: 201 RVA: 0x000049C0 File Offset: 0x00002BC0 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num == Vtc.Tc23LocalsIdxHolder) + { + SetValue(((LocalsIdxHolderVariant)val).GetValue()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x060000CA RID: 202 RVA: 0x00004A00 File Offset: 0x00002C00 + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new LocalsIdxHolderVariant(); + ret.SetValue(_value); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x04000029 RID: 41 + private int _value; + } + + // Token: 0x02000046 RID: 70 + internal abstract class ArrayValueVariantBase : ReferenceVariantBase // \u0008\u2003 + { + // Token: 0x060002F9 RID: 761 RVA: 0x00014788 File Offset: 0x00012988 + public Type GetHeldType() // \u0002 + { + return _type; + } + + // Token: 0x060002FA RID: 762 RVA: 0x00014790 File Offset: 0x00012990 + public void SetHeldType(Type val) // \u0002 + { + _type = val; + } + + // Token: 0x060002FB RID: 763 + public abstract object GetValue(); // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x060002FC RID: 764 + public abstract void SetValue(object val); // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x060002FD RID: 765 + public abstract bool IsEqual(ArrayValueVariantBase val); // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + + // Token: 0x04000174 RID: 372 + private Type _type; + } + + // Token: 0x02000053 RID: 83 + internal static class IntArrayComparison // \u000E\u2004 + { + // Token: 0x06000340 RID: 832 RVA: 0x00015294 File Offset: 0x00013494 + public static bool Execute(int[] a1, int[] a2) // \u0002 + { + if (a1 == a2) + { + return true; + } + if (a1 == null || a2 == null) + { + return false; + } + if (a1.Length != a2.Length) + { + return false; + } + return !a1.Where((t, i) => t != a2[i]).Any(); + } + } + + // Token: 0x0200002D RID: 45 + internal sealed class MdArrayValueVariant : ArrayValueVariantBase // \u0006\u2004 + { + // Token: 0x0600014F RID: 335 RVA: 0x000065AC File Offset: 0x000047AC + public Array GetArray() // \u0002 + { + return _array; + } + + // Token: 0x06000150 RID: 336 RVA: 0x000065B4 File Offset: 0x000047B4 + public void SetArray(Array val) // \u0002 + { + _array = val; + } + + // Token: 0x06000151 RID: 337 RVA: 0x000065C0 File Offset: 0x000047C0 + public int[] GetIndexes() // \u0002 + { + return _indexes; + } + + // Token: 0x06000152 RID: 338 RVA: 0x000065C8 File Offset: 0x000047C8 + public void SetIndexes(int[] val) // \u0002 + { + _indexes = val; + } + + // Token: 0x06000153 RID: 339 RVA: 0x000065D4 File Offset: 0x000047D4 + public override object GetValue() // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + { + return GetArray().GetValue(GetIndexes()); + } + + // Token: 0x06000154 RID: 340 RVA: 0x000065E8 File Offset: 0x000047E8 + public override void SetValue(object val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + { + GetArray().SetValue(val, GetIndexes()); + } + + // Token: 0x06000155 RID: 341 RVA: 0x000065FC File Offset: 0x000047FC + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new MdArrayValueVariant(); + ret.SetArray(GetArray()); + ret.SetIndexes(GetIndexes()); + ret.SetHeldType(GetHeldType()); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x06000156 RID: 342 RVA: 0x00006640 File Offset: 0x00004840 + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc20MdArrayValue; + } + + // Token: 0x06000157 RID: 343 RVA: 0x00006644 File Offset: 0x00004844 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num == Vtc.Tc20MdArrayValue) + { + var src = (MdArrayValueVariant)val; + SetArray(src.GetArray()); + SetIndexes(src.GetIndexes()); + SetHeldType(src.GetHeldType()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x06000158 RID: 344 RVA: 0x000066A0 File Offset: 0x000048A0 + public override bool IsEqual(ArrayValueVariantBase val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + { + var peer = (MdArrayValueVariant)val; + return GetArray() == peer.GetArray() && IntArrayComparison.Execute(GetIndexes(), peer.GetIndexes()); + } + + // Token: 0x04000050 RID: 80 + private Array _array; // \u0002 + + // Token: 0x04000051 RID: 81 + private int[] _indexes; // \u0003 + } + + // Token: 0x02000052 RID: 82 + internal sealed class SdArrayValueVariant : ArrayValueVariantBase // \u000E\u2003 + { + // Token: 0x06000336 RID: 822 RVA: 0x0001516C File Offset: 0x0001336C + public Array GetArray() // \u0002 + { + return _array; + } + + // Token: 0x06000337 RID: 823 RVA: 0x00015174 File Offset: 0x00013374 + public void SetArray(Array val) // \u0002 + { + _array = val; + } + + // Token: 0x06000338 RID: 824 RVA: 0x00015180 File Offset: 0x00013380 + public long GetIndex() // \u0002 + { + return _index; + } + + // Token: 0x06000339 RID: 825 RVA: 0x00015188 File Offset: 0x00013388 + public void SetIndex(long idx) // \u0002 + { + _index = idx; + } + + // Token: 0x0600033A RID: 826 RVA: 0x00015194 File Offset: 0x00013394 + public override object GetValue() // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + { + return _array.GetValue(_index); + } + + // Token: 0x0600033B RID: 827 RVA: 0x000151A8 File Offset: 0x000133A8 + public override void SetValue(object val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + { + _array.SetValue(val, _index); + } + + // Token: 0x0600033C RID: 828 RVA: 0x000151BC File Offset: 0x000133BC + public override Vtc GetTypeCode() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + return Vtc.Tc22SdArrayValue; + } + + // Token: 0x0600033D RID: 829 RVA: 0x000151C0 File Offset: 0x000133C0 + public override VariantBase CopyFrom(VariantBase val) // \u000F\u2008\u2000\u2002\u200A\u0002 + { + SetVariantType(val.GetVariantType()); + var num = val.GetTypeCode(); + if (num == Vtc.Tc22SdArrayValue) + { + var src = (SdArrayValueVariant)val; + SetArray(src.GetArray()); + SetIndex(src.GetIndex()); + SetHeldType(src.GetHeldType()); + return this; + } + throw new ArgumentOutOfRangeException(); + } + + // Token: 0x0600033E RID: 830 RVA: 0x0001521C File Offset: 0x0001341C + public override VariantBase Clone() // \u000F\u2008\u2000\u2002\u200A\u0002 + { + var ret = new SdArrayValueVariant(); + ret.SetArray(_array); + ret.SetIndex(_index); + ret.SetHeldType(GetHeldType()); + ret.SetVariantType(GetVariantType()); + return ret; + } + + // Token: 0x0600033F RID: 831 RVA: 0x00015260 File Offset: 0x00013460 + public override bool IsEqual(ArrayValueVariantBase val) // \u0008\u2003\u2008\u2000\u2002\u200A\u0002 + { + var peer = (SdArrayValueVariant)val; + return GetIndex() == peer.GetIndex() && GetArray() == peer.GetArray(); + } + + // Token: 0x04000181 RID: 385 + private Array _array; // \u0002 + + // Token: 0x04000182 RID: 386 + private long _index; // \u0003 + } +} |