7506 lines
283 KiB
C#
7506 lines
283 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Reflection;
|
||
using System.Reflection.Emit;
|
||
using System.Runtime.InteropServices;
|
||
using System.Runtime.Serialization;
|
||
using System.Threading;
|
||
|
||
// ReSharper disable InconsistentNaming
|
||
// ReSharper disable UnusedMember.Local
|
||
// ReSharper disable UnusedParameter.Local
|
||
// ReSharper disable MemberCanBePrivate.Global
|
||
// ReSharper disable EmptyGeneralCatchClause
|
||
// ReSharper disable RedundantCast
|
||
// ReSharper disable PossibleNullReferenceException
|
||
// ReSharper disable AssignNullToNotNullAttribute
|
||
// ReSharper disable UnusedMember.Global
|
||
|
||
namespace UnitTestProject.RefVm
|
||
{
|
||
// Token: 0x02000032 RID: 50
|
||
public class VmExecutor // \u0006\u2007
|
||
{
|
||
#region subclasses
|
||
|
||
// Token: 0x02000033 RID: 51
|
||
[Serializable]
|
||
private sealed class CatchBlockComparer // \u0002
|
||
{
|
||
// Token: 0x060002B0 RID: 688 RVA: 0x00012EB4 File Offset: 0x000110B4
|
||
internal int Compare(CatchBlock v1, CatchBlock v2) // \u0002
|
||
{
|
||
if (v1.ExcTypeId == v2.ExcTypeId)
|
||
{
|
||
return v2.Start.CompareTo(v1.Start);
|
||
}
|
||
return v1.ExcTypeId.CompareTo(v2.ExcTypeId);
|
||
}
|
||
|
||
// Token: 0x04000155 RID: 341
|
||
public static readonly CatchBlockComparer Instance = new CatchBlockComparer(); // \u0002
|
||
|
||
// Token: 0x04000156 RID: 342
|
||
public static Comparison<CatchBlock> MyComparison; // \u0003
|
||
}
|
||
|
||
// Token: 0x02000038 RID: 56
|
||
private sealed class StringTypePair // \u0006
|
||
{
|
||
// Token: 0x060002C0 RID: 704 RVA: 0x00013020 File Offset: 0x00011220
|
||
// Token: 0x060002C1 RID: 705 RVA: 0x00013028 File Offset: 0x00011228
|
||
// Token: 0x0400015D RID: 349
|
||
public string Str { get; set; } // \u0002
|
||
|
||
// Token: 0x060002C3 RID: 707 RVA: 0x0001303C File Offset: 0x0001123C
|
||
// Token: 0x060002C2 RID: 706 RVA: 0x00013034 File Offset: 0x00011234
|
||
// Token: 0x0400015E RID: 350
|
||
public Type T { get; set; } // \u0002
|
||
}
|
||
|
||
// Token: 0x02000039 RID: 57
|
||
// (Invoke) Token: 0x060002C5 RID: 709
|
||
private delegate object DynamicExecutor(object obj, object[] args); // \u0008
|
||
|
||
// Token: 0x0200003A RID: 58
|
||
// (Invoke) Token: 0x060002C9 RID: 713
|
||
internal delegate void VmInstrImpl(VariantBase t); // \u000E
|
||
|
||
// Token: 0x0200003B RID: 59
|
||
private sealed class VmInstr // \u000F
|
||
{
|
||
// Token: 0x060002CC RID: 716 RVA: 0x00013048 File Offset: 0x00011248
|
||
public VmInstr(VmInstrInfo id, VmInstrImpl func)
|
||
{
|
||
Id = id;
|
||
Func = func;
|
||
}
|
||
|
||
// Token: 0x0400015F RID: 351
|
||
public readonly VmInstrInfo Id; // \u0002
|
||
|
||
// Token: 0x04000160 RID: 352
|
||
public readonly VmInstrImpl Func; // \u0003
|
||
}
|
||
|
||
// Token: 0x02000037 RID: 55
|
||
private sealed class ExcHandlerFrame // \u0005
|
||
{
|
||
// Token: 0x060002BB RID: 699 RVA: 0x00012FF0 File Offset: 0x000111F0
|
||
// Token: 0x060002BC RID: 700 RVA: 0x00012FF8 File Offset: 0x000111F8
|
||
// Token: 0x0400015B RID: 347
|
||
public uint Pos { get; set; }
|
||
|
||
// Token: 0x060002BD RID: 701 RVA: 0x00013004 File Offset: 0x00011204
|
||
// Token: 0x060002BE RID: 702 RVA: 0x0001300C File Offset: 0x0001120C
|
||
// Token: 0x0400015C RID: 348
|
||
public object Exception { get; set; }
|
||
}
|
||
|
||
// Token: 0x02000034 RID: 52
|
||
internal struct MethodBaseAndVirtual : IEquatable<MethodBaseAndVirtual> // \u0002\u2000
|
||
{
|
||
public MethodBaseAndVirtual(MethodBase mb, bool isVirtual)
|
||
{
|
||
Val = mb;
|
||
IsVirtual = isVirtual;
|
||
}
|
||
|
||
// Token: 0x060002B1 RID: 689 RVA: 0x00012EF8 File Offset: 0x000110F8
|
||
// Token: 0x060002B2 RID: 690 RVA: 0x00012F00 File Offset: 0x00011100
|
||
// Token: 0x04000157 RID: 343
|
||
public MethodBase Val /* \u0002 */ { get; }
|
||
|
||
// Token: 0x060002B3 RID: 691 RVA: 0x00012F0C File Offset: 0x0001110C
|
||
// Token: 0x060002B4 RID: 692 RVA: 0x00012F14 File Offset: 0x00011114
|
||
// Token: 0x04000158 RID: 344
|
||
public bool IsVirtual /* \u0003 */ { get; }
|
||
|
||
// Token: 0x060002B5 RID: 693 RVA: 0x00012F20 File Offset: 0x00011120
|
||
public override int GetHashCode()
|
||
{
|
||
return Val.GetHashCode() ^ IsVirtual.GetHashCode();
|
||
}
|
||
|
||
// Token: 0x060002B6 RID: 694 RVA: 0x00012F48 File Offset: 0x00011148
|
||
public override bool Equals(object o)
|
||
{
|
||
if (o is MethodBaseAndVirtual)
|
||
{
|
||
return Equals((MethodBaseAndVirtual)o);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// Token: 0x060002B7 RID: 695 RVA: 0x00012F70 File Offset: 0x00011170
|
||
public bool Equals(MethodBaseAndVirtual val)
|
||
{
|
||
return IsVirtual == val.IsVirtual && Val == val.Val;
|
||
}
|
||
}
|
||
|
||
// Token: 0x02000035 RID: 53
|
||
private struct BoolHolder // \u0003
|
||
{
|
||
// Token: 0x04000159 RID: 345
|
||
public bool Val; // \u0002
|
||
}
|
||
|
||
// Token: 0x02000036 RID: 54
|
||
private sealed class IntToTypeComparer<T> : IComparer<KeyValuePair<int, T>> // \u0003\u2000
|
||
{
|
||
// Token: 0x060002B8 RID: 696 RVA: 0x00012F94 File Offset: 0x00011194
|
||
public IntToTypeComparer(Comparison<T> c)
|
||
{
|
||
_c = c;
|
||
}
|
||
|
||
// Token: 0x060002B9 RID: 697 RVA: 0x00012FA4 File Offset: 0x000111A4
|
||
public int Compare(KeyValuePair<int, T> v1, KeyValuePair<int, T> v2)
|
||
{
|
||
var num = _c(v1.Value, v2.Value);
|
||
if (num == 0)
|
||
{
|
||
return v2.Key.CompareTo(v1.Key);
|
||
}
|
||
return num;
|
||
}
|
||
|
||
// Token: 0x0400015A RID: 346
|
||
private readonly Comparison<T> _c;
|
||
}
|
||
|
||
// Token: 0x0200000B RID: 11
|
||
private static class HiByte // \u0002\u2008
|
||
{
|
||
// Token: 0x06000056 RID: 86 RVA: 0x00003154 File Offset: 0x00001354
|
||
public static int Extract(int src) // \u0002
|
||
{
|
||
return src & -16777216; // 0xFF000000
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region members
|
||
// Token: 0x04000132 RID: 306
|
||
private static readonly Type MethodBaseType = typeof(MethodBase); // \u0002\u2001
|
||
|
||
// Token: 0x04000133 RID: 307
|
||
private VmMethodHeader _methodHeader; // \u000E
|
||
|
||
// Token: 0x04000134 RID: 308
|
||
private readonly MyCollection<VariantBase> _evalStack = new MyCollection<VariantBase>(); // \u0003\u2003
|
||
|
||
// Token: 0x04000135 RID: 309
|
||
private readonly Dictionary<int, object> AllMetadataById = new Dictionary<int, object>(); // \u0006\u2003
|
||
|
||
// Token: 0x04000136 RID: 310
|
||
private readonly VmInstrCodesDb _instrCodesDb; // \u0006\u2001
|
||
|
||
// Token: 0x04000137 RID: 311
|
||
private object _exception; // \u0006\u2002
|
||
|
||
// Token: 0x04000138 RID: 312
|
||
private readonly Dictionary<MethodBase, object> _mbDynamicLock = new Dictionary<MethodBase, object>(); // \u0008\u2002
|
||
|
||
// Token: 0x04000139 RID: 313
|
||
private BinaryReader _srcVirtualizedStreamReader; // \u0002\u2000
|
||
|
||
// Token: 0x0400013A RID: 314
|
||
private Type _currentClass; // \u000F\u2001
|
||
|
||
// Token: 0x0400013B RID: 315
|
||
private static readonly Type AssemblyType = typeof(Assembly); // \u0002\u2003
|
||
|
||
// Token: 0x0400013C RID: 316
|
||
private readonly Dictionary<MethodBase, int> _mbCallCnt = new Dictionary<MethodBase, int>(256); // \u0006
|
||
|
||
// Token: 0x0400013D RID: 317
|
||
private Stream _srcVirtualizedStream; // \u000F\u2000
|
||
|
||
// Token: 0x0400013E RID: 318
|
||
private object[] _callees; // \u0005\u2000
|
||
|
||
// Token: 0x0400013F RID: 319
|
||
private readonly MyCollection<ExcHandlerFrame> _ehStack = new MyCollection<ExcHandlerFrame>(); // \u000F
|
||
|
||
// Token: 0x04000140 RID: 320
|
||
private VariantBase[] _localVariables; // \u0003\u2002
|
||
|
||
// Token: 0x04000141 RID: 321
|
||
private readonly Dictionary<MethodBaseAndVirtual, DynamicExecutor> _dynamicExecutors = new Dictionary<MethodBaseAndVirtual, DynamicExecutor>(256); // \u0002\u2002
|
||
|
||
// Token: 0x04000142 RID: 322
|
||
private bool _retFound; // \u0005\u2003
|
||
|
||
// Token: 0x04000143 RID: 323
|
||
private MyBufferReader _myBufferReader; // \u0002
|
||
|
||
// Token: 0x04000144 RID: 324
|
||
private Type[] _classGenericArgs; // \u0003
|
||
|
||
// Token: 0x04000145 RID: 325
|
||
private readonly Module _module; // \u0008\u2001
|
||
|
||
// Token: 0x04000146 RID: 326
|
||
private long _myBufferPos; // \u0005
|
||
|
||
// Token: 0x04000147 RID: 327
|
||
private byte[] _methodBody; // \u0008
|
||
|
||
// Token: 0x04000148 RID: 328
|
||
private static readonly Type ObjectArrayType = typeof(object[]); // \u000E\u2001
|
||
|
||
// Token: 0x04000149 RID: 329
|
||
private static readonly Dictionary<MethodBase, DynamicMethod> DynamicMethods = new Dictionary<MethodBase, DynamicMethod>(); // \u000E\u2003
|
||
|
||
// Token: 0x0400014A RID: 330
|
||
private bool _wasException; // \u0008\u2000
|
||
|
||
// Token: 0x0400014B RID: 331
|
||
private Type[] _methodGenericArgs; // \u0005\u2001
|
||
|
||
// Token: 0x0400014C RID: 332
|
||
private CatchBlock[] _catchBlocks; // \u000F\u2003
|
||
|
||
// Token: 0x0400014D RID: 333
|
||
private static readonly object InterlockedLock = new object(); // \u0008\u2003
|
||
|
||
// Token: 0x0400014E RID: 334
|
||
private uint? _storedPos; // \u000E\u2000
|
||
|
||
// Token: 0x0400014F RID: 335
|
||
private const bool _alwaysFalse = false; // \u000F\u2002
|
||
|
||
// Token: 0x04000150 RID: 336
|
||
private Dictionary<int, VmInstr> _vmInstrDb; // \u000E\u2002
|
||
|
||
// Token: 0x04000151 RID: 337
|
||
private VariantBase[] _variantOutputArgs; // \u0005\u2002
|
||
|
||
// Token: 0x04000152 RID: 338
|
||
private const bool _alwaysTrue = true; // \u0003\u2001
|
||
|
||
// Token: 0x04000153 RID: 339
|
||
private static readonly Type IntPtrType = typeof(IntPtr); // \u0003\u2000
|
||
|
||
// Token: 0x04000154 RID: 340
|
||
private static readonly Type VoidType = typeof(void); // \u0006\u2000
|
||
|
||
#endregion
|
||
|
||
// Token: 0x0600016C RID: 364 RVA: 0x00007958 File Offset: 0x00005B58
|
||
public VmExecutor(VmInstrCodesDb instrCodesDb, Module m)
|
||
{
|
||
_instrCodesDb = instrCodesDb;
|
||
_module = m;
|
||
Init();
|
||
}
|
||
|
||
// Token: 0x060001B6 RID: 438 RVA: 0x000092E0 File Offset: 0x000074E0
|
||
private void Init() // \u000F
|
||
{
|
||
if (!_instrCodesDb.IsInitialized())
|
||
{
|
||
lock (_instrCodesDb)
|
||
{
|
||
if (!_instrCodesDb.IsInitialized())
|
||
{
|
||
_vmInstrDb = CreateVmInstrDb();
|
||
DoNothing();
|
||
_instrCodesDb.SetInitialized(true);
|
||
}
|
||
}
|
||
}
|
||
if (_vmInstrDb == null)
|
||
{
|
||
_vmInstrDb = CreateVmInstrDb();
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001BD RID: 445 RVA: 0x00009534 File Offset: 0x00007734
|
||
private void DoNothing() // \u0006
|
||
{}
|
||
|
||
// Token: 0x06000239 RID: 569 RVA: 0x0000F9C4 File Offset: 0x0000DBC4
|
||
private VariantBase PopVariant() // \u0002
|
||
{
|
||
return _evalStack.PopBack();
|
||
}
|
||
|
||
// Token: 0x060002A0 RID: 672 RVA: 0x000127D8 File Offset: 0x000109D8
|
||
private long PopLong() // \u0002
|
||
{
|
||
var top = PopVariant();
|
||
switch (top.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum: return VariantBase.SignedLongFromEnum((EnumVariant)top); // bug was fixed and unit tested (Convert.ToInt64(((EnumVariant)top).GetValue());)
|
||
case VariantBase.Vtc.Tc13UIntPtr: return (long)((UIntPtrVariant)top).GetValue().ToUInt64();
|
||
case VariantBase.Vtc.Tc17IntPtr: return ((IntPtrVariant)top).GetValue().ToInt64();
|
||
case VariantBase.Vtc.Tc19Int: return ((IntVariant)top).GetValue();
|
||
}
|
||
throw new Exception(StringDecryptor.GetString(-1550345551) /* Unexpected value on the stack. */);
|
||
}
|
||
|
||
// Token: 0x060001A1 RID: 417 RVA: 0x00008CC4 File Offset: 0x00006EC4
|
||
private void Ldelem(Type t) // \u0002
|
||
{
|
||
var index = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
PushVariant(VariantFactory.Convert(array.GetValue(index), t));
|
||
}
|
||
|
||
// Token: 0x0600020C RID: 524 RVA: 0x0000C528 File Offset: 0x0000A728
|
||
private void Ldelem_(VariantBase vTypeId) // \u0006\u200A\u2000
|
||
{
|
||
var typeId = ((IntVariant)vTypeId).GetValue();
|
||
var type = GetTypeById(typeId);
|
||
Ldelem(type);
|
||
}
|
||
|
||
// Token: 0x060002A5 RID: 677 RVA: 0x00012A80 File Offset: 0x00010C80
|
||
private void PushVariant(VariantBase obj) // \u0008\u2000\u2001
|
||
{
|
||
if (obj == null)
|
||
{
|
||
throw new ArgumentNullException(StringDecryptor.GetString(-1550345950) /* obj */);
|
||
}
|
||
VariantBase push;
|
||
if (obj.GetVariantType() != null)
|
||
{
|
||
push = obj;
|
||
}
|
||
else
|
||
{
|
||
switch (obj.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc1Bool:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue(((BoolVariant)obj).GetValue() ? 1 : 0);
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc6Char:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue(((CharVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
{
|
||
var tmp = new LongVariant();
|
||
tmp.SetValue((long)((UlongVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
var tmp = new FloatVariant();
|
||
tmp.SetValue(((FloatVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue((int)((UintVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc10Ushort:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue(((UshortVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc12Sbyte:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue(((SbyteVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc14Byte:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue(((ByteVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc15Short:
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.SetValue(((ShortVariant)obj).GetValue());
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc18Object:
|
||
{
|
||
var abs = obj.GetValueAbstract();
|
||
if (abs == null)
|
||
{
|
||
push = obj;
|
||
break;
|
||
}
|
||
var type = abs.GetType();
|
||
if (type.HasElementType && !type.IsArray)
|
||
{
|
||
type = type.GetElementType();
|
||
}
|
||
if (type != null && !type.IsValueType && !type.IsEnum)
|
||
{
|
||
push = obj;
|
||
break;
|
||
}
|
||
push = VariantFactory.Convert(abs, type);
|
||
break;
|
||
}
|
||
case VariantBase.Vtc.Tc17IntPtr:
|
||
case VariantBase.Vtc.Tc13UIntPtr:
|
||
if(IntPtr.Size == 4)
|
||
{
|
||
var tmp = new IntVariant();
|
||
tmp.CopyFrom(obj);
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
}
|
||
else
|
||
{
|
||
var tmp = new LongVariant();
|
||
tmp.CopyFrom(obj);
|
||
tmp.SetVariantType(obj.GetVariantType());
|
||
push = tmp;
|
||
}
|
||
break;
|
||
default:
|
||
push = obj;
|
||
break;
|
||
}
|
||
}
|
||
_evalStack.PushBack(push);
|
||
}
|
||
|
||
// Token: 0x0600027D RID: 637 RVA: 0x00011C24 File Offset: 0x0000FE24
|
||
private void Conv_ovf_i4_un_(VariantBase dummy) // \u0003\u200B
|
||
{
|
||
Conv_i4(true, false);
|
||
}
|
||
|
||
// Token: 0x06000283 RID: 643 RVA: 0x00011E9C File Offset: 0x0001009C
|
||
public static void Sort<T>(T[] arr, Comparison<T> c) // \u0002
|
||
{
|
||
var array = new KeyValuePair<int, T>[arr.Length];
|
||
for (var i = 0; i < arr.Length; i++)
|
||
{
|
||
array[i] = new KeyValuePair<int, T>(i, arr[i]);
|
||
}
|
||
Array.Sort(array, arr, new IntToTypeComparer<T>(c));
|
||
}
|
||
|
||
// Token: 0x060001BE RID: 446 RVA: 0x00009538 File Offset: 0x00007738
|
||
private void SortCatchBlocks() // \u0003\u2000
|
||
{
|
||
if (CatchBlockComparer.MyComparison == null)
|
||
{
|
||
CatchBlockComparer.MyComparison = CatchBlockComparer.Instance.Compare;
|
||
}
|
||
Sort(_catchBlocks, CatchBlockComparer.MyComparison);
|
||
}
|
||
|
||
// Token: 0x0600016D RID: 365 RVA: 0x000079C8 File Offset: 0x00005BC8
|
||
public VmExecutor(VmInstrCodesDb instrCodesDb, Stream virtualizedStream = null) : this(instrCodesDb, typeof(VmExecutor).Module) // \u0006\u2007
|
||
{
|
||
_srcVirtualizedStream = virtualizedStream;
|
||
}
|
||
|
||
// Token: 0x0600023C RID: 572 RVA: 0x0000FA0C File Offset: 0x0000DC0C
|
||
public object Invoke(Stream virtualizedStream, string pos, object[] args) // \u0002
|
||
{
|
||
// ReSharper disable once IntroduceOptionalParameters.Global
|
||
return Invoke(virtualizedStream, pos, args, null, null, null);
|
||
}
|
||
|
||
// Token: 0x0600017A RID: 378 RVA: 0x00007DCC File Offset: 0x00005FCC
|
||
public object Invoke(Stream virtualizedStream, string pos, object[] args, Type[] methodGenericArgs, Type[] classGenericArgs, object[] callees) // \u0002
|
||
{
|
||
_srcVirtualizedStream = virtualizedStream;
|
||
Seek(pos, virtualizedStream);
|
||
return Invoke(args, methodGenericArgs, classGenericArgs, callees);
|
||
}
|
||
|
||
// Token: 0x060001C5 RID: 453 RVA: 0x00009A34 File Offset: 0x00007C34
|
||
private Type GetTypeById(int id) // \u0002
|
||
{
|
||
Type result;
|
||
lock (AllMetadataById)
|
||
{
|
||
var flag = true;
|
||
object o;
|
||
if (AllMetadataById.TryGetValue(id, out o))
|
||
{
|
||
result = (Type)o;
|
||
}
|
||
else
|
||
{
|
||
var token = ReadToken(id);
|
||
if (token.IsVm == 0)
|
||
{
|
||
var type = _module.ResolveType(token.MetadataToken);
|
||
AllMetadataById.Add(id, type);
|
||
result = type;
|
||
}
|
||
else
|
||
{
|
||
var vmToken = (VmClassTokenInfo)token.VmToken;
|
||
if (vmToken.IsOuterClassGeneric)
|
||
{
|
||
if (vmToken.OuterClassGenericMethodIdx!= -1)
|
||
{
|
||
result = _methodGenericArgs[vmToken.OuterClassGenericMethodIdx];
|
||
}
|
||
else
|
||
{
|
||
if (vmToken.OuterClassGenericClassIdx== -1)
|
||
{
|
||
throw new Exception();
|
||
}
|
||
result = _classGenericArgs[vmToken.OuterClassGenericClassIdx];
|
||
}
|
||
result = ElementedTypeHelper.PopType(result, ElementedTypeHelper.NestedElementTypes(vmToken.ClassName));
|
||
}
|
||
else
|
||
{
|
||
var className = vmToken.ClassName.Replace("\u0005 ,", "forms_cil.Trial,"); //TODO: в общем случае это лишнее
|
||
result = Type.GetType(className);
|
||
if (result == null)
|
||
{
|
||
var num = className.IndexOf(',');
|
||
var shortClassName = className.Substring(0, num);
|
||
var asmName = className.Substring(num + 1, className.Length - num - 1).Trim();
|
||
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
|
||
foreach (var assembly in assemblies)
|
||
{
|
||
string value = null;
|
||
try
|
||
{
|
||
value = assembly.Location;
|
||
}
|
||
catch (NotSupportedException)
|
||
{
|
||
}
|
||
if (string.IsNullOrEmpty(value) && assembly.FullName.Equals(asmName, StringComparison.Ordinal))
|
||
{
|
||
result = assembly.GetType(shortClassName);
|
||
if (result != null)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (result == null && shortClassName.StartsWith(StringDecryptor.GetString(-1550345235) /* <PrivateImplementationDetails>< */, StringComparison.Ordinal) && shortClassName.Contains(StringDecryptor.GetString(-1550345325) /* . */))
|
||
{
|
||
try
|
||
{
|
||
var types = Assembly.Load(asmName).GetTypes();
|
||
foreach (var t in types.Where(type3 => type3.FullName == shortClassName))
|
||
{
|
||
result = t;
|
||
break;
|
||
}
|
||
}
|
||
// ReSharper disable once EmptyGeneralCatchClause
|
||
catch
|
||
{
|
||
}
|
||
}
|
||
}
|
||
if (vmToken.IsGeneric)
|
||
{
|
||
var array = new Type[vmToken.GenericArguments.Length];
|
||
for (var j = 0; j < vmToken.GenericArguments.Length; j++)
|
||
{
|
||
array[j] = GetTypeById(vmToken.GenericArguments[j].MetadataToken);
|
||
}
|
||
var genericTypeDefinition = ElementedTypeHelper.TryGoToElementType(result).GetGenericTypeDefinition();
|
||
var c = ElementedTypeHelper.NestedElementTypes(result);
|
||
result = ElementedTypeHelper.PopType(genericTypeDefinition.MakeGenericType(array), c);
|
||
flag = false;
|
||
}
|
||
if (flag)
|
||
{
|
||
AllMetadataById.Add(id, result);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x060001A6 RID: 422 RVA: 0x00008DAC File Offset: 0x00006FAC
|
||
public object Invoke(object[] args, Type[] methodGenericArgs, Type[] classGenericArgs, object[] callees) // \u0002
|
||
{
|
||
if (args == null)
|
||
{
|
||
args = EmptyArray<object>.Data;
|
||
}
|
||
if (methodGenericArgs == null)
|
||
{
|
||
methodGenericArgs = Type.EmptyTypes;
|
||
}
|
||
if (classGenericArgs == null)
|
||
{
|
||
classGenericArgs = Type.EmptyTypes;
|
||
}
|
||
_callees = callees;
|
||
_methodGenericArgs = methodGenericArgs;
|
||
_classGenericArgs = classGenericArgs;
|
||
_variantOutputArgs = ArgsToVariantOutputArgs(args);
|
||
_localVariables = CreateLocalVariables();
|
||
object result;
|
||
try
|
||
{
|
||
using (var b = new MyBuffer(_methodBody))
|
||
{
|
||
using (_myBufferReader = new MyBufferReader(b))
|
||
{
|
||
_retFound = false;
|
||
_storedPos = null;
|
||
_evalStack.Clear();
|
||
InternalInvoke();
|
||
}
|
||
}
|
||
var retType = GetTypeById(_methodHeader.ReturnTypeId);
|
||
if (retType != VoidType && _evalStack.Count > 0)
|
||
{
|
||
var pop = PopVariant();
|
||
try
|
||
{
|
||
result = VariantFactory.Convert(null, retType).CopyFrom(pop).GetValueAbstract();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
result = pop.GetValueAbstract(); // example: ckfinite with no numeric
|
||
//throw;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
result = null;
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
for (var i = 0; i < _methodHeader.ArgsTypeToOutput.Length; i++)
|
||
{
|
||
var argTypeToOutput = _methodHeader.ArgsTypeToOutput[i];
|
||
if (argTypeToOutput.IsOutput)
|
||
{
|
||
var argOutValue = (VariantBaseHolder)_variantOutputArgs[i];
|
||
var argType = GetTypeById(argTypeToOutput.TypeId);
|
||
args[i] = VariantFactory.Convert(null, argType.GetElementType()).CopyFrom(argOutValue.GetValue()).GetValueAbstract();
|
||
}
|
||
}
|
||
_callees = null;
|
||
_variantOutputArgs = null;
|
||
_localVariables = null;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x06000269 RID: 617 RVA: 0x00010F7C File Offset: 0x0000F17C
|
||
private void Seek(string pos, Stream virtualizedStream) // \u0002
|
||
{
|
||
Seek(0L, virtualizedStream, pos);
|
||
}
|
||
|
||
// Token: 0x0600025C RID: 604 RVA: 0x00010B38 File Offset: 0x0000ED38
|
||
private void DoNothing(BinaryReader dummy) // \u0002
|
||
{
|
||
}
|
||
|
||
// Token: 0x06000250 RID: 592 RVA: 0x000106EC File Offset: 0x0000E8EC
|
||
private static CatchBlock ReadCatchBlock(BinaryReader r) // \u0002
|
||
{
|
||
return new CatchBlock
|
||
{
|
||
Kind = r.ReadByte(),
|
||
ExcTypeId = r.ReadInt32(),
|
||
Pos = r.ReadUInt32(),
|
||
PosKind4 = r.ReadUInt32(),
|
||
Start = r.ReadUInt32(),
|
||
Len = r.ReadUInt32()
|
||
};
|
||
}
|
||
|
||
// Token: 0x060001FC RID: 508 RVA: 0x0000BD50 File Offset: 0x00009F50
|
||
private static CatchBlock[] ReadCatchBlocks(BinaryReader r) // \u0002
|
||
{
|
||
var num = (int)r.ReadInt16();
|
||
var array = new CatchBlock[num];
|
||
for (var i = 0; i < num; i++)
|
||
{
|
||
array[i] = ReadCatchBlock(r);
|
||
}
|
||
return array;
|
||
}
|
||
|
||
// Token: 0x060001BF RID: 447 RVA: 0x00009564 File Offset: 0x00007764
|
||
private static byte[] ReadByteArray(BinaryReader r) // \u0002
|
||
{
|
||
var num = r.ReadInt32();
|
||
var array = new byte[num];
|
||
r.Read(array, 0, num);
|
||
return array;
|
||
}
|
||
|
||
// Token: 0x060001C1 RID: 449 RVA: 0x000096E4 File Offset: 0x000078E4
|
||
public void Seek(long parsedPos, Stream virtualizedStream, string pos) // \u0002
|
||
{
|
||
var input = new VmStreamWrapper(virtualizedStream, VmXorKey());
|
||
_srcVirtualizedStreamReader = new BinaryReader(input);
|
||
var baseStream = _srcVirtualizedStreamReader.BaseStream;
|
||
lock (baseStream)
|
||
{
|
||
if (pos != null)
|
||
{
|
||
parsedPos = ParsePos(pos);
|
||
}
|
||
_srcVirtualizedStreamReader.BaseStream.Seek(parsedPos, SeekOrigin.Begin);
|
||
DoNothing(_srcVirtualizedStreamReader);
|
||
_methodHeader = ReadMethodHeader(_srcVirtualizedStreamReader);
|
||
_catchBlocks = ReadCatchBlocks(_srcVirtualizedStreamReader);
|
||
SortCatchBlocks();
|
||
_methodBody = ReadByteArray(_srcVirtualizedStreamReader);
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000203 RID: 515 RVA: 0x0000C164 File Offset: 0x0000A364
|
||
private long ParsePos(string pos) // \u0002
|
||
{
|
||
using (var memoryStream = new MemoryStream(VmPosParser.Parse(pos)))
|
||
{
|
||
return new BinaryReader(new VmStreamWrapper(memoryStream, PosXorKey())).ReadInt64();
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001B5 RID: 437 RVA: 0x000092D8 File Offset: 0x000074D8
|
||
private int PosXorKey() // \u0002
|
||
{
|
||
return -2023764088;
|
||
}
|
||
|
||
// Token: 0x0600017B RID: 379 RVA: 0x00007DEC File Offset: 0x00005FEC
|
||
public static int VmXorKey() // \u0003
|
||
{
|
||
return 1783652397;
|
||
}
|
||
|
||
// Token: 0x060001E7 RID: 487 RVA: 0x0000B0F8 File Offset: 0x000092F8
|
||
private LocalVarType ReadLocalVarType(BinaryReader r) // \u0002
|
||
{
|
||
return new LocalVarType { TypeId = r.ReadInt32() };
|
||
}
|
||
|
||
// Token: 0x060001AB RID: 427 RVA: 0x00008FF8 File Offset: 0x000071F8
|
||
private LocalVarType[] ReadLocalVarTypes(BinaryReader r) // \u0002
|
||
{
|
||
var array = new LocalVarType[r.ReadInt16()];
|
||
for (var i = 0; i < array.Length; i++)
|
||
{
|
||
array[i] = ReadLocalVarType(r);
|
||
}
|
||
return array;
|
||
}
|
||
|
||
// Token: 0x0600023B RID: 571 RVA: 0x0000F9E0 File Offset: 0x0000DBE0
|
||
private ArgTypeToOutput ReadArgTypeToOutput(BinaryReader r) // \u0002
|
||
{
|
||
var ret = new ArgTypeToOutput
|
||
{
|
||
TypeId = r.ReadInt32(),
|
||
IsOutput = r.ReadBoolean()
|
||
};
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x06000287 RID: 647 RVA: 0x00012138 File Offset: 0x00010338
|
||
private ArgTypeToOutput[] ReadArgsTypeToOutput(BinaryReader r) // \u0002
|
||
{
|
||
var array = new ArgTypeToOutput[r.ReadInt16()];
|
||
for (var i = 0; i < array.Length; i++)
|
||
{
|
||
array[i] = ReadArgTypeToOutput(r);
|
||
}
|
||
return array;
|
||
}
|
||
|
||
// Token: 0x06000216 RID: 534 RVA: 0x0000C790 File Offset: 0x0000A990
|
||
private VmMethodHeader ReadMethodHeader(BinaryReader src) // \u0002
|
||
{
|
||
var ret = new VmMethodHeader
|
||
{
|
||
ClassId = src.ReadInt32(),
|
||
ReturnTypeId = src.ReadInt32(),
|
||
LocalVarTypes = ReadLocalVarTypes(src),
|
||
Flags = src.ReadByte(),
|
||
Name = src.ReadString(),
|
||
ArgsTypeToOutput = ReadArgsTypeToOutput(src)
|
||
};
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x06000266 RID: 614 RVA: 0x00010C54 File Offset: 0x0000EE54
|
||
private void Shr_un_(VariantBase dummy) // \u000F\u2001
|
||
{
|
||
PushVariant(Shift(false, false));
|
||
}
|
||
|
||
// Token: 0x06000176 RID: 374 RVA: 0x00007CAC File Offset: 0x00005EAC
|
||
private void Shr_(VariantBase dummy) // \u0005\u2007\u2000
|
||
{
|
||
PushVariant(Shift(false, true));
|
||
}
|
||
|
||
private VariantBase Xor(VariantBase org_v1, VariantBase org_v2)
|
||
{
|
||
VariantBase v1, v2;
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, true);
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
uvret.SetValue(uv1 ^ uv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
ivret.SetValue(iv1 ^ iv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
/*double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue(); // естественный алгоритм
|
||
long lv1 = (dv1 < 0) ? (long)dv1 : (long)(ulong)dv1;
|
||
long lv2 = (dv2 < 0) ? (long)dv2 : (long)(ulong)dv2;
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
var l64 = (ulong) lv1 ^ (ulong) lv2;
|
||
if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
|
||
dvret.SetValue(l64);*/
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
dvret.SetValue((4 == IntPtr.Size) ? Double.NaN : (double)0); // иногда у фреймворка бывает мусор, но чаще эти значения...
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
/*float fv1 = ((FloatVariant) v1).GetValue(), fv2 = ((FloatVariant) v2).GetValue(); // естественный алгоритм
|
||
long lv1 = (fv1 < 0) ? (long)fv1 : (long)(ulong)fv1;
|
||
long lv2 = (fv2 < 0) ? (long)fv2 : (long)(ulong)fv2;
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
var l64 = (ulong)lv1 ^ (ulong)lv2;
|
||
if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
|
||
fvret.SetValue(l64);*/
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
fvret.SetValue((4 == IntPtr.Size) ? float.NaN : (float)0.0); // иногда у фреймворка бывает мусор, но чаще эти значения...
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
{
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
lvret.SetValue(lv1 ^ lv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
ulvret.SetValue(ulv1 ^ ulv2);
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(OpCodes.Xor);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x0600026C RID: 620 RVA: 0x00010FC8 File Offset: 0x0000F1C8
|
||
private void Xor_(VariantBase dummy) // \u0008\u2001\u2000
|
||
{
|
||
var v1 = PopVariant();
|
||
var v2 = PopVariant();
|
||
PushVariant(Xor(v2, v1));
|
||
}
|
||
|
||
// Token: 0x06000189 RID: 393 RVA: 0x00008244 File Offset: 0x00006444
|
||
private void Shl_(VariantBase dummy) // \u0006\u2002\u2001
|
||
{
|
||
PushVariant(Shift(true, true));
|
||
}
|
||
|
||
VariantBase.Vtc CommonTypeShift(VariantBase org_val, VariantBase org_shift, out VariantBase val, out VariantBase shift, bool signed)
|
||
{
|
||
val = org_val.Clone();
|
||
shift = org_shift.Clone();
|
||
var tcval = UnderlyingTypeCode(ref val);
|
||
var tcsh = UnderlyingTypeCode(ref shift);
|
||
if (tcval == VariantBase.Vtc.Tc18Object || tcsh == VariantBase.Vtc.Tc18Object)
|
||
return VariantBase.Vtc.Tc18Object;
|
||
shift = new LongVariant();
|
||
long lsh = 0;
|
||
switch (org_shift.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
lsh = VariantBase.SignedLongFromEnum((EnumVariant) org_shift);
|
||
break;
|
||
case VariantBase.Vtc.Tc13UIntPtr:
|
||
lsh = (long)((UIntPtrVariant)org_shift).GetValue().ToUInt64();
|
||
break;
|
||
case VariantBase.Vtc.Tc17IntPtr:
|
||
lsh = ((IntPtrVariant)org_shift).GetValue().ToInt64();
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
lsh = ((IntVariant)org_shift).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
lsh = ((LongVariant)org_shift).GetValue();
|
||
break;
|
||
}
|
||
shift.SetValueAbstract(lsh);
|
||
VariantBase.Vtc ret = tcval;
|
||
if (!signed)
|
||
{
|
||
val = AsUnsigned(val);
|
||
}
|
||
if (!signed) switch (ret)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
return VariantBase.Vtc.Tc9Uint;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
return VariantBase.Vtc.Tc7Ulong;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
private VariantBase Shift(bool left, bool signed)
|
||
{
|
||
VariantBase val, shift;
|
||
|
||
var org_shift = PopVariant();
|
||
var org_val = PopVariant();
|
||
var tc = CommonTypeShift(org_val, org_shift, out val, out shift, signed);
|
||
var sh = (int)(long)shift.GetValueAbstract();
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)val).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
if (left)
|
||
{
|
||
uvret.SetValue(uv1 << sh);
|
||
}
|
||
else
|
||
{
|
||
uvret.SetValue(uv1 >> sh);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)val).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
if (left)
|
||
{
|
||
ivret.SetValue(iv1 << sh);
|
||
}
|
||
else
|
||
{
|
||
ivret.SetValue(iv1 >> sh);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
/*double dv1 = ((DoubleVariant)val).GetValue(), dv2 = ((DoubleVariant)shift).GetValue();
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
var dmul = left ? 2 : 0.5;
|
||
dvret.SetValue(dv1 * Math.Pow(dmul, dv2));
|
||
break;*/
|
||
case VariantBase.Vtc.Tc8Float:
|
||
/*float fv1 = ((FloatVariant)val).GetValue(), fv2 = ((FloatVariant)shift).GetValue();
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
var fmul = left ? 2f : 0.5f;
|
||
fvret.SetValue(fv1 * (float)Math.Pow(fmul, fv2));
|
||
break;*/
|
||
throw new InvalidProgramException();
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv1 = ((LongVariant)val).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
if (left)
|
||
{
|
||
lvret.SetValue(lv1 << sh);
|
||
}
|
||
else
|
||
{
|
||
lvret.SetValue(lv1 >> sh);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)val).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
if (left)
|
||
{
|
||
ulvret.SetValue(ulv1 << sh);
|
||
}
|
||
else
|
||
{
|
||
ulvret.SetValue(ulv1 >> sh);
|
||
}
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (left ? OpCodes.Shl : OpCodes.Shr) : OpCodes.Shr_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_val.GetValueAbstract(), org_shift.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x06000173 RID: 371 RVA: 0x00007BE0 File Offset: 0x00005DE0
|
||
private void Initblk_(VariantBase dummy) // \u0002\u2002\u2000
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345287) /* Initblk not supported. */);
|
||
}
|
||
|
||
// Token: 0x0600020A RID: 522 RVA: 0x0000C508 File Offset: 0x0000A708
|
||
private void Localloc_(VariantBase dummy) // \u0008\u200A\u2000
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345866) /* Localloc not supported. */);
|
||
}
|
||
|
||
// Token: 0x06000212 RID: 530 RVA: 0x0000C73C File Offset: 0x0000A93C
|
||
private void Refanyval_(VariantBase dummy) // \u0005\u200A\u2000
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345900) /* Refanyval is not supported. */);
|
||
}
|
||
|
||
// Token: 0x06000237 RID: 567 RVA: 0x0000F984 File Offset: 0x0000DB84
|
||
private void Refanytype_(VariantBase dummy) // \u000F\u2005
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345460) /* Refanytype is not supported. */);
|
||
}
|
||
|
||
// Token: 0x0600029C RID: 668 RVA: 0x000126CC File Offset: 0x000108CC
|
||
private void Cpblk_(VariantBase dummy) // \u0002\u2006
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345423) /* Cpblk not supported. */);
|
||
}
|
||
|
||
// Token: 0x060001CA RID: 458 RVA: 0x00009E68 File Offset: 0x00008068
|
||
private void Cpobj_(VariantBase dummy) // \u0008\u2009
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345317) /* Cpobj is not supported. */);
|
||
}
|
||
|
||
// Token: 0x060001D2 RID: 466 RVA: 0x0000A338 File Offset: 0x00008538
|
||
private void Arglist_(VariantBase dummy) // \u000F\u2002\u2001
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345940) /* Arglist is not supported. */);
|
||
}
|
||
|
||
// Token: 0x06000187 RID: 391 RVA: 0x00008224 File Offset: 0x00006424
|
||
private void Mkrefany_(VariantBase dummy) // \u0002\u2007
|
||
{
|
||
throw new NotSupportedException(StringDecryptor.GetString(-1550345270) /* Mkrefany is not supported. */);
|
||
}
|
||
|
||
// Token: 0x0600017E RID: 382 RVA: 0x00007ECC File Offset: 0x000060CC
|
||
private static BindingFlags BF(bool isStatic) // \u0002
|
||
{
|
||
var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic;
|
||
if (isStatic)
|
||
{
|
||
bindingFlags |= BindingFlags.Static;
|
||
}
|
||
else
|
||
{
|
||
bindingFlags |= BindingFlags.Instance;
|
||
}
|
||
return bindingFlags;
|
||
}
|
||
|
||
// Token: 0x06000192 RID: 402 RVA: 0x000084F4 File Offset: 0x000066F4
|
||
private void Ldc_i4_0_(VariantBase dummy) // \u0005\u2001
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(0);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x0600028F RID: 655 RVA: 0x0001235C File Offset: 0x0001055C
|
||
private void Ldc_i4_1_(VariantBase dummy) // \u0002\u2005\u2000
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(1);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x0600022F RID: 559 RVA: 0x0000F8C8 File Offset: 0x0000DAC8
|
||
private void Ldc_i4_2_(VariantBase dummy) // \u0005
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(2);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x06000174 RID: 372 RVA: 0x00007BF4 File Offset: 0x00005DF4
|
||
private void Ldc_i4_3_(VariantBase dummy) // \u0008\u2006\u2000
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(3);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x06000262 RID: 610 RVA: 0x00010BEC File Offset: 0x0000EDEC
|
||
private void Ldc_i4_4_(VariantBase dummy) // \u000F\u2009\u2000
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(4);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x060001B3 RID: 435 RVA: 0x000092B4 File Offset: 0x000074B4
|
||
private void Ldc_i4_5_(VariantBase dummy) // \u0008\u2004\u2000
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(5);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x06000231 RID: 561 RVA: 0x0000F900 File Offset: 0x0000DB00
|
||
private void Ldc_i4_6_(VariantBase dummy) // \u0006\u2009\u2000
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(6);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x0600026A RID: 618 RVA: 0x00010F88 File Offset: 0x0000F188
|
||
private void Ldc_i4_7_(VariantBase dummy) // \u0003\u2003\u2000
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(7);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x060001A9 RID: 425 RVA: 0x00008FA8 File Offset: 0x000071A8
|
||
private void Ldc_i4_8_(VariantBase dummy) // \u000E\u2001
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(8);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x0600016F RID: 367 RVA: 0x00007A58 File Offset: 0x00005C58
|
||
private void Unbox_(VariantBase vTypeId) // \u0005\u2003\u2000
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var val = VariantFactory.Convert(PopVariant().GetValueAbstract(), type);
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x06000207 RID: 519 RVA: 0x0000C228 File Offset: 0x0000A428
|
||
private VmTokenInfo ReadVmToken(BinaryReader reader) // \u0002
|
||
{
|
||
switch (reader.ReadByte())
|
||
{
|
||
case (byte)VmTokenInfo.Kind.Class0:
|
||
{
|
||
var ret = new VmClassTokenInfo
|
||
{
|
||
OuterClassGenericMethodIdx = reader.ReadInt32(),
|
||
OuterClassGenericClassIdx = reader.ReadInt32(),
|
||
IsOuterClassGeneric = reader.ReadBoolean(),
|
||
ClassName = reader.ReadString(),
|
||
IsGeneric = reader.ReadBoolean(),
|
||
GenericArguments = new UniversalTokenInfo[(int) reader.ReadInt16()]
|
||
};
|
||
for (var i = 0; i < ret.GenericArguments.Length; i++)
|
||
{
|
||
ret.GenericArguments[i] = new UniversalTokenInfo
|
||
{
|
||
IsVm = 1,
|
||
MetadataToken = reader.ReadInt32()
|
||
};
|
||
}
|
||
return ret;
|
||
}
|
||
case (byte)VmTokenInfo.Kind.Field1:
|
||
return new VmFieldTokenInfo
|
||
{
|
||
Class = new UniversalTokenInfo
|
||
{
|
||
IsVm = 1,
|
||
MetadataToken = reader.ReadInt32()
|
||
},
|
||
Name = reader.ReadString(),
|
||
IsStatic = reader.ReadBoolean()
|
||
};
|
||
case (byte)VmTokenInfo.Kind.Method2:
|
||
{
|
||
var ret = new VmMethodTokenInfo
|
||
{
|
||
Class = new UniversalTokenInfo
|
||
{
|
||
IsVm = 1,
|
||
MetadataToken = reader.ReadInt32()
|
||
},
|
||
Flags = reader.ReadByte(),
|
||
Name = reader.ReadString(),
|
||
ReturnType = new UniversalTokenInfo
|
||
{
|
||
IsVm = 1,
|
||
MetadataToken = reader.ReadInt32()
|
||
},
|
||
Parameters = new UniversalTokenInfo[(int)reader.ReadInt16()]
|
||
};
|
||
for (var j = 0; j < ret.Parameters.Length; j++)
|
||
{
|
||
ret.Parameters[j] = new UniversalTokenInfo
|
||
{
|
||
IsVm = 1,
|
||
MetadataToken = reader.ReadInt32()
|
||
};
|
||
}
|
||
var gaCnt = (int)reader.ReadInt16();
|
||
ret.GenericArguments = new UniversalTokenInfo[gaCnt];
|
||
for (var k = 0; k < gaCnt; k++)
|
||
{
|
||
ret.GenericArguments[k] = new UniversalTokenInfo
|
||
{
|
||
IsVm = 1,
|
||
MetadataToken = reader.ReadInt32()
|
||
};
|
||
}
|
||
return ret;
|
||
}
|
||
case (byte)VmTokenInfo.Kind.String3:
|
||
return new VmStringTokenInfo { Value = reader.ReadString() };
|
||
case (byte)VmTokenInfo.Kind.MethodRef4:
|
||
return new VmMethodRefTokenInfo
|
||
{
|
||
Flags = reader.ReadInt32(),
|
||
Pos = reader.ReadInt32()
|
||
};
|
||
default:
|
||
throw new ArgumentOutOfRangeException();
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000175 RID: 373 RVA: 0x00007C08 File Offset: 0x00005E08
|
||
private UniversalTokenInfo ReadToken(int pos) // u0002
|
||
{
|
||
if (_srcVirtualizedStreamReader == null)
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
var baseStream = _srcVirtualizedStreamReader.BaseStream;
|
||
UniversalTokenInfo result;
|
||
lock (baseStream)
|
||
{
|
||
_srcVirtualizedStreamReader.BaseStream.Seek(pos, SeekOrigin.Begin);
|
||
result = new UniversalTokenInfo {IsVm = _srcVirtualizedStreamReader.ReadByte()};
|
||
if (result.IsVm == 0)
|
||
{
|
||
result.MetadataToken = _srcVirtualizedStreamReader.ReadInt32();
|
||
}
|
||
else
|
||
{
|
||
result.VmToken = ReadVmToken(_srcVirtualizedStreamReader);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x06000248 RID: 584 RVA: 0x000102AC File Offset: 0x0000E4AC
|
||
private string Ldstr(int strToken) // \u0002
|
||
{
|
||
string result;
|
||
lock (AllMetadataById)
|
||
{
|
||
object stored;
|
||
if (AllMetadataById.TryGetValue(strToken, out stored))
|
||
{
|
||
result = (string)stored;
|
||
}
|
||
else
|
||
{
|
||
var tokenInfo = ReadToken(strToken);
|
||
if (tokenInfo.IsVm == 0)
|
||
{
|
||
result = _module.ResolveString(tokenInfo.MetadataToken);
|
||
}
|
||
else
|
||
{
|
||
var text = ((VmStringTokenInfo)tokenInfo.VmToken).Value;
|
||
AllMetadataById.Add(strToken, text);
|
||
result = text;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x0600019C RID: 412 RVA: 0x00008B34 File Offset: 0x00006D34
|
||
private void Ldstr_(VariantBase strToken) // \u000E\u2000\u2001
|
||
{
|
||
var tok = ((IntVariant)strToken).GetValue();
|
||
var text = Ldstr(tok);
|
||
var val = new StringVariant();
|
||
val.SetValue(text);
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x06000170 RID: 368 RVA: 0x00007A94 File Offset: 0x00005C94
|
||
private VariantBase ReadOperand(MyBufferReader r, VmOperandType operandType) // \u0002
|
||
{
|
||
switch (operandType)
|
||
{
|
||
case VmOperandType.Ot0UInt:
|
||
{
|
||
var ret = new UintVariant();
|
||
ret.SetValue(r.ReadUint());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot1UShort:
|
||
case VmOperandType.Ot3UShort:
|
||
{
|
||
var ret = new UshortVariant();
|
||
ret.SetValue(r.ReadUshort());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot2Byte:
|
||
case VmOperandType.Ot8Byte:
|
||
{
|
||
var ret = new ByteVariant();
|
||
ret.SetValue(r.ReadByte());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot4Double:
|
||
{
|
||
var ret = new DoubleVariant();
|
||
ret.SetValue(r.ReadDouble());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot5Int:
|
||
case VmOperandType.Ot12Int:
|
||
{
|
||
var ret = new IntVariant();
|
||
ret.SetValue(r.ReadInt32());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot6SByte:
|
||
{
|
||
var ret = new SbyteVariant();
|
||
ret.SetValue(r.ReadSbyte());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot7Long:
|
||
{
|
||
var ret = new LongVariant();
|
||
ret.SetValue(r.ReadLong());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot9IntArr:
|
||
{
|
||
var num = r.ReadInt32();
|
||
var array = new IntVariant[num];
|
||
for (var i = 0; i < num; i++)
|
||
{
|
||
var item = new IntVariant();
|
||
item.SetValue(r.ReadInt32());
|
||
array[i] = item;
|
||
}
|
||
var ret = new ArrayVariant();
|
||
ret.SetValue(array);
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot10Float:
|
||
{
|
||
var ret = new FloatVariant();
|
||
ret.SetValue(r.ReadFloat());
|
||
return ret;
|
||
}
|
||
case VmOperandType.Ot11Nope:
|
||
return null;
|
||
default:
|
||
throw new Exception(StringDecryptor.GetString(-1550347123) /* Unknown operand type. */);
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000279 RID: 633 RVA: 0x0001184C File Offset: 0x0000FA4C
|
||
enum ComparisonKind { EQ, NEQ, GT, LE, LT, GE }
|
||
private static bool UniCompare(VariantBase v1, VariantBase v2, ComparisonKind ck, bool unsignedNanBranch) // \u0008 - bug fixed (метод переписан)
|
||
{
|
||
// from stack: enum double single long int
|
||
var t1 = v1.GetTypeCode();
|
||
if (t1 == VariantBase.Vtc.Tc5Enum)
|
||
{
|
||
var vv1 = VariantBase.SignedVariantFromEnum((EnumVariant)v1);
|
||
return UniCompare(vv1, v2, ck, unsignedNanBranch);
|
||
}
|
||
var t2 = v2.GetTypeCode();
|
||
if (t2 == VariantBase.Vtc.Tc5Enum)
|
||
{
|
||
var vv2 = VariantBase.SignedVariantFromEnum((EnumVariant)v2);
|
||
return UniCompare(v1, vv2, ck, unsignedNanBranch);
|
||
}
|
||
if (t1 == VariantBase.Vtc.Tc18Object || t2 == VariantBase.Vtc.Tc18Object)
|
||
{
|
||
if (ck == ComparisonKind.EQ) return v1.GetValueAbstract().Equals(v2.GetValueAbstract());
|
||
if (ck == ComparisonKind.NEQ) return !v1.GetValueAbstract().Equals(v2.GetValueAbstract());
|
||
return false;
|
||
}
|
||
if (t1 == VariantBase.Vtc.Tc21Double || t2 == VariantBase.Vtc.Tc21Double)
|
||
{
|
||
var d1 = (t1 == VariantBase.Vtc.Tc21Double) ? ((DoubleVariant)v1).GetValue() : Convert.ToDouble(v1.GetValueAbstract());
|
||
var d2 = (t2 == VariantBase.Vtc.Tc21Double) ? ((DoubleVariant)v2).GetValue() : Convert.ToDouble(v2.GetValueAbstract());
|
||
if (unsignedNanBranch) unsignedNanBranch = (double.IsNaN(d1) || double.IsNaN(d2));
|
||
switch (ck)
|
||
{
|
||
case ComparisonKind.EQ:
|
||
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
||
return (d1 == d2) || unsignedNanBranch;
|
||
case ComparisonKind.GT:
|
||
return (d1 > d2) || unsignedNanBranch;
|
||
case ComparisonKind.NEQ:
|
||
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
||
return (d1 != d2) || unsignedNanBranch;
|
||
case ComparisonKind.LE:
|
||
return (d1 <= d2) || unsignedNanBranch;
|
||
case ComparisonKind.LT:
|
||
return (d1 < d2) || unsignedNanBranch;
|
||
case ComparisonKind.GE:
|
||
return (d1 >= d2) || unsignedNanBranch;
|
||
}
|
||
}
|
||
if (t1 == VariantBase.Vtc.Tc8Float || t2 == VariantBase.Vtc.Tc8Float)
|
||
{
|
||
var d1 = (t1 == VariantBase.Vtc.Tc8Float) ? ((FloatVariant)v1).GetValue() : Convert.ToSingle(v1.GetValueAbstract());
|
||
var d2 = (t2 == VariantBase.Vtc.Tc8Float) ? ((FloatVariant)v2).GetValue() : Convert.ToSingle(v2.GetValueAbstract());
|
||
if (unsignedNanBranch) unsignedNanBranch = (float.IsNaN(d1) || float.IsNaN(d2));
|
||
switch (ck)
|
||
{
|
||
case ComparisonKind.EQ:
|
||
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
||
return (d1 == d2) || unsignedNanBranch;
|
||
case ComparisonKind.GT:
|
||
return (d1 > d2) || unsignedNanBranch;
|
||
case ComparisonKind.NEQ:
|
||
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
||
return (d1 != d2) || unsignedNanBranch;
|
||
case ComparisonKind.LE:
|
||
return (d1 <= d2) || unsignedNanBranch;
|
||
case ComparisonKind.LT:
|
||
return (d1 < d2) || unsignedNanBranch;
|
||
case ComparisonKind.GE:
|
||
return (d1 >= d2) || unsignedNanBranch;
|
||
}
|
||
}
|
||
if (t1 == VariantBase.Vtc.Tc24Long || t2 == VariantBase.Vtc.Tc24Long)
|
||
{
|
||
var d1 = (t1 == VariantBase.Vtc.Tc24Long) ? ((LongVariant)v1).GetValue() : (unsignedNanBranch ? Convert.ToInt64((uint)(int)v1.GetValueAbstract()) : Convert.ToInt64(v1.GetValueAbstract()));
|
||
var d2 = (t2 == VariantBase.Vtc.Tc24Long) ? ((LongVariant)v2).GetValue() : (unsignedNanBranch ? Convert.ToInt64((uint)(int)v2.GetValueAbstract()) : Convert.ToInt64(v2.GetValueAbstract()));
|
||
switch (ck)
|
||
{
|
||
case ComparisonKind.EQ:
|
||
return d1 == d2;
|
||
case ComparisonKind.GT:
|
||
if(unsignedNanBranch) return (ulong)d1 > (ulong)d2;
|
||
return d1 > d2;
|
||
case ComparisonKind.NEQ:
|
||
if (unsignedNanBranch) return (ulong)d1 != (ulong)d2;
|
||
return d1 != d2;
|
||
case ComparisonKind.LE:
|
||
if (unsignedNanBranch) return (ulong)d1 <= (ulong)d2;
|
||
return d1 <= d2;
|
||
case ComparisonKind.LT:
|
||
if (unsignedNanBranch) return (ulong)d1 < (ulong)d2;
|
||
return d1 < d2;
|
||
case ComparisonKind.GE:
|
||
if (unsignedNanBranch) return (ulong)d1 >= (ulong)d2;
|
||
return d1 >= d2;
|
||
}
|
||
}
|
||
if (t1 == VariantBase.Vtc.Tc19Int || t2 == VariantBase.Vtc.Tc19Int)
|
||
{
|
||
switch (ck)
|
||
{
|
||
case ComparisonKind.EQ:
|
||
// ReSharper disable once CompareOfFloatsByEqualityOperator
|
||
return ((IntVariant)v1).GetValue() == ((IntVariant)v2).GetValue();
|
||
case ComparisonKind.GT:
|
||
if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() > (uint)((IntVariant)v2).GetValue();
|
||
return ((IntVariant)v1).GetValue() > ((IntVariant)v2).GetValue();
|
||
case ComparisonKind.NEQ:
|
||
if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() != (uint)((IntVariant)v2).GetValue();
|
||
return ((IntVariant)v1).GetValue() != ((IntVariant)v2).GetValue();
|
||
case ComparisonKind.LE:
|
||
if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() <= (uint)((IntVariant)v2).GetValue();
|
||
return ((IntVariant)v1).GetValue() <= ((IntVariant)v2).GetValue();
|
||
case ComparisonKind.LT:
|
||
if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() < (uint)((IntVariant)v2).GetValue();
|
||
return ((IntVariant)v1).GetValue() < ((IntVariant)v2).GetValue();
|
||
//case ComparisonKind.GE:
|
||
default:
|
||
if (unsignedNanBranch) return (uint)((IntVariant)v1).GetValue() >= (uint)((IntVariant)v2).GetValue();
|
||
return ((IntVariant)v1).GetValue() >= ((IntVariant)v2).GetValue();
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// Token: 0x0600017F RID: 383 RVA: 0x00007EEC File Offset: 0x000060EC
|
||
private void Ldelema_(VariantBase vTypeId) // \u000F\u2002
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var idx = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
var val = new SdArrayValueVariant();
|
||
val.SetArray(array);
|
||
val.SetHeldType(type);
|
||
val.SetIndex(idx);
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x06000252 RID: 594 RVA: 0x00010780 File Offset: 0x0000E980
|
||
private void Ldelem_ref_(VariantBase dummy) // \u000F\u2003\u2000
|
||
{
|
||
Ldelem(SimpleTypeHelper.ObjectType);
|
||
}
|
||
|
||
// Token: 0x06000178 RID: 376 RVA: 0x00007D38 File Offset: 0x00005F38
|
||
private static void SerializeCrossDomain(Exception ex) // \u0002
|
||
{
|
||
if (ex == null)
|
||
{
|
||
return;
|
||
}
|
||
try
|
||
{
|
||
var type = ex.GetType();
|
||
if (type.IsSerializable)
|
||
{
|
||
var context = new StreamingContext(StreamingContextStates.CrossAppDomain);
|
||
var om = new ObjectManager(null, context);
|
||
var info = new SerializationInfo(type, new FormatterConverter());
|
||
ex.GetObjectData(info, context);
|
||
om.RegisterObject(ex, 1L, info);
|
||
om.DoFixups();
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001DF RID: 479 RVA: 0x0000ABCC File Offset: 0x00008DCC
|
||
private static void Throw(object ex) // \u0003
|
||
{
|
||
throw (Exception)ex;
|
||
}
|
||
|
||
// Token: 0x0600024D RID: 589 RVA: 0x000105A0 File Offset: 0x0000E7A0
|
||
private static void ThrowStoreCrossDomain(object ex) // \u0002
|
||
{
|
||
SerializeCrossDomain(ex as Exception);
|
||
Throw(ex);
|
||
}
|
||
|
||
// Token: 0x06000293 RID: 659 RVA: 0x00012398 File Offset: 0x00010598
|
||
private static VariantBase SubLong(VariantBase v1, VariantBase v2, bool bChecked, bool bUnsigned) // \u0005
|
||
{
|
||
var lvret = new LongVariant();
|
||
if (!bUnsigned)
|
||
{
|
||
var l1 = ((LongVariant)v1).GetValue();
|
||
var l2 = ((LongVariant)v2).GetValue();
|
||
long lret;
|
||
if (bChecked)
|
||
{
|
||
lret = checked(l1 - l2);
|
||
}
|
||
else
|
||
{
|
||
lret = l1 - l2;
|
||
}
|
||
lvret.SetValue(lret);
|
||
return lvret;
|
||
}
|
||
var u1 = (ulong)((LongVariant)v1).GetValue();
|
||
var u2 = (ulong)((LongVariant)v2).GetValue();
|
||
ulong uret;
|
||
if (bChecked)
|
||
{
|
||
uret = checked(u1 - u2);
|
||
}
|
||
else
|
||
{
|
||
uret = u1 - u2;
|
||
}
|
||
lvret.SetValue((long)uret);
|
||
return lvret;
|
||
}
|
||
|
||
private VariantBase Sub(bool ovf, bool signed)
|
||
{
|
||
VariantBase v1, v2;
|
||
var org_v2 = PopVariant();
|
||
var org_v1 = PopVariant();
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
if (ovf)
|
||
{
|
||
uint uiv;
|
||
checked
|
||
{
|
||
uiv = uv1 - uv2;
|
||
}
|
||
uvret.SetValue(uiv);
|
||
}
|
||
else
|
||
{
|
||
uvret.SetValue(uv1 - uv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
if (ovf)
|
||
{
|
||
checked
|
||
{
|
||
ivret.SetValue(iv1 - iv2);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ivret.SetValue(iv1 - iv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
dvret.SetValue(dv1 - dv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
fvret.SetValue(fv1 - fv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
if (ovf)
|
||
{
|
||
checked
|
||
{
|
||
lvret.SetValue(lv1 - lv2);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
lvret.SetValue(lv1 - lv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
if (ovf)
|
||
{
|
||
ulong ulv;
|
||
checked
|
||
{
|
||
ulv = ulv1 - ulv2;
|
||
}
|
||
ulvret.SetValue(ulv);
|
||
}
|
||
else
|
||
{
|
||
ulvret.SetValue(ulv1 - ulv2);
|
||
}
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Sub_Ovf : OpCodes.Sub) : OpCodes.Sub_Ovf_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x0600026B RID: 619 RVA: 0x00010F9C File Offset: 0x0000F19C
|
||
private void Sub_ovf_un_(VariantBase dummy) // \u0005\u2006\u2000
|
||
{
|
||
PushVariant(Sub(true, false));
|
||
}
|
||
|
||
// Token: 0x060001A8 RID: 424 RVA: 0x00008F7C File Offset: 0x0000717C
|
||
private void Sub_ovf_(VariantBase dummy) // \u0005\u2008
|
||
{
|
||
PushVariant(Sub(true, true));
|
||
}
|
||
|
||
// Token: 0x0600021C RID: 540 RVA: 0x0000C84C File Offset: 0x0000AA4C
|
||
private void Sub_(VariantBase dummy) // \u0006\u200A
|
||
{
|
||
PushVariant(Sub(false, true));
|
||
}
|
||
|
||
// Token: 0x06000271 RID: 625 RVA: 0x00011144 File Offset: 0x0000F344
|
||
private static VariantBase MulLong(VariantBase v1, VariantBase v2, bool bChecked, bool bUnsigned) // \u0003
|
||
{
|
||
var lvret = new LongVariant();
|
||
if (!bUnsigned)
|
||
{
|
||
var l1 = ((LongVariant)v1).GetValue();
|
||
var l2 = ((LongVariant)v2).GetValue();
|
||
long lret;
|
||
if (bChecked)
|
||
{
|
||
lret = checked(l1 * l2);
|
||
}
|
||
else
|
||
{
|
||
lret = l1 * l2;
|
||
}
|
||
lvret.SetValue(lret);
|
||
return lvret;
|
||
}
|
||
var u1 = (ulong)((LongVariant)v1).GetValue();
|
||
var u2 = (ulong)((LongVariant)v2).GetValue();
|
||
ulong uret;
|
||
if (bChecked)
|
||
{
|
||
uret = checked(u1 * u2);
|
||
}
|
||
else
|
||
{
|
||
uret = u1 * u2;
|
||
}
|
||
lvret.SetValue((long)uret);
|
||
return lvret;
|
||
}
|
||
|
||
private VariantBase Mul(bool ovf, bool signed)
|
||
{
|
||
VariantBase v1, v2;
|
||
var org_v2 = PopVariant();
|
||
var org_v1 = PopVariant();
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
if (ovf)
|
||
{
|
||
uint uiv;
|
||
checked
|
||
{
|
||
uiv = uv1 * uv2;
|
||
}
|
||
uvret.SetValue(uiv);
|
||
}
|
||
else
|
||
{
|
||
uvret.SetValue(uv1 * uv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
if (ovf)
|
||
{
|
||
checked
|
||
{
|
||
ivret.SetValue(iv1 * iv2);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ivret.SetValue(iv1 * iv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
dvret.SetValue(dv1 * dv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
fvret.SetValue(fv1 * fv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
if (ovf)
|
||
{
|
||
checked
|
||
{
|
||
lvret.SetValue(lv1 * lv2);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
lvret.SetValue(lv1 * lv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
if (ovf)
|
||
{
|
||
ulong ulv;
|
||
checked
|
||
{
|
||
ulv = ulv1 * ulv2;
|
||
}
|
||
ulvret.SetValue(ulv);
|
||
}
|
||
else
|
||
{
|
||
ulvret.SetValue(ulv1 * ulv2);
|
||
}
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Mul_Ovf : OpCodes.Mul) : OpCodes.Mul_Ovf_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x06000181 RID: 385 RVA: 0x00007F88 File Offset: 0x00006188
|
||
private void Mul_ovf_un_(VariantBase dummy) // \u0005\u2007
|
||
{
|
||
PushVariant(Mul(true, false));
|
||
}
|
||
|
||
// Token: 0x060001E1 RID: 481 RVA: 0x0000ABDC File Offset: 0x00008DDC
|
||
private void Mul_(VariantBase dummy) // \u0006\u2001\u2001
|
||
{
|
||
PushVariant(Mul(false, true));
|
||
}
|
||
|
||
// Token: 0x060001A0 RID: 416 RVA: 0x00008C98 File Offset: 0x00006E98
|
||
private void Mul_ovf_(VariantBase dummy) // \u0008\u2000\u2000
|
||
{
|
||
PushVariant(Mul(true, true));
|
||
}
|
||
|
||
VariantBase.Vtc CommonType(VariantBase org_v1, VariantBase org_v2, out VariantBase v1, out VariantBase v2, bool signed)
|
||
{
|
||
v1 = org_v1.Clone();
|
||
v2 = org_v2.Clone();
|
||
var tc1 = UnderlyingTypeCode(ref v1);
|
||
var tc2 = UnderlyingTypeCode(ref v2);
|
||
if (tc1 == VariantBase.Vtc.Tc18Object || tc2 == VariantBase.Vtc.Tc18Object)
|
||
return VariantBase.Vtc.Tc18Object;
|
||
VariantBase.Vtc ret = tc1;
|
||
if (!signed)
|
||
{
|
||
v1 = AsUnsigned(v1);
|
||
v2 = AsUnsigned(v2);
|
||
}
|
||
if(tc1 != tc2) switch (tc1)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
switch (tc2)
|
||
{
|
||
case VariantBase.Vtc.Tc24Long:
|
||
{
|
||
ret = tc2;
|
||
var new_v1 = signed ? (VariantBase)new LongVariant() : new UlongVariant();
|
||
new_v1.CopyFrom(v1);
|
||
v1 = new_v1;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
ret = tc2;
|
||
var new_v1 = new DoubleVariant();
|
||
new_v1.CopyFrom(v1);
|
||
v1 = new_v1;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
ret = tc2;
|
||
var new_v1 = new FloatVariant();
|
||
new_v1.CopyFrom(v1);
|
||
v1 = new_v1;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
switch (tc2)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
{
|
||
var new_v2 = signed ? (VariantBase)new LongVariant() : new UlongVariant();
|
||
new_v2.CopyFrom(v2);
|
||
v2 = new_v2;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
ret = tc2;
|
||
var new_v1 = new DoubleVariant();
|
||
new_v1.CopyFrom(v1);
|
||
v1 = new_v1;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
ret = tc2;
|
||
var new_v1 = new FloatVariant();
|
||
new_v1.CopyFrom(v1);
|
||
v1 = new_v1;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
switch (tc2)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
case VariantBase.Vtc.Tc24Long:
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
var new_v2 = new DoubleVariant();
|
||
new_v2.CopyFrom(v2);
|
||
v2 = new_v2;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
switch (tc2)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
case VariantBase.Vtc.Tc24Long:
|
||
{
|
||
var new_v2 = new FloatVariant();
|
||
new_v2.CopyFrom(v2);
|
||
v2 = new_v2;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
ret = tc2;
|
||
var new_v1 = new DoubleVariant();
|
||
new_v1.CopyFrom(v1);
|
||
v1 = new_v1;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
if(!signed) switch (ret)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
return VariantBase.Vtc.Tc9Uint;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
return VariantBase.Vtc.Tc7Ulong;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
private VariantBase.Vtc UnderlyingTypeCode(ref VariantBase v)
|
||
{
|
||
var ret = v.GetTypeCode();
|
||
if (ret == VariantBase.Vtc.Tc5Enum)
|
||
{
|
||
v = VariantBase.SignedVariantFromEnum((EnumVariant) v);
|
||
ret = Marshal.SizeOf(v.GetValueAbstract()) == 4 ? VariantBase.Vtc.Tc19Int : VariantBase.Vtc.Tc24Long;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
private VariantBase AsUnsigned(VariantBase v)
|
||
{
|
||
var tc = v.GetTypeCode();
|
||
var ret = v;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
ret = new UintVariant();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
ret = new UlongVariant();
|
||
break;
|
||
}
|
||
ret.CopyFrom(v);
|
||
return ret;
|
||
}
|
||
|
||
private VariantBase Add(bool ovf, bool signed)
|
||
{
|
||
VariantBase v1, v2;
|
||
var org_v2 = PopVariant();
|
||
var org_v1 = PopVariant();
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
if (ovf)
|
||
{
|
||
uint uiv;
|
||
checked
|
||
{
|
||
uiv = uv1 + uv2;
|
||
}
|
||
uvret.SetValue(uiv);
|
||
}
|
||
else
|
||
{
|
||
uvret.SetValue(uv1 + uv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
if (ovf)
|
||
{
|
||
checked
|
||
{
|
||
ivret.SetValue(iv1 + iv2);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ivret.SetValue(iv1 + iv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
dvret.SetValue(dv1 + dv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
fvret.SetValue(fv1 + fv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
if (ovf)
|
||
{
|
||
checked
|
||
{
|
||
lvret.SetValue(lv1 + lv2);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
lvret.SetValue(lv1 + lv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
if (ovf)
|
||
{
|
||
ulong ulv;
|
||
checked
|
||
{
|
||
ulv = ulv1 + ulv2;
|
||
}
|
||
ulvret.SetValue(ulv);
|
||
}
|
||
else
|
||
{
|
||
ulvret.SetValue(ulv1 + ulv2);
|
||
}
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Add_Ovf : OpCodes.Add) : OpCodes.Add_Ovf_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x0600022D RID: 557 RVA: 0x0000F880 File Offset: 0x0000DA80
|
||
private void Add_ovf_(VariantBase dummy) // \u0008\u2001
|
||
{
|
||
PushVariant(Add(true, true));
|
||
}
|
||
|
||
// Token: 0x06000238 RID: 568 RVA: 0x0000F998 File Offset: 0x0000DB98
|
||
private void Add_(VariantBase dummy) // \u0002\u2004
|
||
{
|
||
PushVariant(Add(false, true));
|
||
}
|
||
|
||
// Token: 0x0600029B RID: 667 RVA: 0x000126A0 File Offset: 0x000108A0
|
||
private void Add_ovf_un_(VariantBase dummy) // \u0002\u2004\u2000
|
||
{
|
||
PushVariant(Add(true, false));
|
||
}
|
||
|
||
private VariantBase Or(VariantBase org_v1, VariantBase org_v2)
|
||
{
|
||
VariantBase v1, v2;
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, true);
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
uvret.SetValue(uv1 | uv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
ivret.SetValue(iv1 | iv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
/*double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue(); // естественный алгоритм
|
||
long lv1 = (dv1 < 0) ? (long)dv1 : (long)(ulong)dv1;
|
||
long lv2 = (dv2 < 0) ? (long)dv2 : (long)(ulong)dv2;
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
var l64 = (ulong) lv1 | (ulong) lv2;
|
||
if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
|
||
dvret.SetValue(l64);*/
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
dvret.SetValue((4 == IntPtr.Size) ? Double.NaN : (double)0); // иногда у фреймворка бывает мусор, но чаще эти значения...
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
/*float fv1 = ((FloatVariant) v1).GetValue(), fv2 = ((FloatVariant) v2).GetValue(); // естественный алгоритм
|
||
long lv1 = (fv1 < 0) ? (long)fv1 : (long)(ulong)fv1;
|
||
long lv2 = (fv2 < 0) ? (long)fv2 : (long)(ulong)fv2;
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
var l64 = (ulong)lv1 | (ulong)lv2;
|
||
if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
|
||
fvret.SetValue(l64);*/
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
fvret.SetValue((4 == IntPtr.Size) ? float.NaN : (float)0.0); // иногда у фреймворка бывает мусор, но чаще эти значения...
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
{
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
lvret.SetValue(lv1 | lv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
ulvret.SetValue(ulv1 | ulv2);
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(OpCodes.Or);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x0600020F RID: 527 RVA: 0x0000C598 File Offset: 0x0000A798
|
||
private void Or_(VariantBase dummy) // \u0006\u2002\u2000
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
PushVariant(Or(v1, v2));
|
||
}
|
||
|
||
// Token: 0x060001D8 RID: 472 RVA: 0x0000A718 File Offset: 0x00008918
|
||
private void Throw_(VariantBase dummy) // \u0006\u2005\u2000
|
||
{
|
||
ThrowStoreCrossDomain(PopVariant().GetValueAbstract());
|
||
}
|
||
|
||
private VariantBase Rem(bool signed)
|
||
{
|
||
VariantBase v1, v2;
|
||
var org_v2 = PopVariant();
|
||
var org_v1 = PopVariant();
|
||
VariantBase ret;
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
|
||
if (IsFloating(org_v1) && org_v1.GetType() == org_v2.GetType() && !signed)
|
||
{
|
||
if (IntPtr.Size == 8) throw new InvalidProgramException();
|
||
if (tc == VariantBase.Vtc.Tc21Double)
|
||
{
|
||
ret = new DoubleVariant();
|
||
ret.SetValueAbstract(double.NaN);
|
||
}
|
||
else /*if (tc == VariantBase.Vtc.Tc8Float)*/
|
||
{
|
||
ret = new FloatVariant();
|
||
ret.SetValueAbstract(float.NaN);
|
||
}
|
||
}
|
||
else switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
uvret.SetValue(uv1 % uv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
ivret.SetValue(iv1 % iv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
if (Math.Abs(dv2) < double.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
|
||
dvret.SetValue(dv1 % dv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
if (Math.Abs(fv2) < float.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
|
||
fvret.SetValue(fv1 % fv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
lvret.SetValue(lv1 % lv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
ulvret.SetValue(ulv1 % ulv2);
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? OpCodes.Rem : OpCodes.Rem_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x060001CC RID: 460 RVA: 0x00009EAC File Offset: 0x000080AC
|
||
private void Rem_(VariantBase dummy) // \u0006\u2000\u2001
|
||
{
|
||
PushVariant(Rem(true));
|
||
}
|
||
|
||
// Token: 0x060001FA RID: 506 RVA: 0x0000BC3C File Offset: 0x00009E3C
|
||
private void Rem_un_(VariantBase dummy) // \u0006\u200B\u2000
|
||
{
|
||
PushVariant(Rem(false));
|
||
}
|
||
|
||
// Token: 0x06000254 RID: 596 RVA: 0x00010824 File Offset: 0x0000EA24
|
||
private static VariantBase Neg(VariantBase v) // \u0002
|
||
{
|
||
if (v.GetTypeCode() == VariantBase.Vtc.Tc19Int)
|
||
{
|
||
var i = ((IntVariant)v).GetValue();
|
||
var ivret = new IntVariant();
|
||
ivret.SetValue(-i);
|
||
return ivret;
|
||
}
|
||
if (v.GetTypeCode() == VariantBase.Vtc.Tc24Long)
|
||
{
|
||
var l = ((LongVariant)v).GetValue();
|
||
var lvret = new LongVariant();
|
||
lvret.SetValue(-l);
|
||
return lvret;
|
||
}
|
||
if (v.GetTypeCode() == VariantBase.Vtc.Tc21Double)
|
||
{
|
||
var dvret = new DoubleVariant();
|
||
dvret.SetValue(-((DoubleVariant)v).GetValue());
|
||
return dvret;
|
||
}
|
||
if (v.GetTypeCode() != VariantBase.Vtc.Tc5Enum)
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
var underlyingType = Enum.GetUnderlyingType(v.GetValueAbstract().GetType());
|
||
if (underlyingType == typeof(long) || underlyingType == typeof(ulong))
|
||
{
|
||
var lvret = new LongVariant();
|
||
lvret.SetValue(Convert.ToInt64(v.GetValueAbstract()));
|
||
return Neg(lvret);
|
||
}
|
||
var ivret2 = new IntVariant();
|
||
ivret2.SetValue(Convert.ToInt32(v.GetValueAbstract()));
|
||
return Neg(ivret2);
|
||
}
|
||
|
||
// Token: 0x060001F8 RID: 504 RVA: 0x0000BA00 File Offset: 0x00009C00
|
||
private void Neg_(VariantBase dummy) // \u0006\u2007
|
||
{
|
||
var v = PopVariant();
|
||
PushVariant(Neg(v));
|
||
}
|
||
|
||
// Token: 0x06000242 RID: 578 RVA: 0x0000FE38 File Offset: 0x0000E038
|
||
private static VariantBase DivLong(VariantBase v1, VariantBase v2, bool bUnsigned) // \u0003
|
||
{
|
||
var lvret = new LongVariant();
|
||
if (!bUnsigned)
|
||
{
|
||
var l1 = ((LongVariant)v1).GetValue();
|
||
var l2 = ((LongVariant)v2).GetValue();
|
||
lvret.SetValue(l1 / l2);
|
||
return lvret;
|
||
}
|
||
var u1 = (ulong)((LongVariant)v1).GetValue();
|
||
var u2 = (ulong)((LongVariant)v2).GetValue();
|
||
lvret.SetValue((long)(u1 / u2));
|
||
return lvret;
|
||
}
|
||
|
||
private VariantBase Div(bool signed)
|
||
{
|
||
VariantBase v1, v2;
|
||
var org_v2 = PopVariant();
|
||
var org_v1 = PopVariant();
|
||
VariantBase ret;
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, signed);
|
||
if (IsFloating(org_v1) && org_v1.GetType() == org_v2.GetType() && !signed)
|
||
{
|
||
if (IntPtr.Size == 8) throw new InvalidProgramException();
|
||
if(tc == VariantBase.Vtc.Tc21Double)
|
||
{
|
||
ret = new DoubleVariant();
|
||
ret.SetValueAbstract(double.NaN);
|
||
} else /*if (tc == VariantBase.Vtc.Tc8Float)*/
|
||
{
|
||
ret = new FloatVariant();
|
||
ret.SetValueAbstract(float.NaN);
|
||
}
|
||
} else switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
uvret.SetValue(uv1 / uv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
ivret.SetValue(iv1 / iv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue();
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
if(Math.Abs(dv2) < double.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
|
||
dvret.SetValue(dv1 / dv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
float fv1 = ((FloatVariant)v1).GetValue(), fv2 = ((FloatVariant)v2).GetValue();
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
if (Math.Abs(fv2) < float.Epsilon && org_v1.GetType() != org_v2.GetType()) throw new DivideByZeroException();
|
||
fvret.SetValue(fv1 / fv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
lvret.SetValue(lv1 / lv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
ulvret.SetValue(ulv1 / ulv2);
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? OpCodes.Div : OpCodes.Div_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x060001F0 RID: 496 RVA: 0x0000B664 File Offset: 0x00009864
|
||
private void Div_(VariantBase dummy) // \u0002\u2009
|
||
{
|
||
PushVariant(Div(true));
|
||
}
|
||
|
||
// Token: 0x0600017C RID: 380 RVA: 0x00007DF4 File Offset: 0x00005FF4
|
||
private void Div_un_(VariantBase dummy) // \u000E\u200B
|
||
{
|
||
PushVariant(Div(false));
|
||
}
|
||
|
||
// Token: 0x0600026D RID: 621 RVA: 0x00010FF4 File Offset: 0x0000F1F4
|
||
private static void EmitLdc(ILGenerator gen, int val) // \u0002
|
||
{
|
||
switch (val)
|
||
{
|
||
case -1:
|
||
gen.Emit(OpCodes.Ldc_I4_M1);
|
||
return;
|
||
case 0:
|
||
gen.Emit(OpCodes.Ldc_I4_0);
|
||
return;
|
||
case 1:
|
||
gen.Emit(OpCodes.Ldc_I4_1);
|
||
return;
|
||
case 2:
|
||
gen.Emit(OpCodes.Ldc_I4_2);
|
||
return;
|
||
case 3:
|
||
gen.Emit(OpCodes.Ldc_I4_3);
|
||
return;
|
||
case 4:
|
||
gen.Emit(OpCodes.Ldc_I4_4);
|
||
return;
|
||
case 5:
|
||
gen.Emit(OpCodes.Ldc_I4_5);
|
||
return;
|
||
case 6:
|
||
gen.Emit(OpCodes.Ldc_I4_6);
|
||
return;
|
||
case 7:
|
||
gen.Emit(OpCodes.Ldc_I4_7);
|
||
return;
|
||
case 8:
|
||
gen.Emit(OpCodes.Ldc_I4_8);
|
||
return;
|
||
default:
|
||
if (val > -129 && val < 128)
|
||
{
|
||
gen.Emit(OpCodes.Ldc_I4_S, (sbyte)val);
|
||
return;
|
||
}
|
||
gen.Emit(OpCodes.Ldc_I4, val);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000264 RID: 612 RVA: 0x00010C28 File Offset: 0x0000EE28
|
||
private static void EnsureClass(ILGenerator gen, Type t) // \u0003
|
||
{
|
||
if (t == SimpleTypeHelper.ObjectType)
|
||
{
|
||
return;
|
||
}
|
||
gen.Emit(OpCodes.Castclass, t);
|
||
}
|
||
|
||
// Token: 0x06000277 RID: 631 RVA: 0x0001180C File Offset: 0x0000FA0C
|
||
private static void EnsureType(ILGenerator gen, Type t) // \u0005
|
||
{
|
||
if (t.IsValueType || ElementedTypeHelper.TryGoToElementType(t).IsGenericParameter)
|
||
{
|
||
gen.Emit(OpCodes.Unbox_Any, t);
|
||
return;
|
||
}
|
||
EnsureClass(gen, t);
|
||
}
|
||
|
||
// Token: 0x06000217 RID: 535 RVA: 0x0000C7EC File Offset: 0x0000A9EC
|
||
private static void EnsureBoxed(ILGenerator gen, Type t) // \u0002
|
||
{
|
||
if (t.IsValueType || ElementedTypeHelper.TryGoToElementType(t).IsGenericParameter)
|
||
{
|
||
gen.Emit(OpCodes.Box, t);
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600023E RID: 574 RVA: 0x0000FA54 File Offset: 0x0000DC54
|
||
private DynamicExecutor DynamicFor(MethodBase mb, bool mayVirtual) // \u0002
|
||
{
|
||
DynamicMethod dynamicMethod; /*= null;
|
||
if (_alwaysFalse && (!mb.IsConstructor || !typeof(Delegate).IsAssignableFrom(mb.DeclaringType)))
|
||
{
|
||
dynamicMethod = new DynamicMethod(string.Empty, SimpleTypeHelper.ObjectType, new Type[]
|
||
{
|
||
SimpleTypeHelper.ObjectType,
|
||
ObjectArrayType
|
||
}, true);
|
||
}
|
||
if (dynamicMethod == null)*/
|
||
{
|
||
dynamicMethod = new DynamicMethod(string.Empty, SimpleTypeHelper.ObjectType, new[]
|
||
{
|
||
SimpleTypeHelper.ObjectType,
|
||
ObjectArrayType
|
||
}, typeof(VmExecutor).Module, true);
|
||
}
|
||
var iLGenerator = dynamicMethod.GetILGenerator();
|
||
var parameters = mb.GetParameters();
|
||
var array = new Type[parameters.Length];
|
||
var flag = false;
|
||
for (var i = 0; i < parameters.Length; i++)
|
||
{
|
||
var type = parameters[i].ParameterType;
|
||
if (type.IsByRef)
|
||
{
|
||
flag = true;
|
||
type = type.GetElementType();
|
||
}
|
||
array[i] = type;
|
||
}
|
||
var array2 = new LocalBuilder[array.Length];
|
||
if (array2.Length != 0)
|
||
{
|
||
dynamicMethod.InitLocals = true;
|
||
}
|
||
for (var j = 0; j < array.Length; j++)
|
||
{
|
||
array2[j] = iLGenerator.DeclareLocal(array[j]);
|
||
}
|
||
for (var k = 0; k < array.Length; k++)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Ldarg_1);
|
||
EmitLdc(iLGenerator, k);
|
||
iLGenerator.Emit(OpCodes.Ldelem_Ref);
|
||
EnsureType(iLGenerator, array[k]);
|
||
iLGenerator.Emit(OpCodes.Stloc, array2[k]);
|
||
}
|
||
if (flag)
|
||
{
|
||
iLGenerator.BeginExceptionBlock();
|
||
}
|
||
if (!mb.IsStatic && !mb.IsConstructor)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Ldarg_0);
|
||
var declaringType = mb.DeclaringType;
|
||
if (declaringType.IsValueType)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Unbox, declaringType);
|
||
mayVirtual = false;
|
||
}
|
||
else
|
||
{
|
||
EnsureClass(iLGenerator, declaringType);
|
||
}
|
||
}
|
||
for (var l = 0; l < array.Length; l++)
|
||
{
|
||
iLGenerator.Emit(parameters[l].ParameterType.IsByRef ? OpCodes.Ldloca_S : OpCodes.Ldloc, array2[l]);
|
||
}
|
||
if (mb.IsConstructor)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Newobj, (ConstructorInfo)mb);
|
||
EnsureBoxed(iLGenerator, mb.DeclaringType);
|
||
}
|
||
else
|
||
{
|
||
var methodInfo = (MethodInfo)mb;
|
||
if (!mayVirtual || mb.IsStatic)
|
||
{
|
||
iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
|
||
}
|
||
else
|
||
{
|
||
iLGenerator.EmitCall(OpCodes.Callvirt, methodInfo, null);
|
||
}
|
||
if (methodInfo.ReturnType == VoidType)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Ldnull);
|
||
}
|
||
else
|
||
{
|
||
EnsureBoxed(iLGenerator, methodInfo.ReturnType);
|
||
}
|
||
}
|
||
if (flag)
|
||
{
|
||
var local = iLGenerator.DeclareLocal(SimpleTypeHelper.ObjectType);
|
||
iLGenerator.Emit(OpCodes.Stloc, local);
|
||
iLGenerator.BeginFinallyBlock();
|
||
for (var m = 0; m < array.Length; m++)
|
||
{
|
||
if (parameters[m].ParameterType.IsByRef)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Ldarg_1);
|
||
EmitLdc(iLGenerator, m);
|
||
iLGenerator.Emit(OpCodes.Ldloc, array2[m]);
|
||
if (array2[m].LocalType.IsValueType || ElementedTypeHelper.TryGoToElementType(array2[m].LocalType).IsGenericParameter)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Box, array2[m].LocalType);
|
||
}
|
||
iLGenerator.Emit(OpCodes.Stelem_Ref);
|
||
}
|
||
}
|
||
iLGenerator.EndExceptionBlock();
|
||
iLGenerator.Emit(OpCodes.Ldloc, local);
|
||
}
|
||
iLGenerator.Emit(OpCodes.Ret);
|
||
return (DynamicExecutor)dynamicMethod.CreateDelegate(typeof(DynamicExecutor));
|
||
}
|
||
|
||
// Token: 0x06000209 RID: 521 RVA: 0x0000C4D0 File Offset: 0x0000A6D0
|
||
private static bool HasByRefParameter(MethodBase mb) // \u0002
|
||
{
|
||
return mb.GetParameters().Any(t => t.ParameterType.IsByRef);
|
||
}
|
||
|
||
// Token: 0x060001D9 RID: 473 RVA: 0x0000A72C File Offset: 0x0000892C
|
||
private object Invoke(MethodBase mb, object obj, object[] args) // \u0002
|
||
{
|
||
if (mb.IsConstructor)
|
||
{
|
||
// ReSharper disable once AssignNullToNotNullAttribute
|
||
return Activator.CreateInstance(mb.DeclaringType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
|
||
}
|
||
return mb.Invoke(obj, args);
|
||
}
|
||
|
||
// Token: 0x06000286 RID: 646 RVA: 0x00011EFC File Offset: 0x000100FC
|
||
private object InvokeDynamic(MethodBase mb, object obj, object[] args, bool mayVirtual) // \u0002
|
||
{
|
||
/*if (!_alwaysTrue)
|
||
{
|
||
return Invoke(mb, obj, args);
|
||
}*/
|
||
var key = new MethodBaseAndVirtual(mb, mayVirtual);
|
||
DynamicExecutor executor;
|
||
lock (_dynamicExecutors)
|
||
{
|
||
_dynamicExecutors.TryGetValue(key, out executor);
|
||
}
|
||
if (executor == null)
|
||
{
|
||
bool needFaster;
|
||
lock (_mbCallCnt)
|
||
{
|
||
int num;
|
||
_mbCallCnt.TryGetValue(mb, out num);
|
||
needFaster = num >= 50;
|
||
if (!needFaster)
|
||
{
|
||
_mbCallCnt[mb] = num + 1;
|
||
}
|
||
}
|
||
if (!needFaster && !mayVirtual && obj == null && !mb.IsStatic && !mb.IsConstructor)
|
||
{
|
||
needFaster = true;
|
||
}
|
||
if (!needFaster && HasByRefParameter(mb))
|
||
{
|
||
needFaster = true;
|
||
}
|
||
if (!needFaster)
|
||
{
|
||
return Invoke(mb, obj, args);
|
||
}
|
||
lock (_mbDynamicLock)
|
||
{
|
||
while (_mbDynamicLock.ContainsKey(mb))
|
||
{
|
||
Monitor.Wait(_mbDynamicLock);
|
||
}
|
||
_mbDynamicLock[mb] = null;
|
||
}
|
||
try
|
||
{
|
||
lock (_dynamicExecutors)
|
||
{
|
||
_dynamicExecutors.TryGetValue(key, out executor);
|
||
}
|
||
if (executor == null)
|
||
{
|
||
executor = DynamicFor(mb, mayVirtual);
|
||
lock (_dynamicExecutors)
|
||
{
|
||
_dynamicExecutors[key] = executor;
|
||
}
|
||
}
|
||
lock (_mbCallCnt)
|
||
{
|
||
_mbCallCnt.Remove(mb);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
lock (_mbDynamicLock)
|
||
{
|
||
_mbDynamicLock.Remove(mb);
|
||
Monitor.PulseAll(_mbDynamicLock);
|
||
}
|
||
}
|
||
}
|
||
return executor(obj, args);
|
||
}
|
||
|
||
// Token: 0x0600028D RID: 653 RVA: 0x000122A4 File Offset: 0x000104A4
|
||
private VariantBase FetchByAddr(VariantBase addr) // \u0003
|
||
{
|
||
if (!addr.IsAddr())
|
||
{
|
||
throw new ArgumentException();
|
||
}
|
||
var num = addr.GetTypeCode();
|
||
if (num == VariantBase.Vtc.Tc0VariantBaseHolder)
|
||
{
|
||
return ((VariantBaseHolder)addr).GetValue();
|
||
}
|
||
if (num != VariantBase.Vtc.Tc4FieldInfo)
|
||
{
|
||
switch (num)
|
||
{
|
||
case VariantBase.Vtc.Tc20MdArrayValue:
|
||
case VariantBase.Vtc.Tc22SdArrayValue:
|
||
{
|
||
var avv = (ArrayValueVariantBase)addr;
|
||
return VariantFactory.Convert(avv.GetValue(), avv.GetHeldType());
|
||
}
|
||
case VariantBase.Vtc.Tc23LocalsIdxHolder:
|
||
return _localVariables[((LocalsIdxHolderVariant)addr).GetValue()];
|
||
}
|
||
throw new ArgumentOutOfRangeException();
|
||
}
|
||
var fiv = (FieldInfoVariant)addr;
|
||
return VariantFactory.Convert(fiv.GetValue().GetValue(fiv.GetObject()), null);
|
||
}
|
||
|
||
// Token: 0x06000186 RID: 390 RVA: 0x00008150 File Offset: 0x00006350
|
||
private FieldInfo ResolveField(int id) // \u0002
|
||
{
|
||
FieldInfo result;
|
||
lock (AllMetadataById)
|
||
{
|
||
object md;
|
||
if (AllMetadataById.TryGetValue(id, out md))
|
||
{
|
||
result = (FieldInfo)md;
|
||
}
|
||
else
|
||
{
|
||
var U0003U2008 = ReadToken(id);
|
||
if (U0003U2008.IsVm == 0)
|
||
{
|
||
result = _module.ResolveField(U0003U2008.MetadataToken);
|
||
}
|
||
else
|
||
{
|
||
var u000Fu2006 = (VmFieldTokenInfo)U0003U2008.VmToken;
|
||
var expr_70 = GetTypeById(u000Fu2006.Class.MetadataToken);
|
||
var bindingAttr = BF(u000Fu2006.IsStatic);
|
||
var field = expr_70.GetField(u000Fu2006.Name, bindingAttr);
|
||
if (!expr_70.IsGenericType)
|
||
{
|
||
AllMetadataById.Add(id, field);
|
||
}
|
||
result = field;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x06000177 RID: 375 RVA: 0x00007CD8 File Offset: 0x00005ED8
|
||
private void Ldflda_(VariantBase vFieldId) // \u0003\u2009
|
||
{
|
||
var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
|
||
var reference = PopVariant();
|
||
var obj = reference.IsAddr() ? FetchByAddr(reference).GetValueAbstract() : reference.GetValueAbstract();
|
||
var val = new FieldInfoVariant();
|
||
val.SetValue(fieldInfo);
|
||
val.SetObject(obj);
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x0600018F RID: 399 RVA: 0x0000840C File Offset: 0x0000660C
|
||
private void Ldsflda_(VariantBase vFieldId) // \u000E\u2002
|
||
{
|
||
var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
|
||
var val = new FieldInfoVariant();
|
||
val.SetValue(fieldInfo);
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x0600017D RID: 381 RVA: 0x00007E20 File Offset: 0x00006020
|
||
private void Ldtoken_(VariantBase vToken) // \u0005\u2002\u2000
|
||
{
|
||
var t = ReadToken(((IntVariant)vToken).GetValue());
|
||
object obj;
|
||
if (t.IsVm == 0)
|
||
{
|
||
obj = ResolveNativeToken(t.MetadataToken);
|
||
}
|
||
else
|
||
{
|
||
switch (t.VmToken.TokenKind())
|
||
{
|
||
case VmTokenInfo.Kind.Class0:
|
||
obj = GetTypeById(((IntVariant)vToken).GetValue()).TypeHandle;
|
||
break;
|
||
case VmTokenInfo.Kind.Field1:
|
||
obj = ResolveField(((IntVariant)vToken).GetValue()).FieldHandle;
|
||
break;
|
||
case VmTokenInfo.Kind.Method2:
|
||
obj = FindMethodById(((IntVariant)vToken).GetValue()).MethodHandle;
|
||
break;
|
||
default:
|
||
throw new InvalidOperationException();
|
||
}
|
||
}
|
||
var push = new ObjectVariant();
|
||
push.SetValue(obj);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000206 RID: 518 RVA: 0x0000C1C8 File Offset: 0x0000A3C8
|
||
private void Ldfld_(VariantBase vFieldId) // \u0005\u2003\u2001
|
||
{
|
||
var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
|
||
var reference = PopVariant();
|
||
if (reference.IsAddr())
|
||
{
|
||
reference = FetchByAddr(reference);
|
||
}
|
||
var obj = reference.GetValueAbstract();
|
||
if (obj == null)
|
||
{
|
||
throw new NullReferenceException();
|
||
}
|
||
PushVariant(VariantFactory.Convert(fieldInfo.GetValue(obj), fieldInfo.FieldType));
|
||
}
|
||
|
||
// Token: 0x06000225 RID: 549 RVA: 0x0000F2CC File Offset: 0x0000D4CC
|
||
private void Ldsfld_(VariantBase vFieldId) // \u000F\u2004\u2000
|
||
{
|
||
var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
|
||
PushVariant(VariantFactory.Convert(fieldInfo.GetValue(null), fieldInfo.FieldType));
|
||
}
|
||
|
||
// Token: 0x0600024A RID: 586 RVA: 0x0001034C File Offset: 0x0000E54C
|
||
private void Newobj_(VariantBase vCtrId) // \u0002\u200A
|
||
{
|
||
var num = ((IntVariant)vCtrId).GetValue();
|
||
var methodBase = FindMethodById(num);
|
||
var declaringType = methodBase.DeclaringType;
|
||
var parameters = methodBase.GetParameters();
|
||
var expr_2A = parameters.Length;
|
||
var array = new object[expr_2A];
|
||
var dictionary = new Dictionary<int, VariantBase>();
|
||
for (var i = expr_2A - 1; i >= 0; i--)
|
||
{
|
||
var u000F = PopVariant();
|
||
if (u000F.IsAddr())
|
||
{
|
||
dictionary.Add(i, u000F);
|
||
u000F = FetchByAddr(u000F);
|
||
}
|
||
if (u000F.GetVariantType() != null)
|
||
{
|
||
u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
|
||
}
|
||
var u000F2 = VariantFactory.Convert(null, parameters[i].ParameterType).CopyFrom(u000F);
|
||
array[i] = u000F2.GetValueAbstract();
|
||
}
|
||
object obj;
|
||
try
|
||
{
|
||
obj = InvokeDynamic(methodBase, null, array, false);
|
||
}
|
||
catch (TargetInvocationException ex)
|
||
{
|
||
var expr_C2 = ex.InnerException ?? ex;
|
||
SerializeCrossDomain(expr_C2);
|
||
throw expr_C2;
|
||
}
|
||
foreach (var current in dictionary)
|
||
{
|
||
AssignByReference(current.Value, VariantFactory.Convert(array[current.Key], null));
|
||
}
|
||
PushVariant(VariantFactory.Convert(obj, declaringType));
|
||
}
|
||
|
||
// Token: 0x06000227 RID: 551 RVA: 0x0000F3B4 File Offset: 0x0000D5B4
|
||
private void AssignByReference(VariantBase refDest, VariantBase val) // \u0002
|
||
{
|
||
switch (refDest.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc0VariantBaseHolder:
|
||
((VariantBaseHolder)refDest).GetValue().CopyFrom(val);
|
||
return;
|
||
case VariantBase.Vtc.Tc4FieldInfo:
|
||
var refFieldInfoDest = (FieldInfoVariant)refDest;
|
||
var fieldInfo = refFieldInfoDest.GetValue();
|
||
fieldInfo.SetValue(refFieldInfoDest.GetObject(), VariantFactory.Convert(val.GetValueAbstract(), fieldInfo.FieldType).GetValueAbstract());
|
||
return;
|
||
case VariantBase.Vtc.Tc20MdArrayValue:
|
||
case VariantBase.Vtc.Tc22SdArrayValue:
|
||
var refArrayValueDest = (ArrayValueVariantBase)refDest;
|
||
refArrayValueDest.SetValue(VariantFactory.Convert(val.GetValueAbstract(), refArrayValueDest.GetHeldType()).GetValueAbstract());
|
||
return;
|
||
case VariantBase.Vtc.Tc23LocalsIdxHolder:
|
||
_localVariables[((LocalsIdxHolderVariant)refDest).GetValue()].CopyFrom(val);
|
||
return;
|
||
default:
|
||
throw new ArgumentOutOfRangeException();
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001E5 RID: 485 RVA: 0x0000AD10 File Offset: 0x00008F10
|
||
private void Invoke(MethodBase mb, bool mayVirtual) // \u0002
|
||
{
|
||
if (!mayVirtual && IsCompatible(mb))
|
||
{
|
||
mb = GenerateDynamicCall(mb, false);
|
||
}
|
||
var parameters = mb.GetParameters();
|
||
var num = parameters.Length;
|
||
var poppedArgs = new VariantBase[num];
|
||
var args = new object[num];
|
||
var wasLocked = default(BoolHolder);
|
||
try
|
||
{
|
||
LockIfInterlocked(ref wasLocked, mb, mayVirtual);
|
||
for (var i = num - 1; i >= 0; i--)
|
||
{
|
||
var u000F = PopVariant();
|
||
poppedArgs[i] = u000F;
|
||
if (u000F.IsAddr())
|
||
{
|
||
u000F = FetchByAddr(u000F);
|
||
}
|
||
if (u000F.GetVariantType() != null)
|
||
{
|
||
u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
|
||
}
|
||
var u000F2 = VariantFactory.Convert(null, parameters[i].ParameterType).CopyFrom(u000F);
|
||
args[i] = u000F2.GetValueAbstract();
|
||
}
|
||
VariantBase u000F3 = null;
|
||
if (!mb.IsStatic)
|
||
{
|
||
u000F3 = PopVariant();
|
||
if (u000F3?.GetVariantType() != null)
|
||
{
|
||
u000F3 = VariantFactory.Convert(null, u000F3.GetVariantType()).CopyFrom(u000F3);
|
||
}
|
||
}
|
||
object obj = null;
|
||
try
|
||
{
|
||
if (mb.IsConstructor)
|
||
{
|
||
obj = Activator.CreateInstance(mb.DeclaringType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
|
||
if (u000F3 != null && !u000F3.IsAddr())
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
AssignByReference(u000F3, VariantFactory.Convert(obj, mb.DeclaringType));
|
||
}
|
||
else
|
||
{
|
||
object poppedThis = null;
|
||
if (u000F3 != null)
|
||
{
|
||
var u000F4 = u000F3;
|
||
if (u000F3.IsAddr())
|
||
{
|
||
u000F4 = FetchByAddr(u000F3);
|
||
}
|
||
poppedThis = u000F4.GetValueAbstract();
|
||
}
|
||
try
|
||
{
|
||
if (!InvokeFilter(mb, poppedThis, ref obj, args))
|
||
{
|
||
if (mayVirtual && !mb.IsStatic && poppedThis == null)
|
||
{
|
||
throw new NullReferenceException();
|
||
}
|
||
if (!AlwaysFalse(mb, poppedThis, poppedArgs, args, mayVirtual, ref obj))
|
||
{
|
||
obj = InvokeDynamic(mb, poppedThis, args, mayVirtual);
|
||
}
|
||
}
|
||
if (u000F3 != null && u000F3.IsAddr())
|
||
{
|
||
AssignByReference(u000F3, VariantFactory.Convert(poppedThis, mb.DeclaringType));
|
||
}
|
||
}
|
||
catch (TargetInvocationException ex)
|
||
{
|
||
var cause = ex.InnerException ?? ex;
|
||
SerializeCrossDomain(cause);
|
||
throw cause;
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
for (var j = 0; j < poppedArgs.Length; j++)
|
||
{
|
||
var u000F5 = poppedArgs[j];
|
||
if (u000F5.IsAddr())
|
||
{
|
||
var obj3 = args[j];
|
||
AssignByReference(u000F5, VariantFactory.Convert(obj3, null));
|
||
}
|
||
}
|
||
}
|
||
var methodInfo = mb as MethodInfo;
|
||
if (methodInfo != null)
|
||
{
|
||
var returnType = methodInfo.ReturnType;
|
||
if (returnType != VoidType)
|
||
{
|
||
PushVariant(VariantFactory.Convert(obj, returnType));
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
UnlockInterlockedIfAny(ref wasLocked);
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001FD RID: 509 RVA: 0x0000BD88 File Offset: 0x00009F88
|
||
private void DoJmp(int pos, Type[] methodGenericArgs, Type[] classGenericArgs, bool mayVirtual) // \u0002
|
||
{
|
||
_srcVirtualizedStreamReader.BaseStream.Seek(pos, SeekOrigin.Begin);
|
||
DoNothing(_srcVirtualizedStreamReader);
|
||
var u0006 = ReadMethodHeader(_srcVirtualizedStreamReader);
|
||
var num = u0006.ArgsTypeToOutput.Length;
|
||
var array = new object[num];
|
||
var array2 = new VariantBase[num];
|
||
if (_currentClass != null & mayVirtual)
|
||
{
|
||
var num2 = u0006.IsStatic() ? 0 : 1;
|
||
var array3 = new Type[num - num2];
|
||
for (var i = num - 1; i >= num2; i--)
|
||
{
|
||
array3[i] = GetTypeById(u0006.ArgsTypeToOutput[i].TypeId);
|
||
}
|
||
var method = _currentClass.GetMethod(u0006.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty, null, array3, null);
|
||
_currentClass = null;
|
||
if (method != null)
|
||
{
|
||
Invoke(method, true);
|
||
return;
|
||
}
|
||
}
|
||
for (var j = num - 1; j >= 0; j--)
|
||
{
|
||
var u000F = PopVariant();
|
||
array2[j] = u000F;
|
||
if (u000F.IsAddr())
|
||
{
|
||
u000F = FetchByAddr(u000F);
|
||
}
|
||
if (u000F.GetVariantType() != null)
|
||
{
|
||
u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
|
||
}
|
||
var u000F2 = VariantFactory.Convert(null, GetTypeById(u0006.ArgsTypeToOutput[j].TypeId)).CopyFrom(u000F);
|
||
array[j] = u000F2.GetValueAbstract();
|
||
if (j == 0 & mayVirtual && !u0006.IsStatic() && array[j] == null)
|
||
{
|
||
throw new NullReferenceException();
|
||
}
|
||
}
|
||
var u0006u2007 = new VmExecutor(_instrCodesDb);
|
||
var callees = new object[]
|
||
{
|
||
_module.Assembly
|
||
};
|
||
object obj;
|
||
try
|
||
{
|
||
obj = u0006u2007.Invoke(_srcVirtualizedStream, pos, array, methodGenericArgs, classGenericArgs, callees);
|
||
}
|
||
finally
|
||
{
|
||
for (var k = 0; k < array2.Length; k++)
|
||
{
|
||
var u000F3 = array2[k];
|
||
if (u000F3.IsAddr())
|
||
{
|
||
var obj2 = array[k];
|
||
AssignByReference(u000F3, VariantFactory.Convert(obj2, null));
|
||
}
|
||
}
|
||
}
|
||
var type = u0006u2007.GetTypeById(u0006u2007._methodHeader.ReturnTypeId);
|
||
if (type != VoidType)
|
||
{
|
||
PushVariant(VariantFactory.Convert(obj, type));
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600027A RID: 634 RVA: 0x00011994 File Offset: 0x0000FB94
|
||
private void JmpToRef(VmMethodRefTokenInfo mref) // \u0002
|
||
{
|
||
//var arg_18_0 = (U0008U2007)U0003U2008.Get_u0005();
|
||
var methodBase = FindMethodById(mref.Pos, ReadToken(mref.Pos));
|
||
//methodBase.GetParameters();
|
||
var num = mref.Flags;
|
||
var mayVirtual = (num & 1073741824) != 0;
|
||
num &= -1073741825;
|
||
var methodGenericArgs = _methodGenericArgs;
|
||
var classGenericArgs = _classGenericArgs;
|
||
try
|
||
{
|
||
_methodGenericArgs = methodBase is ConstructorInfo ? Type.EmptyTypes : methodBase.GetGenericArguments();
|
||
_classGenericArgs = methodBase.DeclaringType.GetGenericArguments();
|
||
DoJmp(num, _methodGenericArgs, _classGenericArgs, mayVirtual);
|
||
}
|
||
finally
|
||
{
|
||
_methodGenericArgs = methodGenericArgs;
|
||
_classGenericArgs = classGenericArgs;
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001EE RID: 494 RVA: 0x0000B5FC File Offset: 0x000097FC
|
||
private void Jmp_(VariantBase vPos) // \u0008\u200B\u2000
|
||
{
|
||
var pos = ((IntVariant)vPos).GetValue();
|
||
var arg_29_0 = (pos & -2147483648) != 0;
|
||
var mayVirtual = (pos & 1073741824) != 0;
|
||
pos &= 1073741823;
|
||
if (arg_29_0)
|
||
{
|
||
DoJmp(pos, null, null, mayVirtual);
|
||
return;
|
||
}
|
||
JmpToRef((VmMethodRefTokenInfo)ReadToken(pos).VmToken);
|
||
}
|
||
|
||
// Token: 0x06000199 RID: 409 RVA: 0x00008660 File Offset: 0x00006860
|
||
private void Calli_(VariantBase dummy) // \u0003\u2002
|
||
{
|
||
var methodBase = ((MethodVariant)PopVariant()).GetValue();
|
||
Invoke(methodBase, false);
|
||
}
|
||
|
||
// Token: 0x06000184 RID: 388 RVA: 0x000080F4 File Offset: 0x000062F4
|
||
private void Call_(VariantBase vMethodId) // \u000E\u2003
|
||
{
|
||
var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
|
||
foreach (var arg in _variantOutputArgs)
|
||
{
|
||
PushVariant(arg);
|
||
}
|
||
Invoke(methodBase, false);
|
||
}
|
||
|
||
// Token: 0x06000191 RID: 401 RVA: 0x0000845C File Offset: 0x0000665C
|
||
private void Callvirt_(VariantBase vMethodId) // \u000E\u2005
|
||
{
|
||
var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
|
||
if (_currentClass != null)
|
||
{
|
||
var pars = methodBase.GetParameters();
|
||
var types = new Type[pars.Length];
|
||
var num = 0;
|
||
foreach (var parameterInfo in pars)
|
||
{
|
||
types[num++] = parameterInfo.ParameterType;
|
||
}
|
||
var method = _currentClass.GetMethod(methodBase.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty, null, types, null);
|
||
if (method != null)
|
||
{
|
||
methodBase = method;
|
||
}
|
||
_currentClass = null;
|
||
}
|
||
Invoke(methodBase, true);
|
||
}
|
||
|
||
// Token: 0x060001CE RID: 462 RVA: 0x0000A1A0 File Offset: 0x000083A0
|
||
private void Invoke(VariantBase vMethodId) // \u000E\u200A
|
||
{
|
||
var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
|
||
Invoke(methodBase, false);
|
||
}
|
||
|
||
// Token: 0x06000205 RID: 517 RVA: 0x0000C1A8 File Offset: 0x0000A3A8
|
||
[DebuggerNonUserCode]
|
||
private MethodBase FindMethodById(int methodId) // \u0002
|
||
{
|
||
return FindMethodById(methodId, ReadToken(methodId));
|
||
}
|
||
|
||
// Token: 0x06000171 RID: 369 RVA: 0x00007BBC File Offset: 0x00005DBC
|
||
private object Invoke(Stream srcVirtualizedStream, int pos, object[] args, Type[] methodGenericArgs, Type[] classGenericArgs, object[] callees) // \u0002
|
||
{
|
||
_srcVirtualizedStream = srcVirtualizedStream;
|
||
Seek(pos, srcVirtualizedStream, null);
|
||
return Invoke(args, methodGenericArgs, classGenericArgs, callees);
|
||
}
|
||
|
||
// Token: 0x06000172 RID: 370 RVA: 0x00007BDC File Offset: 0x00005DDC
|
||
private bool AlwaysFalse(MethodBase mb, object poppedThis, VariantBase[] poppedArgs, object[] args, bool mayVirtual, ref object obj) // \u0002
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Token: 0x06000179 RID: 377 RVA: 0x00007DA8 File Offset: 0x00005FA8
|
||
private void Leave_(VariantBase vTarget) // \u0006\u200B
|
||
{
|
||
OnException(null, ((UintVariant)vTarget).GetValue());
|
||
}
|
||
|
||
// Token: 0x06000180 RID: 384 RVA: 0x00007F48 File Offset: 0x00006148
|
||
private void Castclass_(VariantBase vTypeId) // \u0005\u2003
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var obj = PopVariant();
|
||
if (Isinst(obj, type))
|
||
{
|
||
PushVariant(obj);
|
||
return;
|
||
}
|
||
throw new InvalidCastException();
|
||
}
|
||
|
||
// Token: 0x06000185 RID: 389 RVA: 0x00008144 File Offset: 0x00006344
|
||
private void Ldc_i4_s_(VariantBase val) // \u000E\u2003\u2000
|
||
{
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x0600018B RID: 395 RVA: 0x0000827C File Offset: 0x0000647C
|
||
private void Stelem_i2_(VariantBase dummy) // \u000E\u200A\u2000
|
||
{
|
||
var obj = PopVariant().GetValueAbstract();
|
||
var idx = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
var elementType = array.GetType().GetElementType();
|
||
checked
|
||
{
|
||
if (elementType == typeof(short))
|
||
{
|
||
((short[])array)[(int)(IntPtr)idx] = (short)VariantFactory.Convert(obj, typeof(short)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType == typeof(ushort))
|
||
{
|
||
((ushort[])array)[(int)(IntPtr)idx] = (ushort)VariantFactory.Convert(obj, typeof(ushort)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType == typeof(char))
|
||
{
|
||
((char[])array)[(int)(IntPtr)idx] = (char)VariantFactory.Convert(obj, typeof(char)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType.IsEnum)
|
||
{
|
||
Stelem(elementType, obj, idx, array);
|
||
return;
|
||
}
|
||
Stelem(typeof(short), obj, idx, array);
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600018E RID: 398 RVA: 0x00008404 File Offset: 0x00006604
|
||
private void Stind_i_(VariantBase dummy) // \u000F\u2006
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x06000190 RID: 400 RVA: 0x00008440 File Offset: 0x00006640
|
||
private void Ldloc_0_(VariantBase dummy) // \u0006
|
||
{
|
||
PushVariant(_localVariables[0].Clone());
|
||
}
|
||
|
||
// Token: 0x06000193 RID: 403 RVA: 0x00008508 File Offset: 0x00006708
|
||
private void And_(VariantBase dummy) // \u000F\u200B\u2000
|
||
{
|
||
PushVariant(And(PopVariant(), PopVariant()));
|
||
}
|
||
|
||
// Token: 0x06000194 RID: 404 RVA: 0x00008534 File Offset: 0x00006734
|
||
private void Bge_un_(VariantBase vpos) // \u0006\u2009
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.GE, true))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000198 RID: 408 RVA: 0x00008628 File Offset: 0x00006828
|
||
private void Blt_un_(VariantBase vpos) // \u0006\u2006\u2000
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.LT, true))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000234 RID: 564 RVA: 0x0000F934 File Offset: 0x0000DB34
|
||
private void Bge_(VariantBase vpos) // \u0002\u200B
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.GE, false))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x060002AB RID: 683 RVA: 0x00012D80 File Offset: 0x00010F80
|
||
private void Blt_(VariantBase vpos) // \u0003\u2001
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.LT, false))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600023D RID: 573 RVA: 0x0000FA1C File Offset: 0x0000DC1C
|
||
private void Bgt_(VariantBase vpos) // \u000F\u2000\u2001
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.GT, false))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001A3 RID: 419 RVA: 0x00008D10 File Offset: 0x00006F10
|
||
private void Bgt_un_(VariantBase vpos) // \u0005\u2004
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.GT, true))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000261 RID: 609 RVA: 0x00010BB4 File Offset: 0x0000EDB4
|
||
private void Bne_un_(VariantBase vpos) // \u000F\u2007
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.NEQ, true))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600029D RID: 669 RVA: 0x000126E0 File Offset: 0x000108E0
|
||
private void Beq_(VariantBase vpos) // \u0002\u2007\u2000
|
||
{
|
||
var v2 = PopVariant();
|
||
if (UniCompare(PopVariant(), v2, ComparisonKind.EQ, false))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001B9 RID: 441 RVA: 0x000093F8 File Offset: 0x000075F8
|
||
private void Ble_un_(VariantBase vpos) // \u0003\u2007\u2000
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
if (UniCompare(v1, v2, ComparisonKind.LE, true))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
private static bool IsFloating(VariantBase v)
|
||
{
|
||
return v.GetTypeCode() == VariantBase.Vtc.Tc21Double || v.GetTypeCode() == VariantBase.Vtc.Tc8Float;
|
||
}
|
||
// Token: 0x06000297 RID: 663 RVA: 0x0001253C File Offset: 0x0001073C
|
||
private void Ble_(VariantBase vpos) // \u0002\u2003\u2000
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
if (UniCompare(v1, v2, ComparisonKind.LE, false))
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000228 RID: 552 RVA: 0x0000F480 File Offset: 0x0000D680
|
||
private void Brfalse_(VariantBase vpos) // \u0002\u2002
|
||
{
|
||
var val = PopVariant();
|
||
var num = val.GetTypeCode();
|
||
bool flag;
|
||
switch (num)
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
flag = !Convert.ToBoolean(((EnumVariant)val).GetValue());
|
||
break;
|
||
case VariantBase.Vtc.Tc13UIntPtr:
|
||
flag = ((UIntPtrVariant)val).GetValue() == UIntPtr.Zero;
|
||
break;
|
||
case VariantBase.Vtc.Tc17IntPtr:
|
||
flag = ((IntPtrVariant)val).GetValue() == IntPtr.Zero;
|
||
break;
|
||
case VariantBase.Vtc.Tc18Object:
|
||
flag = ((ObjectVariant)val).GetValue() == null;
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
flag = ((IntVariant)val).GetValue() == 0;
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
flag = ((LongVariant)val).GetValue() == 0L;
|
||
break;
|
||
default:
|
||
flag = val.GetValueAbstract() == null;
|
||
break;
|
||
}
|
||
if (flag)
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000274 RID: 628 RVA: 0x00011488 File Offset: 0x0000F688
|
||
private void ExecuteExceptionHandler() // \u0005
|
||
{
|
||
if (_ehStack.Count == 0)
|
||
{
|
||
if (_wasException)
|
||
{
|
||
_myBufferPos = _myBufferReader.GetBuffer().GetPos();
|
||
ThrowStoreCrossDomain(_exception);
|
||
}
|
||
return;
|
||
}
|
||
var ehFrame = _ehStack.PopBack();
|
||
if (ehFrame.Exception != null)
|
||
{
|
||
var toStack = new ObjectVariant();
|
||
toStack.SetValueAbstract(ehFrame.Exception);
|
||
PushVariant(toStack);
|
||
}
|
||
else
|
||
{
|
||
_evalStack.Clear();
|
||
}
|
||
JumpToPos(ehFrame.Pos);
|
||
}
|
||
|
||
// Token: 0x060001F2 RID: 498 RVA: 0x0000B6C8 File Offset: 0x000098C8
|
||
private void Switch_(VariantBase vSwitchPosArray) // \u0002\u200A\u2000
|
||
{
|
||
var vidx = PopVariant();
|
||
uint idx;
|
||
switch (vidx.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
idx = (uint)Convert.ToInt64(vidx.GetValueAbstract());
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
idx = (uint)((IntVariant)vidx).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
idx = (uint)((LongVariant)vidx).GetValue();
|
||
break;
|
||
default:
|
||
throw new InvalidOperationException();
|
||
}
|
||
var switchPosArray = (IntVariant[])((ArrayVariant)vSwitchPosArray).GetValue();
|
||
if (idx >= (ulong)switchPosArray.Length)
|
||
{
|
||
return;
|
||
}
|
||
JumpToPos((uint)switchPosArray[(int)idx].GetValue());
|
||
}
|
||
|
||
// Token: 0x060001FB RID: 507 RVA: 0x0000BC68 File Offset: 0x00009E68
|
||
private void Brtrue_(VariantBase vpos) // \u0008\u2007
|
||
{
|
||
var val = PopVariant();
|
||
var num = val.GetTypeCode();
|
||
bool flag;
|
||
switch (num)
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
flag = Convert.ToBoolean(((EnumVariant)val).GetValue());
|
||
break;
|
||
case VariantBase.Vtc.Tc13UIntPtr:
|
||
flag = ((UIntPtrVariant)val).GetValue() != UIntPtr.Zero;
|
||
break;
|
||
case VariantBase.Vtc.Tc17IntPtr:
|
||
flag = ((IntPtrVariant)val).GetValue() != IntPtr.Zero;
|
||
break;
|
||
case VariantBase.Vtc.Tc18Object:
|
||
flag = ((ObjectVariant)val).GetValue() != null;
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
flag = ((IntVariant)val).GetValue() != 0;
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
flag = ((LongVariant)val).GetValue() != 0L;
|
||
break;
|
||
default:
|
||
flag = val.GetValueAbstract() != null;
|
||
break;
|
||
}
|
||
if (flag)
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000214 RID: 532 RVA: 0x0000C764 File Offset: 0x0000A964
|
||
private void Br_(VariantBase vpos) // \u0005\u2008\u2000
|
||
{
|
||
JumpToPos(((UintVariant)vpos).GetValue());
|
||
}
|
||
|
||
private void Conv_r_un_(VariantBase dummy)
|
||
{
|
||
var pop = PopVariant();
|
||
double val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (Marshal.SizeOf(v) < 8)
|
||
val = (double)(uint)Convert.ToInt32(v);
|
||
else
|
||
val = (double)(ulong)Convert.ToInt64(v);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
val = (double)(uint)((IntVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
val = ((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
val = (double)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
val = (double)(ulong)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(double), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(OpCodes.Conv_R_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (double)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new DoubleVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
private void Conv_r(OpCode oc, Func<object, double> F)
|
||
{
|
||
var pop = PopVariant();
|
||
double val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
val = F(Marshal.SizeOf(v) < 8 ? Convert.ToInt32(v) : Convert.ToInt64(v));
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
val = F(((IntVariant)pop).GetValue());
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
val = F(((DoubleVariant)pop).GetValue());
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
val = F(((FloatVariant)pop).GetValue());
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
val = F(((LongVariant)pop).GetValue());
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(double), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(oc);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (double)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new DoubleVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
private void Conv_r4_(VariantBase dummy)
|
||
{
|
||
Conv_r(OpCodes.Conv_R4, o => (double)(float)Convert.ChangeType(o, typeof(float)));
|
||
}
|
||
private void Conv_r8_(VariantBase dummy)
|
||
{
|
||
Conv_r(OpCodes.Conv_R8, o => (double)Convert.ChangeType(o, typeof(double)));
|
||
}
|
||
|
||
// Token: 0x06000196 RID: 406 RVA: 0x00008600 File Offset: 0x00006800
|
||
private void Ldind_i4_(VariantBase dummy) // \u0002\u2001\u2000
|
||
{
|
||
Ldind(typeof(int));
|
||
}
|
||
|
||
// Token: 0x06000197 RID: 407 RVA: 0x00008614 File Offset: 0x00006814
|
||
private void Ldind_u1_(VariantBase dummy) // \u000E
|
||
{
|
||
Ldind(typeof(byte));
|
||
}
|
||
|
||
// Token: 0x0600019A RID: 410 RVA: 0x00008688 File Offset: 0x00006888
|
||
private void Isinst_(VariantBase vTypeId) // \u000F\u2007\u2000
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var obj = PopVariant();
|
||
if (Isinst(obj, type))
|
||
{
|
||
PushVariant(obj);
|
||
return;
|
||
}
|
||
PushVariant(new ObjectVariant());
|
||
}
|
||
|
||
// Token: 0x0600019D RID: 413 RVA: 0x00008B68 File Offset: 0x00006D68
|
||
private void Initobj_(VariantBase vTypeId) // \u0005\u2005\u2000
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var dest = PopVariant();
|
||
if (!type.IsValueType)
|
||
{
|
||
AssignByReference(dest, new ObjectVariant());
|
||
return;
|
||
}
|
||
var obj = FetchByAddr(dest).GetValueAbstract();
|
||
if (SimpleTypeHelper.IsNullableGeneric(type))
|
||
{
|
||
var val = new ObjectVariant();
|
||
val.SetVariantType(type);
|
||
AssignByReference(dest, val);
|
||
return;
|
||
}
|
||
var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
|
||
foreach (var fieldInfo in fields)
|
||
{
|
||
fieldInfo.SetValue(obj, CreateValueTypeInstance(fieldInfo.FieldType));
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600019E RID: 414 RVA: 0x00008C08 File Offset: 0x00006E08
|
||
private void Ldarg_s_(VariantBase vidx) // \u000E\u2000
|
||
{
|
||
var idx = (ByteVariant)vidx;
|
||
PushVariant(_variantOutputArgs[idx.GetValue()].Clone());
|
||
}
|
||
|
||
// Token: 0x06000244 RID: 580 RVA: 0x00010160 File Offset: 0x0000E360
|
||
private void Ldarga_s_(VariantBase vidx) // \u0008\u2001\u2001
|
||
{
|
||
var idx = (ByteVariant)vidx;
|
||
var push = new VariantBaseHolder();
|
||
push.SetValue(_variantOutputArgs[idx.GetValue()]);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000255 RID: 597 RVA: 0x00010910 File Offset: 0x0000EB10
|
||
private void Ldarga_(VariantBase vidx) // \u0006\u2001
|
||
{
|
||
var idx = (UshortVariant)vidx;
|
||
var push = new VariantBaseHolder();
|
||
push.SetValue(_variantOutputArgs[idx.GetValue()]);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x0600019F RID: 415 RVA: 0x00008C38 File Offset: 0x00006E38
|
||
private void Endfilter_(VariantBase dummy) // \u000F\u2001\u2000
|
||
{
|
||
if (((IntVariant)PopVariant()).GetValue() != 0)
|
||
{
|
||
_ehStack.PushBack(new ExcHandlerFrame
|
||
{
|
||
Pos = (uint)_myBufferReader.GetBuffer().GetPos(),
|
||
Exception = _exception
|
||
});
|
||
_wasException = false;
|
||
}
|
||
ExecuteExceptionHandler();
|
||
}
|
||
|
||
// Token: 0x060001A2 RID: 418 RVA: 0x00008CFC File Offset: 0x00006EFC
|
||
private void Ldind_r4_(VariantBase dummy) // \u0008\u2009\u2000
|
||
{
|
||
Ldind(typeof(float));
|
||
}
|
||
|
||
// Token: 0x060001A4 RID: 420 RVA: 0x00008D48 File Offset: 0x00006F48
|
||
private void Stsfld_(VariantBase vFieldId) // \u000F\u2008
|
||
{
|
||
var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
|
||
var val = VariantFactory.Convert(PopVariant().GetValueAbstract(), fieldInfo.FieldType);
|
||
fieldInfo.SetValue(null, val.GetValueAbstract());
|
||
}
|
||
|
||
// Token: 0x060001A5 RID: 421 RVA: 0x00008D90 File Offset: 0x00006F90
|
||
private void Ldloc_3_(VariantBase dummy) // \u0003\u2001\u2001
|
||
{
|
||
PushVariant(_localVariables[3].Clone());
|
||
}
|
||
|
||
// Token: 0x060001A7 RID: 423 RVA: 0x00008F68 File Offset: 0x00007168
|
||
private void Stelem_r8_(VariantBase dummy) // \u000E\u2006\u2000
|
||
{
|
||
Stelem(typeof(double));
|
||
}
|
||
|
||
// Token: 0x060001AA RID: 426 RVA: 0x00008FBC File Offset: 0x000071BC
|
||
private void Ceq_(VariantBase dummy) // \u0006\u2008
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(UniCompare(PopVariant(), PopVariant(), ComparisonKind.EQ, false) ? 1 : 0);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x060001AC RID: 428 RVA: 0x00009030 File Offset: 0x00007230
|
||
private void Stelem_i4_(VariantBase dummy) // \u000E\u2001\u2000
|
||
{
|
||
var obj = PopVariant().GetValueAbstract();
|
||
var idx = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
var elementType = array.GetType().GetElementType();
|
||
checked
|
||
{
|
||
if (elementType == typeof(int))
|
||
{
|
||
((int[])array)[(int)(IntPtr)idx] = (int)VariantFactory.Convert(obj, typeof(int)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType == typeof(uint))
|
||
{
|
||
((uint[])array)[(int)(IntPtr)idx] = (uint)VariantFactory.Convert(obj, typeof(uint)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType.IsEnum)
|
||
{
|
||
Stelem(elementType, obj, idx, array);
|
||
return;
|
||
}
|
||
Stelem(typeof(int), obj, idx, array);
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001AD RID: 429 RVA: 0x00009100 File Offset: 0x00007300
|
||
private void Stind_i1_(VariantBase dummy) // \u0005\u2000\u2000
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x060001AF RID: 431 RVA: 0x00009114 File Offset: 0x00007314
|
||
private object ResolveNativeToken(int token) // \u0002
|
||
{
|
||
var num = HiByte.Extract(token);
|
||
object result;
|
||
if (num > 67108864)
|
||
{
|
||
if (num <= 167772160)
|
||
{
|
||
if (num != 100663296)
|
||
{
|
||
if (num != 167772160)
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
try
|
||
{
|
||
result = _module.ModuleHandle.ResolveFieldHandle(token);
|
||
return result;
|
||
}
|
||
catch
|
||
{
|
||
try
|
||
{
|
||
result = _module.ModuleHandle.ResolveMethodHandle(token);
|
||
}
|
||
catch
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
return result;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (num == 452984832)
|
||
{
|
||
result = _module.ModuleHandle.ResolveTypeHandle(token);
|
||
return result;
|
||
}
|
||
if (num != 721420288)
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
}
|
||
result = _module.ModuleHandle.ResolveMethodHandle(token);
|
||
return result;
|
||
}
|
||
if (num != 16777216 && num != 33554432)
|
||
{
|
||
if (num != 67108864)
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
result = _module.ModuleHandle.ResolveFieldHandle(token);
|
||
return result;
|
||
}
|
||
result = _module.ModuleHandle.ResolveTypeHandle(token);
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x060001B0 RID: 432 RVA: 0x0000923C File Offset: 0x0000743C
|
||
private void Ldloc_2_(VariantBase dummy) // \u0008\u2008
|
||
{
|
||
PushVariant(_localVariables[2].Clone());
|
||
}
|
||
|
||
// Token: 0x060001B1 RID: 433 RVA: 0x00009258 File Offset: 0x00007458
|
||
private void Constrained_(VariantBase vTypeId) // \u0002\u2000\u2000
|
||
{
|
||
_currentClass = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
}
|
||
|
||
// Token: 0x060001B2 RID: 434 RVA: 0x00009280 File Offset: 0x00007480
|
||
private void Ldftn_(VariantBase vMethodId) // \U0003\U2008
|
||
{
|
||
var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
|
||
var push = new MethodVariant();
|
||
push.SetValue(methodBase);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060001B4 RID: 436 RVA: 0x000092C8 File Offset: 0x000074C8
|
||
private void Ldnull_(VariantBase dummy) // \u0005\u2002\u2001
|
||
{
|
||
PushVariant(new ObjectVariant());
|
||
}
|
||
|
||
private void Conv_ovf_u8_un_(VariantBase dummy)
|
||
{
|
||
Conv_u8(true, false);
|
||
}
|
||
|
||
// Token: 0x060001B8 RID: 440 RVA: 0x000093F0 File Offset: 0x000075F0
|
||
private void Stind_i2_(VariantBase dummy) // \u0003\u2000\u2000
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
private void Conv_ovf_u2_un_(VariantBase dummy)
|
||
{
|
||
Conv_u2(true, false);
|
||
}
|
||
|
||
private void Conv_u2(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
ushort val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
if (ovf)
|
||
{
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (signed)
|
||
val = Convert.ToUInt16(v);
|
||
else
|
||
val = Convert.ToUInt16((ulong)Convert.ToInt64(v));
|
||
break;
|
||
}
|
||
val = (ushort)VariantBase.SignedLongFromEnum((EnumVariant)pop);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
if (ovf && !signed)
|
||
{
|
||
val = Convert.ToUInt16((uint)((IntVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = ovf ? Convert.ToUInt16(((IntVariant)pop).GetValue()) : (ushort)((IntVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = checked((ushort) ((DoubleVariant) pop).GetValue());
|
||
break;
|
||
}
|
||
val = (ushort)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = checked((ushort)((FloatVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (ushort)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
if (signed)
|
||
val = checked((ushort)((LongVariant)pop).GetValue());
|
||
else
|
||
val = Convert.ToUInt16((ulong)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (ushort)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(ushort), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U2 : OpCodes.Conv_U2) : OpCodes.Conv_Ovf_U2_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (ushort)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new UshortVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060001AE RID: 430 RVA: 0x00009108 File Offset: 0x00007308
|
||
private void Conv_ovf_u2_(VariantBase dummy) // \u0008\u2005\u2000
|
||
{
|
||
Conv_u2(true, true);
|
||
}
|
||
|
||
// Token: 0x06000292 RID: 658 RVA: 0x0001238C File Offset: 0x0001058C
|
||
private void Conv_u2_(VariantBase dummy) // \u000F\u2002\u2000
|
||
{
|
||
Conv_u2(false, true);
|
||
}
|
||
|
||
private void Conv_u1(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
byte val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
if (ovf)
|
||
{
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
val = signed ? Convert.ToByte(v) : Convert.ToByte((ulong)Convert.ToInt64(v));
|
||
break;
|
||
}
|
||
val = (byte)VariantBase.SignedLongFromEnum((EnumVariant)pop);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
if (ovf && !signed)
|
||
{
|
||
val = Convert.ToByte((uint)((IntVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = ovf ? Convert.ToByte(((IntVariant)pop).GetValue()) : (byte)((IntVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = signed ? checked((byte)((DoubleVariant)pop).GetValue()) : Convert.ToByte(((DoubleVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (byte)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = checked((byte)((FloatVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (byte)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
val = checked((byte)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (byte)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(byte), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U1 : OpCodes.Conv_U1) : OpCodes.Conv_Ovf_U1_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (byte)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new ByteVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000182 RID: 386 RVA: 0x00007FB4 File Offset: 0x000061B4
|
||
private void Conv_ovf_i1_(VariantBase dummy) // \u0008\u2004
|
||
{
|
||
Conv_i1(true, true);
|
||
}
|
||
|
||
// Token: 0x06000188 RID: 392 RVA: 0x00008238 File Offset: 0x00006438
|
||
private void Conv_u4_(VariantBase dummy) // \u0008\u2003\u2001
|
||
{
|
||
Conv_u4(false, true);
|
||
}
|
||
|
||
// Token: 0x0600018A RID: 394 RVA: 0x00008270 File Offset: 0x00006470
|
||
private void Conv_ovf_i_(VariantBase dummy) // \u0008\u2003\u2000
|
||
{
|
||
Conv_i(true, true);
|
||
}
|
||
|
||
// Token: 0x060001CF RID: 463 RVA: 0x0000A1CC File Offset: 0x000083CC
|
||
private void Conv_i_(VariantBase dummy) // \u0008\u2005
|
||
{
|
||
Conv_i(false, true);
|
||
}
|
||
|
||
// Token: 0x060001FF RID: 511 RVA: 0x0000BFC8 File Offset: 0x0000A1C8
|
||
private void Conv_u4(bool ovf, bool signed) // \u0005
|
||
{
|
||
var pop = PopVariant();
|
||
uint val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
if (ovf)
|
||
{
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant) pop).GetValueAbstract();
|
||
if (signed || Marshal.SizeOf(v) < 8)
|
||
val = signed ? Convert.ToUInt32(v) : (uint)Convert.ToInt32(v);
|
||
else
|
||
val = Convert.ToUInt32(Convert.ToUInt64(v));
|
||
break;
|
||
}
|
||
val = (uint)VariantBase.SignedLongFromEnum((EnumVariant)pop);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
if (ovf && signed)
|
||
{
|
||
val = checked((uint)((IntVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (uint)((IntVariant)pop).GetValue(); // err fixed and unit tested by ursoft (was ushort)
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = checked((uint)((DoubleVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (uint)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = checked((uint)((FloatVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (uint)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
val = checked((uint)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (uint)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(UInt32), new []{ typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U4 : OpCodes.Conv_U4) : OpCodes.Conv_Ovf_U4_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (uint) dyn.Invoke(null, new[] {pop.GetValueAbstract()});
|
||
break;
|
||
}
|
||
var push = new IntVariant();
|
||
push.SetValue((int)val);
|
||
PushVariant(push);
|
||
}
|
||
private void Conv_i4(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
int val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
if (ovf)
|
||
{
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (signed)
|
||
val = Convert.ToInt32(v);
|
||
else
|
||
val = Convert.ToInt32((ulong)Convert.ToInt64(v));
|
||
break;
|
||
}
|
||
val = (int)VariantBase.SignedLongFromEnum((EnumVariant)pop);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
if (ovf && !signed)
|
||
{
|
||
val = Convert.ToInt32((uint)((IntVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = ((IntVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = checked((int)((DoubleVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (int)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = checked((int)((FloatVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (int)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
if(signed)
|
||
val = checked((int)((LongVariant)pop).GetValue());
|
||
else
|
||
val = Convert.ToInt32((ulong)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (int)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(Int32), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I4 : OpCodes.Conv_I4) : OpCodes.Conv_Ovf_I4_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (int)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new IntVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000294 RID: 660 RVA: 0x00012414 File Offset: 0x00010614
|
||
private void Conv_ovf_u4_(VariantBase dummy) // \u000F\u200A
|
||
{
|
||
Conv_u4(true, true);
|
||
}
|
||
|
||
// Token: 0x06000200 RID: 512 RVA: 0x0000C0B0 File Offset: 0x0000A2B0
|
||
private void Conv_ovf_u1_(VariantBase dummy) // \u0008\u2007\u2000
|
||
{
|
||
Conv_u1(true, true);
|
||
}
|
||
|
||
private void Conv_ovf_i2_un_(VariantBase dummy)
|
||
{
|
||
Conv_i2(true, false);
|
||
}
|
||
|
||
private void Conv_i2(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
short val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
if (ovf)
|
||
{
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (signed)
|
||
val = Convert.ToInt16(v);
|
||
else
|
||
val = Convert.ToInt16((ulong)Convert.ToInt64(v));
|
||
break;
|
||
}
|
||
val = (short)VariantBase.SignedLongFromEnum((EnumVariant)pop);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
if (ovf && !signed)
|
||
{
|
||
val = Convert.ToInt16((uint)((IntVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = ovf ? Convert.ToInt16(((IntVariant)pop).GetValue()) : (short)((IntVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = signed ? checked((short)((DoubleVariant)pop).GetValue()) :
|
||
(IntPtr.Size == 4 ? Convert.ToInt16(Convert.ToUInt16((long)((DoubleVariant)pop).GetValue())) :
|
||
Convert.ToInt16((long)((DoubleVariant)pop).GetValue()));
|
||
break;
|
||
}
|
||
val = (short)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = signed ? checked((short)((FloatVariant)pop).GetValue()) :
|
||
(IntPtr.Size == 4 ? Convert.ToInt16(Convert.ToUInt16((long)((FloatVariant)pop).GetValue())) :
|
||
Convert.ToInt16((long)((FloatVariant)pop).GetValue()));
|
||
break;
|
||
}
|
||
val = (short)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
if (signed)
|
||
val = checked((short)((LongVariant)pop).GetValue());
|
||
else
|
||
val = Convert.ToInt16((ulong)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (short)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(short), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I2 : OpCodes.Conv_I2) : OpCodes.Conv_Ovf_I2_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (short)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new ShortVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060001FE RID: 510 RVA: 0x0000BFBC File Offset: 0x0000A1BC
|
||
private void Conv_i2_(VariantBase dummy) // \u0006\u2001\u2000
|
||
{
|
||
Conv_i2(false, true);
|
||
}
|
||
|
||
// Token: 0x060002A8 RID: 680 RVA: 0x00012D2C File Offset: 0x00010F2C
|
||
private void Conv_ovf_i4_(VariantBase dummy) // \u000F\u2000\u2000
|
||
{
|
||
Conv_i4(true, true);
|
||
}
|
||
|
||
private void Conv_i8(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
long val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (!signed && ovf && Marshal.SizeOf(v) > 4)
|
||
val = checked((long)(ulong)Convert.ToInt64(v));
|
||
else
|
||
val = (signed || Marshal.SizeOf(v) > 4) ? Convert.ToInt64(v) :
|
||
(uint)(ulong)Convert.ToInt64(v);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv = ((IntVariant)pop).GetValue();
|
||
if (signed)
|
||
val = iv;
|
||
else
|
||
val = (long)(uint)iv;
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = checked((long)((DoubleVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (long)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = checked((long)((FloatVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (long)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
if (signed)
|
||
val = ((LongVariant)pop).GetValue();
|
||
else
|
||
val = Convert.ToInt64((ulong)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = ((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(long), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I8 : OpCodes.Conv_I8) : OpCodes.Conv_Ovf_I8_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (long)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new LongVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000219 RID: 537 RVA: 0x0000C824 File Offset: 0x0000AA24
|
||
private void Conv_ovf_i8_(VariantBase dummy) // \u0008\u2002\u2000
|
||
{
|
||
Conv_i8(true, true);
|
||
}
|
||
|
||
private void Conv_i1(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
sbyte val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
if (ovf)
|
||
{
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
val = signed ? Convert.ToSByte(v) : Convert.ToSByte((ulong)Convert.ToInt64(v));
|
||
break;
|
||
}
|
||
val = (sbyte)VariantBase.SignedLongFromEnum((EnumVariant)pop);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
if (ovf && !signed)
|
||
{
|
||
val = Convert.ToSByte((uint)((IntVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = ovf ? Convert.ToSByte(((IntVariant)pop).GetValue()) : (sbyte)((IntVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = signed ? checked((sbyte)((DoubleVariant)pop).GetValue()) :
|
||
(IntPtr.Size == 4 ? Convert.ToSByte(Convert.ToByte(((DoubleVariant)pop).GetValue())) :
|
||
Convert.ToSByte((long)((DoubleVariant)pop).GetValue()));
|
||
break;
|
||
}
|
||
val = (sbyte)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = signed ? checked((sbyte)((FloatVariant)pop).GetValue()) :
|
||
(IntPtr.Size == 4 ? Convert.ToSByte(Convert.ToByte(((FloatVariant)pop).GetValue())) :
|
||
Convert.ToSByte((long)((FloatVariant)pop).GetValue()));
|
||
break;
|
||
}
|
||
val = (sbyte)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf)
|
||
{
|
||
if (signed)
|
||
val = checked((sbyte)((LongVariant)pop).GetValue());
|
||
else
|
||
val = Convert.ToSByte((ulong)((LongVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (sbyte)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(SByte), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I1 : OpCodes.Conv_I1) : OpCodes.Conv_Ovf_I1_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (sbyte)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new SbyteVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060002A6 RID: 678 RVA: 0x00012CD0 File Offset: 0x00010ED0
|
||
private void Conv_i1_(VariantBase dummy) // \u000E\u2006
|
||
{
|
||
Conv_i1(false, true);
|
||
}
|
||
|
||
// Token: 0x06000285 RID: 645 RVA: 0x00011EF0 File Offset: 0x000100F0
|
||
private void Conv_ovf_i2_(VariantBase dummy) // \u0002\u2000\u2001
|
||
{
|
||
Conv_i2(true, true);
|
||
}
|
||
|
||
// Token: 0x0600018D RID: 397 RVA: 0x000083F8 File Offset: 0x000065F8
|
||
private void Conv_u_(VariantBase dummy) // \u000F\u2003\u2001
|
||
{
|
||
Conv_u(false, true);
|
||
}
|
||
|
||
// Token: 0x060001EF RID: 495 RVA: 0x0000B658 File Offset: 0x00009858
|
||
private void Conv_ovf_u_(VariantBase dummy) // \u0002\u2000
|
||
{
|
||
Conv_u(true, true);
|
||
}
|
||
|
||
// Token: 0x06000215 RID: 533 RVA: 0x0000C784 File Offset: 0x0000A984
|
||
private void Conv_u1_(VariantBase dummy) // \u0008\u2002
|
||
{
|
||
Conv_u1(false, true);
|
||
}
|
||
|
||
// Token: 0x06000211 RID: 529 RVA: 0x0000C690 File Offset: 0x0000A890
|
||
private void Conv_ovf_i_un_(VariantBase dummy) // \u000F
|
||
{
|
||
Conv_i(true, false);
|
||
}
|
||
|
||
// Token: 0x06000229 RID: 553 RVA: 0x0000F56C File Offset: 0x0000D76C
|
||
private void Conv_i4_(VariantBase dummy) // \u0003\u2005\u2000
|
||
{
|
||
Conv_i4(false, true);
|
||
}
|
||
|
||
private void Conv_ovf_i8_un_(VariantBase dummy)
|
||
{
|
||
Conv_i8(true, false);
|
||
}
|
||
|
||
// Token: 0x06000253 RID: 595 RVA: 0x00010790 File Offset: 0x0000E990
|
||
private void Conv_ovf_u4_un_(VariantBase dummy) // \u0002\u2009\u2000
|
||
{
|
||
Conv_u4(true, false);
|
||
}
|
||
|
||
// Token: 0x06000284 RID: 644 RVA: 0x00011EE4 File Offset: 0x000100E4
|
||
private void Conv_i8_(VariantBase dummy) // \u0003\u2006\u2000
|
||
{
|
||
Conv_i8(false, true);
|
||
}
|
||
|
||
// Token: 0x0600028A RID: 650 RVA: 0x000121B8 File Offset: 0x000103B8
|
||
private void Conv_ovf_u_un_(VariantBase dummy) // \u000F\u200B
|
||
{
|
||
Conv_u(true, false);
|
||
}
|
||
|
||
private unsafe void Conv_i(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
var push = new IntPtrVariant();
|
||
long val;
|
||
var tc = pop.GetTypeCode();
|
||
if (tc == VariantBase.Vtc.Tc21Double || tc == VariantBase.Vtc.Tc8Float)
|
||
signed = true;
|
||
long maxVal = long.MaxValue, minVal = signed ? long.MinValue : 0;
|
||
if (IntPtr.Size == 4)
|
||
{
|
||
maxVal = signed ? Int32.MaxValue : UInt32.MaxValue;
|
||
minVal = signed ? Int32.MinValue : 0;
|
||
}
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (IntPtr.Size == 4)
|
||
{
|
||
if (ovf) val = Convert.ToInt32(v);
|
||
else val = (int)Convert.ToInt64(v);
|
||
}
|
||
else
|
||
{
|
||
val = (signed || Marshal.SizeOf(v) > 4 || !ovf) ? Convert.ToInt64(v) :
|
||
(uint)(ulong)Convert.ToInt64(v);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv = ((IntVariant) pop).GetValue();
|
||
if (IntPtr.Size == 4 || signed)
|
||
val = iv;
|
||
else
|
||
val = (long)(uint)iv;
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
double dv = ((DoubleVariant)pop).GetValue();
|
||
if (dv <= maxVal && dv >= minVal)
|
||
val = (long)dv;
|
||
else
|
||
{
|
||
if (ovf) throw new OverflowException();
|
||
val = (IntPtr.Size == 4) ? Int32.MinValue : Int64.MinValue; // не мусор ли?
|
||
}
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
double dv = (double) ((FloatVariant) pop).GetValue();
|
||
if (dv <= maxVal && dv >= minVal)
|
||
val = (long) dv;
|
||
else
|
||
{
|
||
if (ovf) throw new OverflowException();
|
||
val = (IntPtr.Size == 4) ? Int32.MinValue : Int64.MinValue; // не мусор ли?
|
||
}
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
val = ((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_I : OpCodes.Conv_I) : OpCodes.Conv_Ovf_I_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
push.SetValue(((IntPtr)dyn.Invoke(null, new[] { pop.GetValueAbstract() })));
|
||
PushVariant(push);
|
||
return;
|
||
}
|
||
if ((ovf == false) || (val <= maxVal && val >= minVal))
|
||
{
|
||
push.SetValue(new IntPtr((void*)val));
|
||
PushVariant(push);
|
||
} else throw new OverflowException();
|
||
}
|
||
private unsafe void Conv_u(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
var push = new UIntPtrVariant();
|
||
ulong val, maxVal = (IntPtr.Size == 4) ? UInt32.MaxValue : UInt64.MaxValue;
|
||
var tc = pop.GetTypeCode();
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if (IntPtr.Size == 4)
|
||
{
|
||
if (ovf) val = signed ?
|
||
Convert.ToUInt64(v) :
|
||
(Marshal.SizeOf(v) > 4) ? (ulong)Convert.ToInt64(v) : (uint)Convert.ToInt32(v);
|
||
else val = (uint)Convert.ToInt64(v);
|
||
}
|
||
else
|
||
{
|
||
val = (Marshal.SizeOf(v) > 4) ?
|
||
((ovf && signed) ? Convert.ToUInt64(Convert.ToInt64(v)) : (ulong)Convert.ToInt64(v)) :
|
||
((ovf && signed) ? Convert.ToUInt32(Convert.ToInt32(v)) : (uint)Convert.ToInt32(v));
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv = ((IntVariant)pop).GetValue();
|
||
if (ovf && signed && iv < 0) throw new OverflowException();
|
||
val = (uint)iv;
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
double dv = ((DoubleVariant)pop).GetValue();
|
||
if (ovf && signed && dv < 0) throw new OverflowException();
|
||
if (dv <= maxVal && (signed || dv >= 0))
|
||
val = (ulong)dv;
|
||
else
|
||
{
|
||
if (ovf) throw new OverflowException();
|
||
val = 0; // мусор, индульгируем
|
||
}
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
double dv = (double)((FloatVariant)pop).GetValue();
|
||
if (ovf && signed && dv < 0) throw new OverflowException();
|
||
if (dv <= maxVal && (signed || dv >= 0))
|
||
val = (ulong)dv;
|
||
else
|
||
{
|
||
if (ovf) throw new OverflowException();
|
||
val = 0; // мусор, индульгируем
|
||
}
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
long lv = ((LongVariant)pop).GetValue();
|
||
if (ovf && signed && lv < 0) throw new OverflowException();
|
||
val = (ulong) lv;
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(UIntPtr), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U : OpCodes.Conv_U) : OpCodes.Conv_Ovf_U_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
push.SetValue(((UIntPtr)dyn.Invoke(null, new[] { pop.GetValueAbstract() })));
|
||
PushVariant(push);
|
||
return;
|
||
}
|
||
if ((ovf == false) || (val <= maxVal))
|
||
{
|
||
push.SetValue(new UIntPtr((void*)val));
|
||
PushVariant(push);
|
||
}
|
||
else throw new OverflowException();
|
||
}
|
||
|
||
private void Conv_u8(bool ovf, bool signed)
|
||
{
|
||
var pop = PopVariant();
|
||
ulong val;
|
||
switch (pop.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var v = VariantBase.SignedVariantFromEnum((EnumVariant)pop).GetValueAbstract();
|
||
if(ovf && signed)
|
||
val = Convert.ToUInt64(v);
|
||
else
|
||
if (Marshal.SizeOf(v) > 4)
|
||
val = (ulong)Convert.ToInt64(v);
|
||
else
|
||
val = (uint)(ulong)Convert.ToInt64(v);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv = ((IntVariant)pop).GetValue();
|
||
val = ovf ? (signed ? checked((uint)iv) : (uint)iv) : (uint)iv;
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (ovf)
|
||
{
|
||
val = checked((ulong)((DoubleVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (ulong)((DoubleVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (ovf)
|
||
{
|
||
val = checked((ulong)((FloatVariant)pop).GetValue());
|
||
break;
|
||
}
|
||
val = (ulong)((FloatVariant)pop).GetValue();
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
if (ovf && signed)
|
||
val = Convert.ToUInt64(((LongVariant)pop).GetValue());
|
||
else
|
||
val = (ulong)((LongVariant)pop).GetValue();
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(ulong), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(signed ? (ovf ? OpCodes.Conv_Ovf_U8 : OpCodes.Conv_U8) : OpCodes.Conv_Ovf_U8_Un);
|
||
gen.Emit(OpCodes.Ret);
|
||
val = (ulong)dyn.Invoke(null, new[] { pop.GetValueAbstract() });
|
||
break;
|
||
}
|
||
var push = new UlongVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000204 RID: 516 RVA: 0x0000C19C File Offset: 0x0000A39C
|
||
private void Conv_u8_(VariantBase dummy) // \u0003\u2005
|
||
{
|
||
Conv_u8(false, true);
|
||
}
|
||
|
||
// Token: 0x0600020E RID: 526 RVA: 0x0000C58C File Offset: 0x0000A78C
|
||
private void Conv_ovf_u8_(VariantBase dummy) // \u0008\u2008\u2000
|
||
{
|
||
Conv_u8(true, true);
|
||
}
|
||
|
||
// Token: 0x06000208 RID: 520 RVA: 0x0000C43C File Offset: 0x0000A63C
|
||
private void Conv_ovf_i1_un_(VariantBase dummy) // \u0008
|
||
{
|
||
Conv_i1(true, false);
|
||
}
|
||
|
||
private void Conv_ovf_u1_un_(VariantBase dummy)
|
||
{
|
||
Conv_u1(true, false);
|
||
}
|
||
|
||
// Token: 0x060001BB RID: 443 RVA: 0x000094E0 File Offset: 0x000076E0
|
||
private void _u0006u2003u2001(VariantBase dummy) // \u0006\u2003\u2001
|
||
{
|
||
}
|
||
|
||
// Token: 0x060001BC RID: 444 RVA: 0x000094E4 File Offset: 0x000076E4
|
||
private VariantBase[] CreateLocalVariables() // u0002
|
||
{
|
||
var array = _methodHeader.LocalVarTypes;
|
||
var num = array.Length;
|
||
var ret = new VariantBase[num];
|
||
for (var i = 0; i < num; i++)
|
||
{
|
||
ret[i] = VariantFactory.Convert(null, GetTypeById(array[i].TypeId));
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x060001C0 RID: 448 RVA: 0x0000958C File Offset: 0x0000778C
|
||
private MethodBase FindGenericMethod(VmMethodTokenInfo what) // \u0002
|
||
{
|
||
var type = GetTypeById(what.Class.MetadataToken);
|
||
var bindingAttr = BF(what.IsStatic());
|
||
var arg_32_0 = type.GetMember(what.Name, bindingAttr);
|
||
var array = arg_32_0;
|
||
var methodInfo = (from MethodInfo methodInfo2 in array
|
||
where methodInfo2.IsGenericMethodDefinition
|
||
let parameters = methodInfo2.GetParameters()
|
||
where
|
||
parameters.Length == what.Parameters.Length &&
|
||
methodInfo2.GetGenericArguments().Length == what.GenericArguments.Length &&
|
||
AreCompatible(methodInfo2.ReturnType, what.ReturnType)
|
||
where !parameters.Where((t1, j) => !AreCompatible(t1.ParameterType, what.Parameters[j])).Any()
|
||
select methodInfo2).FirstOrDefault();
|
||
if (methodInfo == null)
|
||
{
|
||
throw new Exception(string.Format(StringDecryptor.GetString(-1550347247) /* Cannot bind method: {0}.{1} */, type.Name, what.Name));
|
||
}
|
||
var array2 = new Type[what.GenericArguments.Length];
|
||
for (var k = 0; k < array2.Length; k++)
|
||
{
|
||
array2[k] = GetTypeById(what.GenericArguments[k].MetadataToken);
|
||
}
|
||
return methodInfo.MakeGenericMethod(array2);
|
||
}
|
||
|
||
// Token: 0x060001C2 RID: 450 RVA: 0x000097A0 File Offset: 0x000079A0
|
||
private bool InvokeFilter(MethodBase mb, object obj, ref object result, object[] args) // \u0002
|
||
{
|
||
var declaringType = mb.DeclaringType;
|
||
if (declaringType == null)
|
||
{
|
||
return false;
|
||
}
|
||
if (SimpleTypeHelper.IsNullableGeneric(declaringType))
|
||
{
|
||
if (string.Equals(mb.Name, StringDecryptor.GetString(-1550345611) /* get_HasValue */, StringComparison.Ordinal))
|
||
{
|
||
result = obj != null;
|
||
}
|
||
else if (string.Equals(mb.Name, StringDecryptor.GetString(-1550345722) /* get_Value */, StringComparison.Ordinal))
|
||
{
|
||
if (obj == null)
|
||
{
|
||
//return ((bool?)null).Value;
|
||
throw new InvalidOperationException();
|
||
}
|
||
result = obj;
|
||
}
|
||
else if (mb.Name.Equals(StringDecryptor.GetString(-1550345706) /* GetValueOrDefault */, StringComparison.Ordinal))
|
||
{
|
||
if (obj == null)
|
||
{
|
||
/*u0005 =*/ Activator.CreateInstance(Nullable.GetUnderlyingType(mb.DeclaringType));
|
||
}
|
||
result = obj;
|
||
}
|
||
else
|
||
{
|
||
if (obj != null || mb.IsStatic)
|
||
{
|
||
return false;
|
||
}
|
||
result = null;
|
||
}
|
||
return true;
|
||
}
|
||
if (declaringType == SimpleTypeHelper.TypedReferenceType)
|
||
{
|
||
var name = mb.Name;
|
||
var i = args.Length;
|
||
if (i != 1)
|
||
{
|
||
if (i == 2)
|
||
{
|
||
if (name == StringDecryptor.GetString(-1550345495) /* SetTypedReference */)
|
||
{
|
||
TypedReference.SetTypedReference((TypedReference)args[0], args[1]);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (name == StringDecryptor.GetString(-1550345682) /* GetTargetType */)
|
||
{
|
||
result = TypedReference.GetTargetType((TypedReference)args[0]);
|
||
return true;
|
||
}
|
||
if (name == StringDecryptor.GetString(-1550345534) /* TargetTypeToken */)
|
||
{
|
||
result = TypedReference.TargetTypeToken((TypedReference)args[0]);
|
||
return true;
|
||
}
|
||
if (name == StringDecryptor.GetString(-1550345512) /* ToObject */)
|
||
{
|
||
result = TypedReference.ToObject((TypedReference)args[0]);
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
else if (declaringType == AssemblyType)
|
||
{
|
||
if (_callees != null && mb.Name == StringDecryptor.GetString(-1550345599) /* GetCallingAssembly */)
|
||
{
|
||
var array = _callees;
|
||
foreach (var t in array)
|
||
{
|
||
var assembly = t as Assembly;
|
||
if (assembly != null)
|
||
{
|
||
result = assembly;
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (declaringType == MethodBaseType)
|
||
{
|
||
if (mb.Name == StringDecryptor.GetString(-1550345576) /* GetCurrentMethod */)
|
||
{
|
||
if (_callees != null)
|
||
{
|
||
var array = _callees;
|
||
foreach (var t in array)
|
||
{
|
||
var methodBase = t as MethodBase;
|
||
if (methodBase != null)
|
||
{
|
||
result = methodBase;
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
result = MethodBase.GetCurrentMethod();
|
||
return true;
|
||
}
|
||
}
|
||
else if (declaringType.IsArray && declaringType.GetArrayRank() >= 2)
|
||
{
|
||
return RefToMdArrayItem(mb, obj, ref result, args);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// Token: 0x060001C3 RID: 451 RVA: 0x000099F8 File Offset: 0x00007BF8
|
||
private void Ldloca_s_(VariantBase vLocIdx) // \u0005\u2001\u2001
|
||
{
|
||
var push = new LocalsIdxHolderVariant();
|
||
push.SetValue(((ByteVariant)vLocIdx).GetValue());
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060001C4 RID: 452 RVA: 0x00009A24 File Offset: 0x00007C24
|
||
private void Ldind_i_(VariantBase dummy) // \u000E\u2004\u2000
|
||
{
|
||
Ldind(IntPtrType);
|
||
}
|
||
|
||
// Token: 0x060001C6 RID: 454 RVA: 0x00009D14 File Offset: 0x00007F14
|
||
private void Stloc_(VariantBase vidx) // \u0008\u2006
|
||
{
|
||
var idx = (UshortVariant)vidx;
|
||
PopToLocal(idx.GetValue());
|
||
}
|
||
|
||
// Token: 0x060001C7 RID: 455 RVA: 0x00009D34 File Offset: 0x00007F34
|
||
private void Stfld_(VariantBase vFieldId) // \u0005\u200B
|
||
{
|
||
var fieldInfo = ResolveField(((IntVariant)vFieldId).GetValue());
|
||
var val = PopVariant();
|
||
var objRef = PopVariant();
|
||
var obj = objRef.IsAddr() ? FetchByAddr(objRef).GetValueAbstract() : objRef.GetValueAbstract();
|
||
if (obj == null)
|
||
{
|
||
throw new NullReferenceException();
|
||
}
|
||
fieldInfo.SetValue(obj, VariantFactory.Convert(val.GetValueAbstract(), fieldInfo.FieldType).GetValueAbstract());
|
||
if (objRef.IsAddr() && /*obj != null && */ obj.GetType().IsValueType)
|
||
{
|
||
AssignByReference(objRef, VariantFactory.Convert(obj, null));
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001C8 RID: 456 RVA: 0x00009DD0 File Offset: 0x00007FD0
|
||
/*private void u000Fu2004(VariantBase dummy) // \u000F\u2004
|
||
{
|
||
}*/
|
||
|
||
// Token: 0x060001CB RID: 459 RVA: 0x00009E7C File Offset: 0x0000807C
|
||
private void Ldloc_s_(VariantBase vidx) // \u0002
|
||
{
|
||
var idx = (ByteVariant)vidx;
|
||
PushVariant(_localVariables[idx.GetValue()].Clone());
|
||
}
|
||
|
||
// Token: 0x060001D1 RID: 465 RVA: 0x0000A328 File Offset: 0x00008528
|
||
private void Stelem_ref_(VariantBase dummy) // \u0008\u200A
|
||
{
|
||
Stelem(SimpleTypeHelper.ObjectType);
|
||
}
|
||
|
||
// Token: 0x060001D3 RID: 467 RVA: 0x0000A34C File Offset: 0x0000854C
|
||
private void Ldelem_u2_(VariantBase dummy) // \u000E\u2003\u2001
|
||
{
|
||
Ldelem(typeof(ushort));
|
||
}
|
||
|
||
// Token: 0x060001D5 RID: 469 RVA: 0x0000A620 File Offset: 0x00008820
|
||
private void Stind_i4_(VariantBase dummy) // \u0006\u2003\u2000
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x060001D6 RID: 470 RVA: 0x0000A628 File Offset: 0x00008828
|
||
private void Stind_i8_(VariantBase dummy) // \u0003\u2002\u2000
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x060001DC RID: 476 RVA: 0x0000AAD8 File Offset: 0x00008CD8
|
||
private void Stelem_i8_(VariantBase dummy) // \u0002\u200B\u2000
|
||
{
|
||
var obj = PopVariant().GetValueAbstract();
|
||
var idx = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
var elementType = array.GetType().GetElementType();
|
||
checked
|
||
{
|
||
if (elementType == typeof(long))
|
||
{
|
||
((long[])array)[(int)(IntPtr)idx] = (long)VariantFactory.Convert(obj, typeof(long)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType == typeof(ulong))
|
||
{
|
||
((ulong[])array)[(int)(IntPtr)idx] = (ulong)VariantFactory.Convert(obj, typeof(ulong)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType.IsEnum)
|
||
{
|
||
Stelem(elementType, obj, idx, array);
|
||
return;
|
||
}
|
||
Stelem(typeof(long), obj, idx, array);
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001DD RID: 477 RVA: 0x0000ABA8 File Offset: 0x00008DA8
|
||
private void Stelem_i_(VariantBase dummy) // \u000F\u2006\u2000
|
||
{
|
||
Stelem(IntPtrType);
|
||
}
|
||
|
||
// Token: 0x060001DE RID: 478 RVA: 0x0000ABB8 File Offset: 0x00008DB8
|
||
private void Ldelem_i8_(VariantBase dummy) // \u0006\u2000
|
||
{
|
||
Ldelem(typeof(long));
|
||
}
|
||
|
||
// Token: 0x060001E0 RID: 480 RVA: 0x0000ABD0 File Offset: 0x00008DD0
|
||
private void Ldc_i4_(VariantBase val) // \u0006\u2000\u2000
|
||
{
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x060001E2 RID: 482 RVA: 0x0000AC08 File Offset: 0x00008E08
|
||
private void Ldarg_1_(VariantBase dummy) // \u0002\u2003\u2001
|
||
{
|
||
PushVariant(_variantOutputArgs[1].Clone());
|
||
}
|
||
|
||
// Token: 0x060001E3 RID: 483 RVA: 0x0000AC24 File Offset: 0x00008E24
|
||
private void Ret_(VariantBase dummy) // \u000E\u2005\u2000
|
||
{
|
||
Ret();
|
||
}
|
||
|
||
// Token: 0x060001E8 RID: 488 RVA: 0x0000B10C File Offset: 0x0000930C
|
||
private void Stelem(Type arrType, object val, long idx, Array array) // \u0002
|
||
{
|
||
array.SetValue(VariantFactory.Convert(val, arrType).GetValueAbstract(), idx);
|
||
}
|
||
|
||
// Token: 0x060001E9 RID: 489 RVA: 0x0000B130 File Offset: 0x00009330
|
||
[DebuggerNonUserCode]
|
||
private MethodBase FindMethodById(int methodId, UniversalTokenInfo methodToken) // \u0002
|
||
{
|
||
MethodBase result = null;
|
||
lock (AllMetadataById)
|
||
{
|
||
//var flag = true;
|
||
object obj;
|
||
if (/*flag &&*/ AllMetadataById.TryGetValue(methodId, out obj))
|
||
{
|
||
result = (MethodBase)obj;
|
||
}
|
||
else if (methodToken.IsVm == 0)
|
||
{
|
||
var methodBase = _module.ResolveMethod(methodToken.MetadataToken);
|
||
//if (flag)
|
||
{
|
||
AllMetadataById.Add(methodId, methodBase);
|
||
}
|
||
result = methodBase;
|
||
}
|
||
else
|
||
{
|
||
var mti = (VmMethodTokenInfo)methodToken.VmToken;
|
||
if (mti.IsGeneric())
|
||
{
|
||
result = FindGenericMethod(mti);
|
||
}
|
||
else
|
||
{
|
||
var clsType = GetTypeById(mti.Class.MetadataToken);
|
||
var retType = GetTypeById(mti.ReturnType.MetadataToken);
|
||
var paramArray = new Type[mti.Parameters.Length];
|
||
for (var i = 0; i < paramArray.Length; i++)
|
||
{
|
||
paramArray[i] = GetTypeById(mti.Parameters[i].MetadataToken);
|
||
}
|
||
/*if (type.IsGenericType)
|
||
{
|
||
flag = false;
|
||
}*/
|
||
if (mti.Name == StringDecryptor.GetString(-1550347259) /* .ctor */)
|
||
{
|
||
var constructor = clsType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, paramArray, null);
|
||
if (constructor == null)
|
||
{
|
||
throw new Exception();
|
||
}
|
||
if (!clsType.IsGenericType)
|
||
{
|
||
AllMetadataById.Add(methodId, constructor);
|
||
}
|
||
result = constructor;
|
||
}
|
||
else
|
||
{
|
||
var bindingAttr = BF(mti.IsStatic());
|
||
try
|
||
{
|
||
result = clsType.GetMethod(mti.Name, bindingAttr, null, CallingConventions.Any, paramArray, null);
|
||
}
|
||
catch (AmbiguousMatchException)
|
||
{
|
||
var methods = clsType.GetMethods(bindingAttr);
|
||
foreach (var methodInfo in methods)
|
||
{
|
||
if (methodInfo.Name == mti.Name && methodInfo.ReturnType == retType)
|
||
{
|
||
var parameters = methodInfo.GetParameters();
|
||
if (parameters.Length == paramArray.Length)
|
||
{
|
||
if (!(bool)paramArray.Where((t, k) => parameters[k].ParameterType != t).Any())
|
||
{
|
||
result = methodInfo;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (result == null)
|
||
{
|
||
throw new Exception(string.Format(StringDecryptor.GetString(-1550347247) /* Cannot bind method: {0}.{1} */, clsType.Name, mti.Name));
|
||
}
|
||
if (!clsType.IsGenericType)
|
||
{
|
||
AllMetadataById.Add(methodId, result);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x060001EA RID: 490 RVA: 0x0000B3B8 File Offset: 0x000095B8
|
||
private void Stloc_s_(VariantBase vidx) // \u000E\u2004
|
||
{
|
||
var idx = (ByteVariant)vidx;
|
||
PopToLocal(idx.GetValue());
|
||
}
|
||
|
||
// Token: 0x060001EB RID: 491 RVA: 0x0000B3D8 File Offset: 0x000095D8
|
||
private void LockIfInterlocked(ref BoolHolder wasLocked, MethodBase mb, bool dummy) // \u0002
|
||
{
|
||
if (mb.DeclaringType == typeof(Interlocked) && mb.IsStatic)
|
||
{
|
||
var name = mb.Name;
|
||
if (name == StringDecryptor.GetString(-1550347213) /* Add */ || name == StringDecryptor.GetString(-1550347203) /* CompareExchange */ || name == StringDecryptor.GetString(-1550347053) /* Decrement */ || name == StringDecryptor.GetString(-1550347037) /* Exchange */ || name == StringDecryptor.GetString(-1550347024) /* Increment */ || name == StringDecryptor.GetString(-1550347136) /* Read*/)
|
||
{
|
||
Monitor.Enter(InterlockedLock);
|
||
wasLocked.Val = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001EC RID: 492 RVA: 0x0000B4A0 File Offset: 0x000096A0
|
||
private void Box_(VariantBase vTypeId) // \u0003\u2009\u2000
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var push = VariantFactory.Convert(PopVariant().GetValueAbstract(), type);
|
||
push.SetVariantType(type);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060001F1 RID: 497 RVA: 0x0000B690 File Offset: 0x00009890
|
||
private void Sizeof_(VariantBase vTypeId) // \u000E\u2001\u2001
|
||
{
|
||
var t = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
var iv = new IntVariant();
|
||
iv.SetValue(Marshal.SizeOf(t));
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x060001F3 RID: 499 RVA: 0x0000B758 File Offset: 0x00009958
|
||
private void Ldelem_i_(VariantBase dummy) // \u000F\u2000
|
||
{
|
||
Ldelem(IntPtrType);
|
||
}
|
||
|
||
// Token: 0x060001F4 RID: 500 RVA: 0x0000B768 File Offset: 0x00009968
|
||
private void InternalInvoke() // \u0002
|
||
{
|
||
try
|
||
{
|
||
LoopUntilRet();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
OnException(ex, 0u);
|
||
LoopUntilRet();
|
||
}
|
||
}
|
||
|
||
// Token: 0x060001F5 RID: 501 RVA: 0x0000B7A0 File Offset: 0x000099A0
|
||
private MethodBase GenerateDynamicCall(MethodBase mb, bool mayVirtual) // \u0002
|
||
{
|
||
MethodBase result;
|
||
lock (DynamicMethods)
|
||
{
|
||
DynamicMethod dynamicMethod;
|
||
if (DynamicMethods.TryGetValue(mb, out dynamicMethod))
|
||
{
|
||
result = dynamicMethod;
|
||
}
|
||
else
|
||
{
|
||
var methodInfo = mb as MethodInfo;
|
||
var returnType = methodInfo?.ReturnType ?? VoidType;
|
||
var parameters = mb.GetParameters();
|
||
Type[] array;
|
||
if (mb.IsStatic)
|
||
{
|
||
array = new Type[parameters.Length];
|
||
for (var i = 0; i < parameters.Length; i++)
|
||
{
|
||
array[i] = parameters[i].ParameterType;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
array = new Type[parameters.Length + 1];
|
||
var type = mb.DeclaringType;
|
||
if (type.IsValueType)
|
||
{
|
||
type = type.MakeByRefType();
|
||
mayVirtual = false;
|
||
}
|
||
array[0] = type;
|
||
for (var j = 0; j < parameters.Length; j++)
|
||
{
|
||
array[j + 1] = parameters[j].ParameterType;
|
||
}
|
||
}
|
||
/*if (_alwaysFalse)
|
||
{
|
||
dynamicMethod = new DynamicMethod(string.Empty, returnType, array, true);
|
||
}
|
||
if (dynamicMethod == null)*/
|
||
{
|
||
dynamicMethod = new DynamicMethod(string.Empty, returnType, array, GetTypeById(_methodHeader.ClassId), true);
|
||
}
|
||
var iLGenerator = dynamicMethod.GetILGenerator();
|
||
for (var k = 0; k < array.Length; k++)
|
||
{
|
||
iLGenerator.Emit(OpCodes.Ldarg, k);
|
||
}
|
||
var constructorInfo = mb as ConstructorInfo;
|
||
if (constructorInfo != null)
|
||
{
|
||
iLGenerator.Emit(mayVirtual ? OpCodes.Callvirt : OpCodes.Call, constructorInfo);
|
||
}
|
||
else
|
||
{
|
||
iLGenerator.Emit(mayVirtual ? OpCodes.Callvirt : OpCodes.Call, (MethodInfo)mb);
|
||
}
|
||
iLGenerator.Emit(OpCodes.Ret);
|
||
DynamicMethods.Add(mb, dynamicMethod);
|
||
result = dynamicMethod;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// Token: 0x060001F7 RID: 503 RVA: 0x0000B9EC File Offset: 0x00009BEC
|
||
private void Ldelem_i4_(VariantBase dummy) // \u000E\u2007
|
||
{
|
||
Ldelem(typeof(int));
|
||
}
|
||
|
||
// Token: 0x060001FD RID: 509 RVA: 0x0000BD88 File Offset: 0x00009F88
|
||
private void Invoke(int pos, Type[] methodGenericArgs, Type[] classGenericArgs, bool mayVirtual) // \u0002
|
||
{
|
||
_srcVirtualizedStreamReader.BaseStream.Seek(pos, SeekOrigin.Begin);
|
||
DoNothing(_srcVirtualizedStreamReader);
|
||
var u0006 = ReadMethodHeader(_srcVirtualizedStreamReader);
|
||
var num = u0006.ArgsTypeToOutput.Length;
|
||
var array = new object[num];
|
||
var array2 = new VariantBase[num];
|
||
if (_currentClass != null & mayVirtual)
|
||
{
|
||
var num2 = u0006.IsStatic() ? 0 : 1;
|
||
var array3 = new Type[num - num2];
|
||
for (var i = num - 1; i >= num2; i--)
|
||
{
|
||
array3[i] = GetTypeById(u0006.ArgsTypeToOutput[i].TypeId);
|
||
}
|
||
var method = _currentClass.GetMethod(u0006.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty, null, array3, null);
|
||
_currentClass = null;
|
||
if (method != null)
|
||
{
|
||
GenerateDynamicCall(method, true);
|
||
return;
|
||
}
|
||
}
|
||
for (var j = num - 1; j >= 0; j--)
|
||
{
|
||
var u000F = PopVariant();
|
||
array2[j] = u000F;
|
||
if (u000F.IsAddr())
|
||
{
|
||
u000F = FetchByAddr(u000F);
|
||
}
|
||
if (u000F.GetVariantType() != null)
|
||
{
|
||
u000F = VariantFactory.Convert(null, u000F.GetVariantType()).CopyFrom(u000F);
|
||
}
|
||
var u000F2 = VariantFactory.Convert(null, GetTypeById(u0006.ArgsTypeToOutput[j].TypeId)).CopyFrom(u000F);
|
||
array[j] = u000F2.GetValueAbstract();
|
||
if (j == 0 & mayVirtual && !u0006.IsStatic() && array[j] == null)
|
||
{
|
||
throw new NullReferenceException();
|
||
}
|
||
}
|
||
var executor = new VmExecutor(_instrCodesDb);
|
||
var callees = new object[]
|
||
{
|
||
_module.Assembly
|
||
};
|
||
object obj;
|
||
try
|
||
{
|
||
obj = executor.Invoke(_srcVirtualizedStream, pos, array, methodGenericArgs, classGenericArgs, callees);
|
||
}
|
||
finally
|
||
{
|
||
for (var k = 0; k < array2.Length; k++)
|
||
{
|
||
var u000F3 = array2[k];
|
||
if (u000F3.IsAddr())
|
||
{
|
||
var obj2 = array[k];
|
||
AssignByReference(u000F3, VariantFactory.Convert(obj2, null));
|
||
}
|
||
}
|
||
}
|
||
var type = executor.GetTypeById(executor._methodHeader.ReturnTypeId);
|
||
if (type != VoidType)
|
||
{
|
||
PushVariant(VariantFactory.Convert(obj, type));
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000202 RID: 514 RVA: 0x0000C150 File Offset: 0x0000A350
|
||
public static object CreateValueTypeInstance(Type t) // \u0002
|
||
{
|
||
if (t.IsValueType)
|
||
{
|
||
return Activator.CreateInstance(t);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// Token: 0x0600020B RID: 523 RVA: 0x0000C51C File Offset: 0x0000A71C
|
||
private void Ldc_r4_(VariantBase val) // \u0003\u200B\u2000
|
||
{
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x0600020D RID: 525 RVA: 0x0000C550 File Offset: 0x0000A750
|
||
private void Stelem(Type t) // \u0003
|
||
{
|
||
var obj = PopVariant().GetValueAbstract();
|
||
var idx = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
Stelem(t, obj, idx, array);
|
||
}
|
||
|
||
// Token: 0x06000210 RID: 528 RVA: 0x0000C5C4 File Offset: 0x0000A7C4
|
||
private void Ldvirtftn_(VariantBase vMethodId) // \u0003\u200A
|
||
{
|
||
var methodBase = FindMethodById(((IntVariant)vMethodId).GetValue());
|
||
var declaringType = methodBase.DeclaringType;
|
||
var type = PopVariant().GetValueAbstract().GetType();
|
||
var parameters = methodBase.GetParameters();
|
||
var paramTypes = new Type[parameters.Length];
|
||
for (var i = 0; i < parameters.Length; i++)
|
||
{
|
||
paramTypes[i] = parameters[i].ParameterType;
|
||
}
|
||
while (type != null && type != declaringType)
|
||
{
|
||
var method = type.GetMethod(methodBase.Name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.ExactBinding, null, CallingConventions.Any, paramTypes, null);
|
||
if (method != null && method.GetBaseDefinition() == methodBase)
|
||
{
|
||
methodBase = method;
|
||
break;
|
||
}
|
||
type = type.BaseType;
|
||
}
|
||
var push = new MethodVariant();
|
||
push.SetValue(methodBase);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000213 RID: 531 RVA: 0x0000C750 File Offset: 0x0000A950
|
||
private void Ldind_u4_(VariantBase dummy) // \u000E\u2002\u2001
|
||
{
|
||
Ldind(typeof(uint));
|
||
}
|
||
|
||
// Token: 0x06000218 RID: 536 RVA: 0x0000C810 File Offset: 0x0000AA10
|
||
private void Ldind_i2_(VariantBase dummy) // \u0003\u2002\u2001
|
||
{
|
||
Ldind(typeof(short));
|
||
}
|
||
|
||
// Token: 0x0600021A RID: 538 RVA: 0x0000C830 File Offset: 0x0000AA30
|
||
private void Ldind_u2_(VariantBase dummy) // \u000F\u2001\u2001
|
||
{
|
||
Ldind(typeof(ushort));
|
||
}
|
||
|
||
// Token: 0x0600021B RID: 539 RVA: 0x0000C844 File Offset: 0x0000AA44
|
||
private void Break_(VariantBase dummy) // \u0005\u2002
|
||
{
|
||
Debugger.Break();
|
||
}
|
||
|
||
// Token: 0x0600021D RID: 541 RVA: 0x0000C878 File Offset: 0x0000AA78
|
||
private void Ldc_i4_m1_(VariantBase dummy) // \u0002\u2005
|
||
{
|
||
var iv = new IntVariant();
|
||
iv.SetValue(-1);
|
||
PushVariant(iv);
|
||
}
|
||
|
||
// Token: 0x0600021E RID: 542 RVA: 0x0000C88C File Offset: 0x0000AA8C
|
||
private void ExecuteNextInstruction() // \u0002\u2000
|
||
{
|
||
try
|
||
{
|
||
TryExecuteNextInstruction();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
OnException(ex, 0u);
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000220 RID: 544 RVA: 0x0000F07C File Offset: 0x0000D27C
|
||
private void OnException(object ex, uint pos) // \u0002
|
||
{
|
||
_wasException = ex != null;
|
||
_exception = ex;
|
||
if (_wasException)
|
||
{
|
||
_ehStack.Clear();
|
||
}
|
||
if (!_wasException)
|
||
{
|
||
_ehStack.PushBack(new ExcHandlerFrame { Pos = pos });
|
||
}
|
||
foreach (var catchBlock in _catchBlocks)
|
||
{
|
||
if (PosInRange(_myBufferPos, catchBlock.Start, catchBlock.Len))
|
||
{
|
||
switch (catchBlock.Kind)
|
||
{
|
||
case 0:
|
||
if (_wasException)
|
||
{
|
||
var type = ex.GetType();
|
||
var type2 = GetTypeById(catchBlock.ExcTypeId);
|
||
if (type == type2 || type.IsSubclassOf(type2))
|
||
{
|
||
_ehStack.PushBack(new ExcHandlerFrame
|
||
{
|
||
Pos = catchBlock.Pos,
|
||
Exception = ex
|
||
});
|
||
_wasException = false;
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
if (_wasException)
|
||
{
|
||
_ehStack.PushBack(new ExcHandlerFrame { Pos = catchBlock.Pos });
|
||
}
|
||
break;
|
||
case 2:
|
||
if (_wasException || !PosInRange((long)(ulong)pos, catchBlock.Start, catchBlock.Len))
|
||
{
|
||
_ehStack.PushBack(new ExcHandlerFrame { Pos = catchBlock.Pos });
|
||
}
|
||
break;
|
||
case 4:
|
||
if (_wasException)
|
||
{
|
||
_ehStack.PushBack(new ExcHandlerFrame
|
||
{
|
||
Pos = catchBlock.PosKind4,
|
||
Exception = ex
|
||
});
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
ExecuteExceptionHandler();
|
||
}
|
||
|
||
// Token: 0x06000221 RID: 545 RVA: 0x0000F210 File Offset: 0x0000D410
|
||
private void Stloc_0_(VariantBase dummy) // \u0008\u2003
|
||
{
|
||
PopToLocal(0);
|
||
}
|
||
|
||
// Token: 0x06000222 RID: 546 RVA: 0x0000F21C File Offset: 0x0000D41C
|
||
private void Ldind_ref_(VariantBase dummy) // \u0003\u2003\u2001
|
||
{
|
||
Ldind(SimpleTypeHelper.ObjectType);
|
||
}
|
||
|
||
// Token: 0x06000223 RID: 547 RVA: 0x0000F22C File Offset: 0x0000D42C
|
||
private void Stind_r4_(VariantBase dummy) // \u0006\u2006
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x06000224 RID: 548 RVA: 0x0000F234 File Offset: 0x0000D434
|
||
private void Newarr_(VariantBase vTypeId) // \u0002\u2001\u2001
|
||
{
|
||
var vLength = PopVariant();
|
||
var ivLength = vLength as IntVariant;
|
||
int length;
|
||
if (ivLength != null)
|
||
{
|
||
length = ivLength.GetValue();
|
||
}
|
||
else
|
||
{
|
||
var ipvLength = vLength as IntPtrVariant;
|
||
if (ipvLength != null)
|
||
{
|
||
length = ipvLength.GetValue().ToInt32();
|
||
}
|
||
else
|
||
{
|
||
var uipvLength = vLength as UIntPtrVariant;
|
||
if (uipvLength == null)
|
||
{
|
||
throw new Exception();
|
||
}
|
||
length = (int)uipvLength.GetValue().ToUInt32();
|
||
}
|
||
}
|
||
var array = Array.CreateInstance(GetTypeById(((IntVariant)vTypeId).GetValue()), length);
|
||
var push = new ArrayVariant();
|
||
push.SetValue(array);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000226 RID: 550 RVA: 0x0000F308 File Offset: 0x0000D508
|
||
private bool RefToMdArrayItem(MethodBase mb, object array, ref object result, object[] oidxs) // \u0003
|
||
{
|
||
if (!mb.IsStatic && mb.Name == StringDecryptor.GetString(-1550345964) /* Address */)
|
||
{
|
||
var methodInfo = mb as MethodInfo;
|
||
if (methodInfo != null)
|
||
{
|
||
var type = methodInfo.ReturnType;
|
||
if (type.IsByRef)
|
||
{
|
||
type = type.GetElementType();
|
||
var num = oidxs.Length;
|
||
if (num >= 1 && oidxs[0] is int)
|
||
{
|
||
var idxs = new int[num];
|
||
for (var i = 0; i < num; i++)
|
||
{
|
||
idxs[i] = (int)oidxs[i];
|
||
}
|
||
var val = new MdArrayValueVariant();
|
||
val.SetArray((Array)array);
|
||
val.SetIndexes(idxs);
|
||
val.SetHeldType(type);
|
||
result = val;
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// Token: 0x0600022C RID: 556 RVA: 0x0000F86C File Offset: 0x0000DA6C
|
||
private void Stelem_r4_(VariantBase dummy) // \u0005\u200A
|
||
{
|
||
Stelem(typeof(float));
|
||
}
|
||
|
||
// Token: 0x0600022E RID: 558 RVA: 0x0000F8AC File Offset: 0x0000DAAC
|
||
private void Ldarg_2_(VariantBase dummy) // \u0006\u2003
|
||
{
|
||
PushVariant(_variantOutputArgs[2].Clone());
|
||
}
|
||
|
||
// Token: 0x06000230 RID: 560 RVA: 0x0000F8DC File Offset: 0x0000DADC
|
||
private void Not_(VariantBase dummy) // \u0008\u2002\u2001
|
||
{
|
||
PushVariant(Not(PopVariant()));
|
||
}
|
||
|
||
// Token: 0x06000232 RID: 562 RVA: 0x0000F914 File Offset: 0x0000DB14
|
||
private void Ldind_i1_(VariantBase dummy) // \u000F\u2005\u2000
|
||
{
|
||
Ldind(typeof(sbyte));
|
||
}
|
||
|
||
// Token: 0x06000233 RID: 563 RVA: 0x0000F928 File Offset: 0x0000DB28
|
||
private void Stloc_2_(VariantBase dummy) // \u000F\u2009
|
||
{
|
||
PopToLocal(2);
|
||
}
|
||
|
||
// Token: 0x06000235 RID: 565 RVA: 0x0000F96C File Offset: 0x0000DB6C
|
||
private void Stloc_1_(VariantBase dummy) // \u000E\u2009\u2000
|
||
{
|
||
PopToLocal(1);
|
||
}
|
||
|
||
// Token: 0x06000236 RID: 566 RVA: 0x0000F978 File Offset: 0x0000DB78
|
||
private void Pop_(VariantBase dummy) // \u0003
|
||
{
|
||
PopVariant();
|
||
}
|
||
|
||
// Token: 0x0600023A RID: 570 RVA: 0x0000F9D4 File Offset: 0x0000DBD4
|
||
private void Ldc_r8_(VariantBase val) // \u0005\u200B\u2000
|
||
{
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x0600023F RID: 575 RVA: 0x0000FDF4 File Offset: 0x0000DFF4
|
||
private void Ldelem_r4_(VariantBase dummy) // \u0008\u200B
|
||
{
|
||
Ldelem(typeof(float));
|
||
}
|
||
|
||
// Token: 0x06000240 RID: 576 RVA: 0x0000FE08 File Offset: 0x0000E008
|
||
private void UnlockInterlockedIfAny(ref BoolHolder wasLocked) // \u0002
|
||
{
|
||
if (wasLocked.Val)
|
||
{
|
||
Monitor.Exit(InterlockedLock);
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000241 RID: 577 RVA: 0x0000FE1C File Offset: 0x0000E01C
|
||
private void Ldarg_0_(VariantBase dummy) // \u0003\u2007
|
||
{
|
||
PushVariant(_variantOutputArgs[0].Clone());
|
||
}
|
||
|
||
// Token: 0x06000245 RID: 581 RVA: 0x00010198 File Offset: 0x0000E398
|
||
private VariantBase Not(VariantBase val) // \u0005
|
||
{
|
||
switch (val.GetTypeCode())
|
||
{
|
||
case VariantBase.Vtc.Tc19Int:
|
||
var iv = new IntVariant();
|
||
iv.SetValue(~((IntVariant)val).GetValue());
|
||
return iv;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
var lv = new LongVariant();
|
||
lv.SetValue(~((LongVariant)val).GetValue());
|
||
return lv;
|
||
case VariantBase.Vtc.Tc5Enum:
|
||
var underlyingType = Enum.GetUnderlyingType(val.GetValueAbstract().GetType());
|
||
if (underlyingType == typeof(ulong))
|
||
{
|
||
var ret = new UlongVariant();
|
||
ret.SetValue(~Convert.ToUInt64(val.GetValueAbstract()));
|
||
return ret;
|
||
}
|
||
if (underlyingType == typeof(long))
|
||
{
|
||
var ret = new LongVariant();
|
||
ret.SetValue(~Convert.ToInt64(val.GetValueAbstract()));
|
||
return ret;
|
||
}
|
||
if (underlyingType == typeof(uint))
|
||
{
|
||
var ret = new UintVariant();
|
||
ret.SetValue(~Convert.ToUInt32(val.GetValueAbstract()));
|
||
return ret;
|
||
}
|
||
var result = new IntVariant();
|
||
result.SetValue(~Convert.ToInt32(val.GetValueAbstract()));
|
||
return result;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
if (IntPtr.Size == 4)
|
||
{
|
||
var ret = new DoubleVariant();
|
||
ret.SetValue(double.NaN);
|
||
return ret;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
if (IntPtr.Size == 4)
|
||
{
|
||
var ret = new FloatVariant();
|
||
ret.SetValue(float.NaN);
|
||
return ret;
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc18Object:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(OpCodes.Not);
|
||
gen.Emit(OpCodes.Ret);
|
||
var oret = new IntPtrVariant();
|
||
((IntPtrVariant)oret).SetValue(((IntPtr)dyn.Invoke(null, new[] { val.GetValueAbstract() })));
|
||
return oret;
|
||
}
|
||
throw new InvalidProgramException();
|
||
}
|
||
|
||
// Token: 0x06000246 RID: 582 RVA: 0x0001025C File Offset: 0x0000E45C
|
||
private void Ldind_i8_(VariantBase dummy) // \u0005\u2006
|
||
{
|
||
Ldind(typeof(long));
|
||
}
|
||
|
||
// Token: 0x06000247 RID: 583 RVA: 0x00010270 File Offset: 0x0000E470
|
||
private void Clt_(VariantBase dummy) // \u0002\u2004\u2001
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
var push = new IntVariant();
|
||
push.SetValue(UniCompare(v1, v2, ComparisonKind.LT, false) ? 1 : 0);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000249 RID: 585 RVA: 0x00010348 File Offset: 0x0000E548
|
||
private void Nop_(VariantBase dummy) // \u0005\u2005
|
||
{
|
||
}
|
||
|
||
// Token: 0x0600024B RID: 587 RVA: 0x00010498 File Offset: 0x0000E698
|
||
private void TryExecuteNextInstruction() // \u000E
|
||
{
|
||
var key = _myBufferReader.ReadInt32();
|
||
VmInstr instr;
|
||
if (!_vmInstrDb.TryGetValue(key, out instr))
|
||
{
|
||
throw new InvalidOperationException(StringDecryptor.GetString(-1550345644) /* Unsupported instruction. */);
|
||
}
|
||
instr.Func(ReadOperand(_myBufferReader, instr.Id.OperandType));
|
||
_myBufferPos = _myBufferReader.GetBuffer().GetPos();
|
||
}
|
||
|
||
// Token: 0x0600024E RID: 590 RVA: 0x000105B4 File Offset: 0x0000E7B4
|
||
private void Stelem_i1_(VariantBase dummy) // \u0002\u2003
|
||
{
|
||
var obj = PopVariant().GetValueAbstract();
|
||
var idx = PopLong();
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
var elementType = array.GetType().GetElementType();
|
||
checked
|
||
{
|
||
if (elementType == typeof(sbyte))
|
||
{
|
||
((sbyte[])array)[(int)(IntPtr)idx] = (sbyte)VariantFactory.Convert(obj, typeof(sbyte)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType == typeof(byte))
|
||
{
|
||
((byte[])array)[(int)(IntPtr)idx] = (byte)VariantFactory.Convert(obj, typeof(byte)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType == typeof(bool))
|
||
{
|
||
((bool[])array)[(int)(IntPtr)idx] = (bool)VariantFactory.Convert(obj, typeof(bool)).GetValueAbstract();
|
||
return;
|
||
}
|
||
if (elementType.IsEnum)
|
||
{
|
||
Stelem(elementType, obj, idx, array);
|
||
return;
|
||
}
|
||
Stelem(typeof(sbyte), obj, idx, array);
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600024F RID: 591 RVA: 0x000106B8 File Offset: 0x0000E8B8
|
||
private void Starg_s_(VariantBase vidx) // \u000E\u2007\u2000
|
||
{
|
||
var idx = (ByteVariant)vidx;
|
||
_variantOutputArgs[idx.GetValue()].CopyFrom(PopVariant());
|
||
}
|
||
|
||
// Token: 0x06000251 RID: 593 RVA: 0x00010748 File Offset: 0x0000E948
|
||
private void Ldlen_(VariantBase dummy) // \u000E\u200B\u2000
|
||
{
|
||
var array = (Array)PopVariant().GetValueAbstract();
|
||
var len = new IntVariant();
|
||
len.SetValue(array.Length);
|
||
PushVariant(len);
|
||
}
|
||
|
||
// Token: 0x06000256 RID: 598 RVA: 0x00010948 File Offset: 0x0000EB48
|
||
private void Ldelem_i2_(VariantBase dummy) // \u0008\u2000
|
||
{
|
||
Ldelem(typeof(short));
|
||
}
|
||
|
||
// Token: 0x06000257 RID: 599 RVA: 0x0001095C File Offset: 0x0000EB5C
|
||
private void Ldarg_(VariantBase vidx) // \u000E\u2000\u2000
|
||
{
|
||
var idx = (UshortVariant)vidx;
|
||
PushVariant(_variantOutputArgs[idx.GetValue()].Clone());
|
||
}
|
||
|
||
// Token: 0x06000258 RID: 600 RVA: 0x0001098C File Offset: 0x0000EB8C
|
||
private void Clt_un_(VariantBase dummy) // \u0003\u2000\u2001
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
var push = new IntVariant();
|
||
push.SetValue(UniCompare(v1, v2, ComparisonKind.LT, true) ? 1 : 0);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x06000259 RID: 601 RVA: 0x000109C8 File Offset: 0x0000EBC8
|
||
private void Dup_(VariantBase dummy) // \u0002\u2006\u2000
|
||
{
|
||
var v = PopVariant();
|
||
PushVariant(v);
|
||
PushVariant(v.Clone());
|
||
}
|
||
|
||
// Token: 0x0600025A RID: 602 RVA: 0x000109F4 File Offset: 0x0000EBF4
|
||
[Conditional("DEBUG")]
|
||
private void DoNothing(object dummy) // \u0002
|
||
{
|
||
}
|
||
|
||
// Token: 0x0600025B RID: 603 RVA: 0x000109F8 File Offset: 0x0000EBF8
|
||
private VariantBase[] ArgsToVariantOutputArgs(object[] args) // u0002
|
||
{
|
||
var methodHeaderArgsTypeToOutput = _methodHeader.ArgsTypeToOutput;
|
||
var num = methodHeaderArgsTypeToOutput.Length;
|
||
var retArgs = new VariantBase[num];
|
||
for (var i = 0; i < num; i++)
|
||
{
|
||
var obj = args[i];
|
||
var type = GetTypeById(methodHeaderArgsTypeToOutput[i].TypeId);
|
||
var type2 = ElementedTypeHelper.TryGoToPointerOrReferenceElementType(type);
|
||
Type type3;
|
||
if (type2 == SimpleTypeHelper.ObjectType || SimpleTypeHelper.IsNullableGeneric(type2))
|
||
{
|
||
type3 = type;
|
||
}
|
||
else
|
||
{
|
||
type3 = obj?.GetType() ?? type;
|
||
}
|
||
if (obj != null && !type.IsAssignableFrom(type3) && type.IsByRef && !type.GetElementType().IsAssignableFrom(type3))
|
||
{
|
||
throw new ArgumentException(string.Format(StringDecryptor.GetString(-1550345390) /* Object of type {0} cannot be converted to type {1}. */, type3, type));
|
||
}
|
||
retArgs[i] = VariantFactory.Convert(obj, type3);
|
||
}
|
||
if (!_methodHeader.IsStatic() && GetTypeById(_methodHeader.ClassId).IsValueType)
|
||
{
|
||
var expr_EB = new VariantBaseHolder();
|
||
expr_EB.SetValue(retArgs[0]);
|
||
retArgs[0] = expr_EB;
|
||
}
|
||
for (var j = 0; j < num; j++)
|
||
{
|
||
if (methodHeaderArgsTypeToOutput[j].IsOutput)
|
||
{
|
||
var expr_116 = new VariantBaseHolder();
|
||
expr_116.SetValue(retArgs[j]);
|
||
retArgs[j] = expr_116;
|
||
}
|
||
}
|
||
return retArgs;
|
||
}
|
||
|
||
// Token: 0x0600025D RID: 605 RVA: 0x00010B3C File Offset: 0x0000ED3C
|
||
private void Stind() // \u0003
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
AssignByReference(v1, v2);
|
||
}
|
||
|
||
// Token: 0x0600025E RID: 606 RVA: 0x00010B60 File Offset: 0x0000ED60
|
||
private void Endfinally_(VariantBase dummy) // \u0005\u2000\u2001
|
||
{
|
||
ExecuteExceptionHandler();
|
||
}
|
||
|
||
// Token: 0x0600025F RID: 607 RVA: 0x00010B68 File Offset: 0x0000ED68
|
||
private bool PosInRange(long pos, uint start, uint len) // \u0002
|
||
{
|
||
return pos >= (long)(ulong)start && pos <= (long)(ulong)(start + len);
|
||
}
|
||
|
||
// Token: 0x06000260 RID: 608 RVA: 0x00010B7C File Offset: 0x0000ED7C
|
||
private bool IsCompatible(MethodBase mb) // \u0002
|
||
{
|
||
return mb.IsVirtual && GetTypeById(_methodHeader.ClassId).IsSubclassOf(mb.DeclaringType);
|
||
}
|
||
|
||
// Token: 0x06000263 RID: 611 RVA: 0x00010C00 File Offset: 0x0000EE00
|
||
private void Stelem_(VariantBase vTypeId) // \u0006\u2004\u2000
|
||
{
|
||
Stelem(GetTypeById(((IntVariant)vTypeId).GetValue()));
|
||
}
|
||
|
||
// Token: 0x06000265 RID: 613 RVA: 0x00010C40 File Offset: 0x0000EE40
|
||
private void Ldelem_u1_(VariantBase dummy) // \u0006\u2004
|
||
{
|
||
Ldelem(typeof(byte));
|
||
}
|
||
|
||
// Token: 0x06000267 RID: 615 RVA: 0x00010C80 File Offset: 0x0000EE80
|
||
private void Cgt_(VariantBase dummy) // \u0005\u2001\u2000
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
var push = new IntVariant();
|
||
push.SetValue(UniCompare(v1, v2, ComparisonKind.GT, false) ? 1 : 0);
|
||
PushVariant(push);
|
||
}
|
||
|
||
private VariantBase And(VariantBase org_v1, VariantBase org_v2)
|
||
{
|
||
VariantBase v1, v2;
|
||
var tc = CommonType(org_v1, org_v2, out v1, out v2, true);
|
||
VariantBase ret;
|
||
switch (tc)
|
||
{
|
||
case VariantBase.Vtc.Tc9Uint:
|
||
uint uv1 = ((UintVariant)v1).GetValue(), uv2 = ((UintVariant)v2).GetValue();
|
||
var uvret = new UintVariant();
|
||
ret = uvret;
|
||
uvret.SetValue(uv1 & uv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc19Int:
|
||
int iv1 = ((IntVariant)v1).GetValue(), iv2 = ((IntVariant)v2).GetValue();
|
||
var ivret = new IntVariant();
|
||
ret = ivret;
|
||
ivret.SetValue(iv1 & iv2);
|
||
break;
|
||
case VariantBase.Vtc.Tc21Double:
|
||
{
|
||
/*double dv1 = ((DoubleVariant)v1).GetValue(), dv2 = ((DoubleVariant)v2).GetValue(); // естественный алгоритм
|
||
long lv1 = (dv1 < 0) ? (long)dv1 : (long)(ulong)dv1;
|
||
long lv2 = (dv2 < 0) ? (long)dv2 : (long)(ulong)dv2;
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
var l64 = (ulong) lv1 & (ulong) lv2;
|
||
if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
|
||
dvret.SetValue(l64);*/
|
||
var dvret = new DoubleVariant();
|
||
ret = dvret;
|
||
dvret.SetValue((4 == IntPtr.Size) ? Double.NaN : (double)0); // иногда у фреймворка бывает мусор, но чаще эти значения...
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc8Float:
|
||
{
|
||
/*float fv1 = ((FloatVariant) v1).GetValue(), fv2 = ((FloatVariant) v2).GetValue(); // естественный алгоритм
|
||
long lv1 = (fv1 < 0) ? (long)fv1 : (long)(ulong)fv1;
|
||
long lv2 = (fv2 < 0) ? (long)fv2 : (long)(ulong)fv2;
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
var l64 = (ulong)lv1 & (ulong)lv2;
|
||
if (l64 >> 32 == UInt32.MaxValue) l64 &= UInt32.MaxValue;
|
||
fvret.SetValue(l64);*/
|
||
var fvret = new FloatVariant();
|
||
ret = fvret;
|
||
fvret.SetValue((4 == IntPtr.Size) ? float.NaN : (float)0.0); // иногда у фреймворка бывает мусор, но чаще эти значения...
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc24Long:
|
||
{
|
||
long lv1 = ((LongVariant)v1).GetValue(), lv2 = ((LongVariant)v2).GetValue();
|
||
var lvret = new LongVariant();
|
||
ret = lvret;
|
||
lvret.SetValue(lv1 & lv2);
|
||
}
|
||
break;
|
||
case VariantBase.Vtc.Tc7Ulong:
|
||
ulong ulv1 = ((UlongVariant)v1).GetValue(), ulv2 = ((UlongVariant)v2).GetValue();
|
||
var ulvret = new UlongVariant();
|
||
ret = ulvret;
|
||
ulvret.SetValue(ulv1 & ulv2);
|
||
break;
|
||
default:
|
||
// это нужно будет заменить на соотв. msil-код
|
||
var dyn = new DynamicMethod(String.Empty, typeof(IntPtr), new[] { typeof(object), typeof(object) }, typeof(void), true);
|
||
var gen = dyn.GetILGenerator();
|
||
gen.Emit(OpCodes.Ldarg_1);
|
||
gen.Emit(OpCodes.Ldarg_0);
|
||
gen.Emit(OpCodes.And);
|
||
gen.Emit(OpCodes.Ret);
|
||
ret = new IntPtrVariant();
|
||
((IntPtrVariant)ret).SetValue(((IntPtr)dyn.Invoke(null, new[] { org_v1.GetValueAbstract(), org_v2.GetValueAbstract() })));
|
||
break;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Token: 0x0600026E RID: 622 RVA: 0x000110D8 File Offset: 0x0000F2D8
|
||
private void Ldind(Type t) // \u0005
|
||
{
|
||
PushVariant(VariantFactory.Convert(FetchByAddr(PopVariant()).GetValueAbstract(), t));
|
||
}
|
||
|
||
// Token: 0x0600026F RID: 623 RVA: 0x00011104 File Offset: 0x0000F304
|
||
private void Starg_(VariantBase vidx) // \u000F\u2008\u2000
|
||
{
|
||
var idx = (UshortVariant)vidx;
|
||
_variantOutputArgs[idx.GetValue()].CopyFrom(PopVariant());
|
||
}
|
||
|
||
// Token: 0x06000270 RID: 624 RVA: 0x00011138 File Offset: 0x0000F338
|
||
private void Ret() // \u0008
|
||
{
|
||
_retFound = true;
|
||
}
|
||
|
||
// Token: 0x06000273 RID: 627 RVA: 0x00011480 File Offset: 0x0000F680
|
||
private void Stind_r8_(VariantBase dummy) // \u0005\u2004\u2000
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x06000275 RID: 629 RVA: 0x00011510 File Offset: 0x0000F710
|
||
private void Rethrow_(VariantBase dummy) // \u0003\u200A\u2000
|
||
{
|
||
if (_exception == null)
|
||
{
|
||
throw new InvalidOperationException();
|
||
}
|
||
_myBufferPos = _myBufferReader.GetBuffer().GetPos();
|
||
ThrowStoreCrossDomain(_exception);
|
||
}
|
||
|
||
// Token: 0x06000278 RID: 632 RVA: 0x00011838 File Offset: 0x0000FA38
|
||
private void Ldelem_u4_(VariantBase dummy) // \u0003\u2003
|
||
{
|
||
Ldelem(typeof(uint));
|
||
}
|
||
|
||
// Token: 0x0600027A RID: 634 RVA: 0x00011994 File Offset: 0x0000FB94
|
||
private void Invoke(VmMethodRefTokenInfo mref) // \u0002
|
||
{
|
||
//var arg_18_0 = (U0008U2007)U0003U2008.Get_u0005();
|
||
var methodBase = FindMethodById(mref.Pos, ReadToken(mref.Pos));
|
||
//methodBase.GetParameters();
|
||
var pos = mref.Flags;
|
||
var mayVirtual = (pos & 1073741824) != 0;
|
||
pos &= -1073741825;
|
||
var methodGenericArgs = _methodGenericArgs;
|
||
var classGenericArgs = _classGenericArgs;
|
||
try
|
||
{
|
||
_methodGenericArgs = methodBase is ConstructorInfo ? Type.EmptyTypes : methodBase.GetGenericArguments();
|
||
_classGenericArgs = methodBase.DeclaringType.GetGenericArguments();
|
||
Invoke(pos, _methodGenericArgs, _classGenericArgs, mayVirtual);
|
||
}
|
||
finally
|
||
{
|
||
_methodGenericArgs = methodGenericArgs;
|
||
_classGenericArgs = classGenericArgs;
|
||
}
|
||
}
|
||
|
||
// Token: 0x0600027B RID: 635 RVA: 0x00011A5C File Offset: 0x0000FC5C
|
||
private void Ldc_i8_(VariantBase val) // \u0006\u2007\u2000
|
||
{
|
||
PushVariant(val);
|
||
}
|
||
|
||
// Token: 0x0600027E RID: 638 RVA: 0x00011CB8 File Offset: 0x0000FEB8
|
||
private void Ldelem_r8_(VariantBase dummy) // \u000E\u2002\u2000
|
||
{
|
||
Ldelem(typeof(double));
|
||
}
|
||
|
||
// Token: 0x06000280 RID: 640 RVA: 0x00011DB4 File Offset: 0x0000FFB4
|
||
private void Stloc_3_(VariantBase dummy) // \u0003\u2004\u2000
|
||
{
|
||
PopToLocal(3);
|
||
}
|
||
|
||
// Token: 0x06000281 RID: 641 RVA: 0x00011DC0 File Offset: 0x0000FFC0
|
||
private void Ckfinite_(VariantBase dummy) // \u000F\u2003
|
||
{
|
||
var v = PopVariant();
|
||
if (v.GetTypeCode() == VariantBase.Vtc.Tc5Enum)
|
||
{
|
||
v = VariantBase.SignedVariantFromEnum((EnumVariant)v);
|
||
}
|
||
double val = double.NaN;
|
||
bool con = v.GetValueAbstract() is IConvertible;
|
||
if (con)
|
||
{
|
||
val = Convert.ToDouble(v.GetValueAbstract());
|
||
if (double.IsNaN(val) || double.IsInfinity(val))
|
||
{
|
||
throw new OverflowException(StringDecryptor.GetString(-1550347095) /* The value is not finite real number. */);
|
||
}
|
||
}
|
||
if (IsFloating(v))
|
||
{
|
||
PushVariant(v);
|
||
} else
|
||
{
|
||
var push = new DoubleVariant();
|
||
push.SetValue(val);
|
||
PushVariant(push);
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000288 RID: 648 RVA: 0x00012170 File Offset: 0x00010370
|
||
private void Stind_ref_(VariantBase dummy) // \u0002\u2008
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x06000289 RID: 649 RVA: 0x00012178 File Offset: 0x00010378
|
||
private void PopToLocal(int idx) // \u0002
|
||
{
|
||
var pop = PopVariant();
|
||
if (pop is ReferenceVariantBase)
|
||
{
|
||
_localVariables[idx] = pop;
|
||
return;
|
||
}
|
||
_localVariables[idx].CopyFrom(pop);
|
||
}
|
||
|
||
// Token: 0x0600028B RID: 651 RVA: 0x00012260 File Offset: 0x00010460
|
||
private void Ldobj_(VariantBase vTypeId) // \u000E\u2008
|
||
{
|
||
var type = GetTypeById(((IntVariant)vTypeId).GetValue());
|
||
Ldind(type);
|
||
}
|
||
|
||
// Token: 0x0600028C RID: 652 RVA: 0x00012288 File Offset: 0x00010488
|
||
private void Ldloc_1_(VariantBase dummy) // \u0003\u2008\u2000
|
||
{
|
||
PushVariant(_localVariables[1].Clone());
|
||
}
|
||
|
||
// Token: 0x0600028E RID: 654 RVA: 0x00012348 File Offset: 0x00010548
|
||
private void Ldelem_i1_(VariantBase dummy) // \u0005\u2009\u2000
|
||
{
|
||
Ldelem(typeof(sbyte));
|
||
}
|
||
|
||
// Token: 0x06000290 RID: 656 RVA: 0x00012370 File Offset: 0x00010570
|
||
private void JumpToPos(uint val) // \u0002
|
||
{
|
||
_storedPos = val;
|
||
}
|
||
|
||
// Token: 0x06000291 RID: 657 RVA: 0x00012380 File Offset: 0x00010580
|
||
public void VoidInvoke(Stream virtualizedStream, string pos, object[] args) // \u0002
|
||
{
|
||
Invoke(virtualizedStream, pos, args);
|
||
}
|
||
|
||
// Token: 0x06000295 RID: 661 RVA: 0x00012420 File Offset: 0x00010620
|
||
private void _u0002u2002u2001(VariantBase dummy) // \u0002\u2002\u2001
|
||
{
|
||
}
|
||
|
||
// Token: 0x06000298 RID: 664 RVA: 0x00012590 File Offset: 0x00010790
|
||
private void LoopUntilRet() // \u0005\u2000
|
||
{
|
||
var usedSize = _myBufferReader.GetBuffer().UsedSize();
|
||
while (!_retFound)
|
||
{
|
||
if (_storedPos.HasValue)
|
||
{
|
||
_myBufferReader.GetBuffer().SetPos((long)(ulong)_storedPos.Value);
|
||
_storedPos = null;
|
||
}
|
||
ExecuteNextInstruction();
|
||
if (_myBufferReader.GetBuffer().GetPos() >= usedSize && !_storedPos.HasValue)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Token: 0x06000299 RID: 665 RVA: 0x00012614 File Offset: 0x00010814
|
||
private VmInstrInfo GetInstrById(int id) // \u0002
|
||
{
|
||
return _instrCodesDb.MyFieldsEnumerator().FirstOrDefault(current => current.Id == id);
|
||
}
|
||
|
||
// Token: 0x0600029A RID: 666 RVA: 0x00012670 File Offset: 0x00010870
|
||
private void Ldloc_(VariantBase val) // \u000F\u200A\u2000
|
||
{
|
||
PushVariant(_localVariables[((UshortVariant)val).GetValue()].Clone());
|
||
}
|
||
|
||
// Token: 0x0600029E RID: 670 RVA: 0x00012718 File Offset: 0x00010918
|
||
private bool Isinst(VariantBase obj, Type t) // \u0002
|
||
{
|
||
if (obj.GetValueAbstract() == null)
|
||
{
|
||
return true;
|
||
}
|
||
var type = obj.GetVariantType() ?? obj.GetValueAbstract().GetType();
|
||
if (type == t || t.IsAssignableFrom(type))
|
||
{
|
||
return true;
|
||
}
|
||
if (!type.IsValueType && !t.IsValueType && Marshal.IsComObject(obj.GetValueAbstract()))
|
||
{
|
||
IntPtr intPtr;
|
||
try
|
||
{
|
||
intPtr = Marshal.GetComInterfaceForObject(obj.GetValueAbstract(), t);
|
||
}
|
||
catch (InvalidCastException)
|
||
{
|
||
intPtr = IntPtr.Zero;
|
||
}
|
||
if (intPtr != IntPtr.Zero)
|
||
{
|
||
try
|
||
{
|
||
Marshal.Release(intPtr);
|
||
}
|
||
catch
|
||
{
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// Token: 0x0600029F RID: 671 RVA: 0x000127C4 File Offset: 0x000109C4
|
||
private void Ldind_r8_(VariantBase dummy) // \u000E\u2008\u2000
|
||
{
|
||
Ldind(typeof(double));
|
||
}
|
||
|
||
// Token: 0x060002A1 RID: 673 RVA: 0x00012870 File Offset: 0x00010A70
|
||
private void Stobj_(VariantBase dummy) // \u0005\u2009
|
||
{
|
||
Stind();
|
||
}
|
||
|
||
// Token: 0x060002A4 RID: 676 RVA: 0x00012A44 File Offset: 0x00010C44
|
||
private void Cgt_un_(VariantBase dummy) // \u0006\u2002
|
||
{
|
||
var v2 = PopVariant();
|
||
var v1 = PopVariant();
|
||
var push = new IntVariant();
|
||
push.SetValue(UniCompare(v1, v2, ComparisonKind.GT, true) ? 1 : 0);
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060002A7 RID: 679 RVA: 0x00012CDC File Offset: 0x00010EDC
|
||
private bool AreCompatible(Type t1, UniversalTokenInfo ut2) // \u0002
|
||
{
|
||
var t2 = (VmClassTokenInfo)ut2.VmToken;
|
||
if (ElementedTypeHelper.TryGoToElementType(t1).IsGenericParameter)
|
||
{
|
||
return t2 == null || t2.IsOuterClassGeneric;
|
||
}
|
||
return TypeCompatibility.Check(t1, GetTypeById(ut2.MetadataToken));
|
||
}
|
||
|
||
// Token: 0x060002A9 RID: 681 RVA: 0x00012D38 File Offset: 0x00010F38
|
||
private void Ldloca_(VariantBase vLocIdx) // \u0006\u2005
|
||
{
|
||
var push = new LocalsIdxHolderVariant();
|
||
push.SetValue(((UshortVariant)vLocIdx).GetValue());
|
||
PushVariant(push);
|
||
}
|
||
|
||
// Token: 0x060002AA RID: 682 RVA: 0x00012D64 File Offset: 0x00010F64
|
||
private void Ldarg_3_(VariantBase dummy) // \u000E\u2009
|
||
{
|
||
PushVariant(_variantOutputArgs[3].Clone());
|
||
}
|
||
|
||
// Token: 0x060002AC RID: 684 RVA: 0x00012DB8 File Offset: 0x00010FB8
|
||
/*[Conditional("DEBUG")]
|
||
public static void DoNothing(string dummy) // \u0002
|
||
{
|
||
}*/
|
||
|
||
// Token: 0x0600021F RID: 543 RVA: 0x0000C8BC File Offset: 0x0000AABC
|
||
private Dictionary<int, VmInstr> CreateVmInstrDb() // \u0002
|
||
{
|
||
return new Dictionary<int, VmInstr>(256)
|
||
{
|
||
{
|
||
_instrCodesDb.Conv_ovf_i4_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i4_un_, Conv_ovf_i4_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Shr_un_.Id,
|
||
new VmInstr(_instrCodesDb.Shr_un_, Shr_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_i_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_i_, Conv_i_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i_un_, Conv_ovf_i_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_i_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_i_, Stelem_i_)
|
||
},
|
||
{
|
||
_instrCodesDb.Starg_s_.Id,
|
||
new VmInstr(_instrCodesDb.Starg_s_, Starg_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Sizeof_.Id,
|
||
new VmInstr(_instrCodesDb.Sizeof_, Sizeof_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarg_s_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarg_s_, Ldarg_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_i4_, Stelem_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Calli_.Id,
|
||
new VmInstr(_instrCodesDb.Calli_, Calli_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_7_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_7_, Ldc_i4_7_)
|
||
},
|
||
{
|
||
_instrCodesDb.Newobj_.Id,
|
||
new VmInstr(_instrCodesDb.Newobj_, Newobj_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_u4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_u4_, Ldind_u4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Cgt_un_.Id,
|
||
new VmInstr(_instrCodesDb.Cgt_un_, Cgt_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_u1_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_u1_, Conv_u1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_ref_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_ref_, Ldelem_ref_)
|
||
},
|
||
{
|
||
_instrCodesDb.U0006U2008U2000.Id,
|
||
new VmInstr(_instrCodesDb.U0006U2008U2000, _u0002u2002u2001)
|
||
},
|
||
{
|
||
_instrCodesDb.Newarr_.Id,
|
||
new VmInstr(_instrCodesDb.Newarr_, Newarr_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarga_s_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarga_s_, Ldarga_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Bgt_.Id,
|
||
new VmInstr(_instrCodesDb.Bgt_, Bgt_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldflda_.Id,
|
||
new VmInstr(_instrCodesDb.Ldflda_, Ldflda_)
|
||
},
|
||
{
|
||
_instrCodesDb.Sub_.Id,
|
||
new VmInstr(_instrCodesDb.Sub_, Sub_)
|
||
},
|
||
{
|
||
_instrCodesDb.Endfilter_.Id,
|
||
new VmInstr(_instrCodesDb.Endfilter_, Endfilter_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u_un_, Conv_ovf_u_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_1_, Ldc_i4_1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i_, Conv_ovf_i_)
|
||
},
|
||
{
|
||
_instrCodesDb.Add_ovf_.Id,
|
||
new VmInstr(_instrCodesDb.Add_ovf_, Add_ovf_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldftn_.Id,
|
||
new VmInstr(_instrCodesDb.Ldftn_, Ldftn_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stfld_.Id,
|
||
new VmInstr(_instrCodesDb.Stfld_, Stfld_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_5_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_5_, Ldc_i4_5_)
|
||
},
|
||
{
|
||
_instrCodesDb.Xor_.Id,
|
||
new VmInstr(_instrCodesDb.Xor_, Xor_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_u2_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_u2_, Conv_u2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Div_un_.Id,
|
||
new VmInstr(_instrCodesDb.Div_un_, Div_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stloc_3_.Id,
|
||
new VmInstr(_instrCodesDb.Stloc_3_, Stloc_3_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ret_.Id,
|
||
new VmInstr(_instrCodesDb.Ret_, Ret_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_m1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_m1_, Ldc_i4_m1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarg_1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarg_1_, Ldarg_1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Div_.Id,
|
||
new VmInstr(_instrCodesDb.Div_, Div_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldnull_.Id,
|
||
new VmInstr(_instrCodesDb.Ldnull_, Ldnull_)
|
||
},
|
||
{
|
||
_instrCodesDb.Break_.Id,
|
||
new VmInstr(_instrCodesDb.Break_, Break_)
|
||
},
|
||
{
|
||
_instrCodesDb.Cgt_.Id,
|
||
new VmInstr(_instrCodesDb.Cgt_, Cgt_)
|
||
},
|
||
{
|
||
_instrCodesDb.Arglist_.Id,
|
||
new VmInstr(_instrCodesDb.Arglist_, Arglist_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloc_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloc_, Ldloc_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_u_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_u_, Conv_u_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_i_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_i_, Ldelem_i_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i1_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i1_un_, Conv_ovf_i1_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Cpblk_.Id,
|
||
new VmInstr(_instrCodesDb.Cpblk_, Cpblk_)
|
||
},
|
||
{
|
||
_instrCodesDb.Add_.Id,
|
||
new VmInstr(_instrCodesDb.Add_, Add_)
|
||
},
|
||
{
|
||
_instrCodesDb.Initblk_.Id,
|
||
new VmInstr(_instrCodesDb.Initblk_, Initblk_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_i_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_i_, Ldind_i_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_u4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_u4_, Ldelem_u4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_ref_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_ref_, Stind_ref_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_i1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_i1_, Ldelem_i1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloc_3_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloc_3_, Ldloc_3_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_i8_, Stind_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_i1_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_i1_, Conv_i1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_, Ldelem_)
|
||
},
|
||
{
|
||
_instrCodesDb.Clt_un_.Id,
|
||
new VmInstr(_instrCodesDb.Clt_un_, Clt_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_i4_, Ldelem_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Mkrefany_.Id,
|
||
new VmInstr(_instrCodesDb.Mkrefany_, Mkrefany_)
|
||
},
|
||
{
|
||
_instrCodesDb.Neg_.Id,
|
||
new VmInstr(_instrCodesDb.Neg_, Neg_)
|
||
},
|
||
{
|
||
_instrCodesDb.Leave_.Id,
|
||
new VmInstr(_instrCodesDb.Leave_, Leave_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_2_, Ldc_i4_2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i2_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i2_, Conv_ovf_i2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloc_2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloc_2_, Ldloc_2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Bgt_un_.Id,
|
||
new VmInstr(_instrCodesDb.Bgt_un_, Bgt_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stsfld_.Id,
|
||
new VmInstr(_instrCodesDb.Stsfld_, Stsfld_)
|
||
},
|
||
/*{
|
||
_instrCodesDb.Nop_.Id,
|
||
new VmInstr(_instrCodesDb.Nop_, u000Fu2004)
|
||
},*/
|
||
{
|
||
_instrCodesDb.Shr_.Id,
|
||
new VmInstr(_instrCodesDb.Shr_, Shr_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_ref_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_ref_, Ldind_ref_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldfld_.Id,
|
||
new VmInstr(_instrCodesDb.Ldfld_, Ldfld_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldlen_.Id,
|
||
new VmInstr(_instrCodesDb.Ldlen_, Ldlen_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_ref_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_ref_, Stelem_ref_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ceq_.Id,
|
||
new VmInstr(_instrCodesDb.Ceq_, Ceq_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u2_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u2_, Conv_ovf_u2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Add_ovf_un_.Id,
|
||
new VmInstr(_instrCodesDb.Add_ovf_un_, Add_ovf_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i8_, Conv_ovf_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_i2_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_i2_, Stind_i2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_i1_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_i1_, Stelem_i1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloca_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloca_, Ldloca_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_r4_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_r4_, Stind_r4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stloc_s_.Id,
|
||
new VmInstr(_instrCodesDb.Stloc_s_, Stloc_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Refanyval_.Id,
|
||
new VmInstr(_instrCodesDb.Refanyval_, Refanyval_)
|
||
},
|
||
{
|
||
_instrCodesDb.Clt_.Id,
|
||
new VmInstr(_instrCodesDb.Clt_, Clt_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_r4_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_r4_, Stelem_r4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_r8_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_r8_, Stelem_r8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_u4_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_u4_, Conv_u4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i8_, Ldc_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_r4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_r4_, Ldind_r4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_r_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_r_un_, Conv_r_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldtoken_.Id,
|
||
new VmInstr(_instrCodesDb.Ldtoken_, Ldtoken_)
|
||
},
|
||
{
|
||
_instrCodesDb.Blt_un_.Id,
|
||
new VmInstr(_instrCodesDb.Blt_un_, Blt_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Brtrue_.Id,
|
||
new VmInstr(_instrCodesDb.Brtrue_, Brtrue_)
|
||
},
|
||
{
|
||
_instrCodesDb.Switch_.Id,
|
||
new VmInstr(_instrCodesDb.Switch_, Switch_)
|
||
},
|
||
{
|
||
_instrCodesDb.Refanytype_.Id,
|
||
new VmInstr(_instrCodesDb.Refanytype_, Refanytype_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stobj_.Id,
|
||
new VmInstr(_instrCodesDb.Stobj_, Stobj_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ble_un_.Id,
|
||
new VmInstr(_instrCodesDb.Ble_un_, Ble_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i8_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i8_un_, Conv_ovf_i8_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u4_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u4_un_, Conv_ovf_u4_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_i8_, Ldind_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.U000EU2006U2000.Id,
|
||
new VmInstr(_instrCodesDb.U000EU2006U2000, Invoke)
|
||
},
|
||
{
|
||
_instrCodesDb.Endfinally_.Id,
|
||
new VmInstr(_instrCodesDb.Endfinally_, Endfinally_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u8_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u8_un_, Conv_ovf_u8_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_i2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_i2_, Ldelem_i2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_, Ldc_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.U000FU2001.Id,
|
||
new VmInstr(_instrCodesDb.U000FU2001, _u0006u2003u2001)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_i4_, Conv_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_u1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_u1_, Ldind_u1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Rethrow_.Id,
|
||
new VmInstr(_instrCodesDb.Rethrow_, Rethrow_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i1_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i1_, Conv_ovf_i1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Box_.Id,
|
||
new VmInstr(_instrCodesDb.Box_, Box_)
|
||
},
|
||
{
|
||
_instrCodesDb.Localloc_.Id,
|
||
new VmInstr(_instrCodesDb.Localloc_, Localloc_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_r8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_r8_, Ldelem_r8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Throw_.Id,
|
||
new VmInstr(_instrCodesDb.Throw_, Throw_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldvirtftn_.Id,
|
||
new VmInstr(_instrCodesDb.Ldvirtftn_, Ldvirtftn_)
|
||
},
|
||
{
|
||
_instrCodesDb.Mul_ovf_un_.Id,
|
||
new VmInstr(_instrCodesDb.Mul_ovf_un_, Mul_ovf_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i4_, Conv_ovf_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloc_0_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloc_0_, Ldloc_0_)
|
||
},
|
||
{
|
||
_instrCodesDb.Starg_.Id,
|
||
new VmInstr(_instrCodesDb.Starg_, Starg_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_i1_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_i1_, Stind_i1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_i2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_i2_, Ldind_i2_)
|
||
},
|
||
{
|
||
_instrCodesDb.And_.Id,
|
||
new VmInstr(_instrCodesDb.And_, And_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_6_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_6_, Ldc_i4_6_)
|
||
},
|
||
{
|
||
_instrCodesDb.Nop_.Id,
|
||
new VmInstr(_instrCodesDb.Nop_, Nop_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_i4_, Ldind_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Dup_.Id,
|
||
new VmInstr(_instrCodesDb.Dup_, Dup_)
|
||
},
|
||
{
|
||
_instrCodesDb.Mul_.Id,
|
||
new VmInstr(_instrCodesDb.Mul_, Mul_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stloc_2_.Id,
|
||
new VmInstr(_instrCodesDb.Stloc_2_, Stloc_2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Or_.Id,
|
||
new VmInstr(_instrCodesDb.Or_, Or_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_u8_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_u8_, Conv_u8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u1_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u1_, Conv_ovf_u1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Sub_ovf_.Id,
|
||
new VmInstr(_instrCodesDb.Sub_ovf_, Sub_ovf_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u1_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u1_un_, Conv_ovf_u1_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_r4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_r4_, Ldelem_r4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_r8_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_r8_, Conv_r8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stloc_0_.Id,
|
||
new VmInstr(_instrCodesDb.Stloc_0_, Stloc_0_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u8_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u8_, Conv_ovf_u8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Brfalse_.Id,
|
||
new VmInstr(_instrCodesDb.Brfalse_, Brfalse_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarg_3_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarg_3_, Ldarg_3_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarg_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarg_, Ldarg_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_r4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_r4_, Ldc_r4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Initobj_.Id,
|
||
new VmInstr(_instrCodesDb.Initobj_, Initobj_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stloc_.Id,
|
||
new VmInstr(_instrCodesDb.Stloc_, Stloc_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_i4_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_i4_, Stind_i4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Callvirt_.Id,
|
||
new VmInstr(_instrCodesDb.Callvirt_, Callvirt_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_i2_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_i2_, Stelem_i2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u_, Conv_ovf_u_)
|
||
},
|
||
{
|
||
_instrCodesDb.Cpobj_.Id,
|
||
new VmInstr(_instrCodesDb.Cpobj_, Cpobj_)
|
||
},
|
||
{
|
||
_instrCodesDb.Rem_.Id,
|
||
new VmInstr(_instrCodesDb.Rem_, Rem_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_r8_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_r8_, Stind_r8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stloc_1_.Id,
|
||
new VmInstr(_instrCodesDb.Stloc_1_, Stloc_1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u4_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u4_, Conv_ovf_u4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_0_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_0_, Ldc_i4_0_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stind_i_.Id,
|
||
new VmInstr(_instrCodesDb.Stind_i_, Stind_i_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_i8_, Stelem_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelema_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelema_, Ldelema_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldsflda_.Id,
|
||
new VmInstr(_instrCodesDb.Ldsflda_, Ldsflda_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldsfld_.Id,
|
||
new VmInstr(_instrCodesDb.Ldsfld_, Ldsfld_)
|
||
},
|
||
{
|
||
_instrCodesDb.Isinst_.Id,
|
||
new VmInstr(_instrCodesDb.Isinst_, Isinst_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_i2_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_i2_, Conv_i2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Stelem_.Id,
|
||
new VmInstr(_instrCodesDb.Stelem_, Stelem_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_r8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_r8_, Ldind_r8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_r8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_r8_, Ldc_r8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Bge_.Id,
|
||
new VmInstr(_instrCodesDb.Bge_, Bge_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_i1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_i1_, Ldind_i1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_u1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_u1_, Ldelem_u1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldstr_.Id,
|
||
new VmInstr(_instrCodesDb.Ldstr_, Ldstr_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloca_s_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloca_s_, Ldloca_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_i8_, Ldelem_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_8_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_8_, Ldc_i4_8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Blt_.Id,
|
||
new VmInstr(_instrCodesDb.Blt_, Blt_)
|
||
},
|
||
{
|
||
_instrCodesDb.Unbox_.Id,
|
||
new VmInstr(_instrCodesDb.Unbox_, Unbox_)
|
||
},
|
||
{
|
||
_instrCodesDb.Bge_un_.Id,
|
||
new VmInstr(_instrCodesDb.Bge_un_, Bge_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldelem_u2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldelem_u2_, Ldelem_u2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldind_u2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldind_u2_, Ldind_u2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Sub_ovf_un_.Id,
|
||
new VmInstr(_instrCodesDb.Sub_ovf_un_, Sub_ovf_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_4_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_4_, Ldc_i4_4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarg_0_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarg_0_, Ldarg_0_)
|
||
},
|
||
{
|
||
_instrCodesDb.Rem_un_.Id,
|
||
new VmInstr(_instrCodesDb.Rem_un_, Rem_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloc_1_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloc_1_, Ldloc_1_)
|
||
},
|
||
{
|
||
_instrCodesDb.Bne_un_.Id,
|
||
new VmInstr(_instrCodesDb.Bne_un_, Bne_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_i2_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_i2_un_, Conv_ovf_i2_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ckfinite_.Id,
|
||
new VmInstr(_instrCodesDb.Ckfinite_, Ckfinite_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldobj_.Id,
|
||
new VmInstr(_instrCodesDb.Ldobj_, Ldobj_)
|
||
},
|
||
{
|
||
_instrCodesDb.Pop_.Id,
|
||
new VmInstr(_instrCodesDb.Pop_, Pop_)
|
||
},
|
||
{
|
||
_instrCodesDb.Constrained_.Id,
|
||
new VmInstr(_instrCodesDb.Constrained_, Constrained_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_s_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_s_, Ldc_i4_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldloc_s_.Id,
|
||
new VmInstr(_instrCodesDb.Ldloc_s_, Ldloc_s_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarg_2_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarg_2_, Ldarg_2_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldarga_.Id,
|
||
new VmInstr(_instrCodesDb.Ldarga_, Ldarga_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_i8_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_i8_, Conv_i8_)
|
||
},
|
||
{
|
||
_instrCodesDb.Br_.Id,
|
||
new VmInstr(_instrCodesDb.Br_, Br_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ldc_i4_3_.Id,
|
||
new VmInstr(_instrCodesDb.Ldc_i4_3_, Ldc_i4_3_)
|
||
},
|
||
{
|
||
_instrCodesDb.Mul_ovf_.Id,
|
||
new VmInstr(_instrCodesDb.Mul_ovf_, Mul_ovf_)
|
||
},
|
||
{
|
||
_instrCodesDb.Shl_.Id,
|
||
new VmInstr(_instrCodesDb.Shl_, Shl_)
|
||
},
|
||
{
|
||
_instrCodesDb.Castclass_.Id,
|
||
new VmInstr(_instrCodesDb.Castclass_, Castclass_)
|
||
},
|
||
{
|
||
_instrCodesDb.Jmp_.Id,
|
||
new VmInstr(_instrCodesDb.Jmp_, Jmp_)
|
||
},
|
||
{
|
||
_instrCodesDb.Beq_.Id,
|
||
new VmInstr(_instrCodesDb.Beq_, Beq_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_r4_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_r4_, Conv_r4_)
|
||
},
|
||
{
|
||
_instrCodesDb.Ble_.Id,
|
||
new VmInstr(_instrCodesDb.Ble_, Ble_)
|
||
},
|
||
{
|
||
_instrCodesDb.Conv_ovf_u2_un_.Id,
|
||
new VmInstr(_instrCodesDb.Conv_ovf_u2_un_, Conv_ovf_u2_un_)
|
||
},
|
||
{
|
||
_instrCodesDb.Call_.Id,
|
||
new VmInstr(_instrCodesDb.Call_, Call_)
|
||
},
|
||
{
|
||
_instrCodesDb.Not_.Id,
|
||
new VmInstr(_instrCodesDb.Not_, Not_)
|
||
}
|
||
};
|
||
}
|
||
}
|
||
|
||
// Token: 0x02000042 RID: 66
|
||
public sealed class LocalVarType // \u0008
|
||
{
|
||
// Token: 0x060002E4 RID: 740 RVA: 0x00013F08 File Offset: 0x00012108
|
||
// Token: 0x060002E5 RID: 741 RVA: 0x00013F10 File Offset: 0x00012110
|
||
// Token: 0x04000171 RID: 369
|
||
public int TypeId /* \u0002 */ { get; set; }
|
||
}
|
||
|
||
// Token: 0x0200004D RID: 77
|
||
public sealed class ArgTypeToOutput // \u000E
|
||
{
|
||
// Token: 0x06000321 RID: 801 RVA: 0x00014C74 File Offset: 0x00012E74
|
||
// Token: 0x06000322 RID: 802 RVA: 0x00014C7C File Offset: 0x00012E7C
|
||
// Token: 0x0400017C RID: 380
|
||
public int TypeId /* \u0002 */ { get; set; }
|
||
|
||
// Token: 0x06000323 RID: 803 RVA: 0x00014C88 File Offset: 0x00012E88
|
||
// Token: 0x06000324 RID: 804 RVA: 0x00014C90 File Offset: 0x00012E90
|
||
// Token: 0x0400017D RID: 381
|
||
public bool IsOutput /* \u0003 */ { get; set; }
|
||
}
|
||
|
||
// Token: 0x0200005E RID: 94
|
||
internal sealed class CatchBlock
|
||
{
|
||
// Token: 0x0600036B RID: 875 RVA: 0x00015AFC File Offset: 0x00013CFC
|
||
// Token: 0x0600036C RID: 876 RVA: 0x00015B04 File Offset: 0x00013D04
|
||
// Token: 0x04000189 RID: 393
|
||
public byte Kind { get; set; }
|
||
|
||
// Token: 0x0600036D RID: 877 RVA: 0x00015B10 File Offset: 0x00013D10
|
||
// Token: 0x0600036E RID: 878 RVA: 0x00015B18 File Offset: 0x00013D18
|
||
// Token: 0x0400018A RID: 394
|
||
public int ExcTypeId { get; set; }
|
||
|
||
// Token: 0x0600036F RID: 879 RVA: 0x00015B24 File Offset: 0x00013D24
|
||
// Token: 0x06000370 RID: 880 RVA: 0x00015B2C File Offset: 0x00013D2C
|
||
// Token: 0x0400018B RID: 395
|
||
public uint PosKind4 { get; set; }
|
||
|
||
// Token: 0x06000371 RID: 881 RVA: 0x00015B38 File Offset: 0x00013D38
|
||
// Token: 0x06000372 RID: 882 RVA: 0x00015B40 File Offset: 0x00013D40
|
||
// Token: 0x0400018C RID: 396
|
||
public uint Start { get; set; }
|
||
|
||
// Token: 0x06000373 RID: 883 RVA: 0x00015B4C File Offset: 0x00013D4C
|
||
// Token: 0x06000374 RID: 884 RVA: 0x00015B54 File Offset: 0x00013D54
|
||
// Token: 0x0400018D RID: 397
|
||
public uint Pos { get; set; } // \u0005
|
||
|
||
// Token: 0x06000375 RID: 885 RVA: 0x00015B60 File Offset: 0x00013D60
|
||
// Token: 0x06000376 RID: 886 RVA: 0x00015B68 File Offset: 0x00013D68
|
||
// Token: 0x0400018E RID: 398
|
||
public uint Len { get; set; }
|
||
}
|
||
|
||
// Token: 0x02000049 RID: 73
|
||
internal abstract class VmTokenInfo // \u0008\u2006
|
||
{
|
||
internal enum Kind : byte
|
||
{
|
||
Class0, Field1, Method2, String3, MethodRef4
|
||
}
|
||
|
||
// Token: 0x0600030D RID: 781
|
||
public abstract Kind TokenKind(); // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
|
||
}
|
||
|
||
// Token: 0x02000017 RID: 23
|
||
internal sealed class UniversalTokenInfo // \u0003\u2008
|
||
{
|
||
// Token: 0x06000097 RID: 151 RVA: 0x00003E9C File Offset: 0x0000209C
|
||
// Token: 0x06000098 RID: 152 RVA: 0x00003EA4 File Offset: 0x000020A4
|
||
// Token: 0x04000020 RID: 32
|
||
public byte IsVm { get; set; }
|
||
|
||
// Token: 0x06000099 RID: 153 RVA: 0x00003EB0 File Offset: 0x000020B0
|
||
// Token: 0x0600009A RID: 154 RVA: 0x00003EB8 File Offset: 0x000020B8
|
||
// Token: 0x04000021 RID: 33
|
||
public int MetadataToken { get; set; }
|
||
|
||
// Token: 0x0600009B RID: 155 RVA: 0x00003EC4 File Offset: 0x000020C4
|
||
// Token: 0x0600009C RID: 156 RVA: 0x00003ECC File Offset: 0x000020CC
|
||
// Token: 0x04000022 RID: 34
|
||
public VmTokenInfo VmToken { get; set; }
|
||
}
|
||
|
||
// Token: 0x02000016 RID: 22
|
||
internal sealed class VmMethodRefTokenInfo : VmTokenInfo // \u0003\u2007
|
||
{
|
||
// Token: 0x06000091 RID: 145 RVA: 0x00003E68 File Offset: 0x00002068
|
||
// Token: 0x06000092 RID: 146 RVA: 0x00003E70 File Offset: 0x00002070
|
||
// Token: 0x0400001E RID: 30
|
||
public int Flags { get; set; }
|
||
|
||
// Token: 0x06000093 RID: 147 RVA: 0x00003E7C File Offset: 0x0000207C
|
||
// Token: 0x06000094 RID: 148 RVA: 0x00003E84 File Offset: 0x00002084
|
||
// Token: 0x0400001F RID: 31
|
||
public int Pos { get; set; }
|
||
|
||
// Token: 0x06000095 RID: 149 RVA: 0x00003E90 File Offset: 0x00002090
|
||
public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
|
||
{
|
||
return Kind.MethodRef4;
|
||
}
|
||
}
|
||
|
||
// Token: 0x0200004A RID: 74
|
||
internal sealed class VmMethodTokenInfo : VmTokenInfo // \u0008\u2007
|
||
{
|
||
// Token: 0x0600030F RID: 783 RVA: 0x00014BB0 File Offset: 0x00012DB0
|
||
// Token: 0x06000310 RID: 784 RVA: 0x00014BB8 File Offset: 0x00012DB8
|
||
// Token: 0x04000176 RID: 374
|
||
public byte Flags { get; set; }
|
||
|
||
// Token: 0x06000311 RID: 785 RVA: 0x00014BC4 File Offset: 0x00012DC4
|
||
public bool IsStatic() // \u0002
|
||
{
|
||
return (Flags & 2) > 0;
|
||
}
|
||
|
||
// Token: 0x06000312 RID: 786 RVA: 0x00014BD4 File Offset: 0x00012DD4
|
||
public bool IsGeneric() // \u0003
|
||
{
|
||
return (Flags & 1) > 0;
|
||
}
|
||
|
||
// Token: 0x06000313 RID: 787 RVA: 0x00014BE4 File Offset: 0x00012DE4
|
||
// Token: 0x06000314 RID: 788 RVA: 0x00014BEC File Offset: 0x00012DEC
|
||
// Token: 0x04000177 RID: 375
|
||
public UniversalTokenInfo Class { get; set; }
|
||
|
||
// Token: 0x06000315 RID: 789 RVA: 0x00014BF8 File Offset: 0x00012DF8
|
||
// Token: 0x06000316 RID: 790 RVA: 0x00014C00 File Offset: 0x00012E00
|
||
// Token: 0x04000178 RID: 376
|
||
public string Name { get; set; }
|
||
|
||
// Token: 0x06000317 RID: 791 RVA: 0x00014C0C File Offset: 0x00012E0C
|
||
// Token: 0x06000318 RID: 792 RVA: 0x00014C14 File Offset: 0x00012E14
|
||
// Token: 0x04000179 RID: 377
|
||
public UniversalTokenInfo[] Parameters { get; set; }
|
||
|
||
// Token: 0x06000319 RID: 793 RVA: 0x00014C20 File Offset: 0x00012E20
|
||
// Token: 0x0600031A RID: 794 RVA: 0x00014C28 File Offset: 0x00012E28
|
||
// Token: 0x0400017A RID: 378
|
||
public UniversalTokenInfo[] GenericArguments { get; set; }
|
||
|
||
// Token: 0x0600031B RID: 795 RVA: 0x00014C34 File Offset: 0x00012E34
|
||
// Token: 0x0600031C RID: 796 RVA: 0x00014C3C File Offset: 0x00012E3C
|
||
// Token: 0x0400017B RID: 379
|
||
public UniversalTokenInfo ReturnType { get; set; }
|
||
|
||
// Token: 0x0600031D RID: 797 RVA: 0x00014C48 File Offset: 0x00012E48
|
||
public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
|
||
{
|
||
return Kind.Method2;
|
||
}
|
||
}
|
||
|
||
// Token: 0x02000056 RID: 86
|
||
internal sealed class VmStringTokenInfo : VmTokenInfo // \u000E\u2007
|
||
{
|
||
// Token: 0x06000343 RID: 835 RVA: 0x000153CC File Offset: 0x000135CC
|
||
// Token: 0x06000344 RID: 836 RVA: 0x000153D4 File Offset: 0x000135D4
|
||
// Token: 0x04000185 RID: 389
|
||
public string Value { get; set; }
|
||
|
||
// Token: 0x06000345 RID: 837 RVA: 0x000153E0 File Offset: 0x000135E0
|
||
public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
|
||
{
|
||
return Kind.String3;
|
||
}
|
||
}
|
||
|
||
// Token: 0x02000060 RID: 96
|
||
internal sealed class VmFieldTokenInfo : VmTokenInfo // \u000F\u2006
|
||
{
|
||
// Token: 0x06000382 RID: 898 RVA: 0x00015C38 File Offset: 0x00013E38
|
||
// Token: 0x06000383 RID: 899 RVA: 0x00015C40 File Offset: 0x00013E40
|
||
// Token: 0x04000191 RID: 401
|
||
public UniversalTokenInfo Class { get; set; }
|
||
|
||
// Token: 0x06000384 RID: 900 RVA: 0x00015C4C File Offset: 0x00013E4C
|
||
// Token: 0x06000385 RID: 901 RVA: 0x00015C54 File Offset: 0x00013E54
|
||
// Token: 0x04000192 RID: 402
|
||
public string Name { get; set; }
|
||
|
||
// Token: 0x06000386 RID: 902 RVA: 0x00015C60 File Offset: 0x00013E60
|
||
// Token: 0x06000387 RID: 903 RVA: 0x00015C68 File Offset: 0x00013E68
|
||
// Token: 0x04000193 RID: 403
|
||
public bool IsStatic { get; set; }
|
||
|
||
// Token: 0x06000388 RID: 904 RVA: 0x00015C74 File Offset: 0x00013E74
|
||
public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
|
||
{
|
||
return Kind.Field1;
|
||
}
|
||
}
|
||
|
||
// Token: 0x02000061 RID: 97
|
||
internal sealed class VmClassTokenInfo : VmTokenInfo // \u000F\u2007
|
||
{
|
||
// Token: 0x04000194 RID: 404
|
||
// Token: 0x0600038A RID: 906 RVA: 0x00015C90 File Offset: 0x00013E90
|
||
// Token: 0x0600038B RID: 907 RVA: 0x00015C98 File Offset: 0x00013E98
|
||
public string ClassName { get; set; }
|
||
|
||
// Token: 0x0600038C RID: 908 RVA: 0x00015CA4 File Offset: 0x00013EA4
|
||
// Token: 0x04000195 RID: 405
|
||
// Token: 0x0600038D RID: 909 RVA: 0x00015CAC File Offset: 0x00013EAC
|
||
public bool IsOuterClassGeneric { get; set; }
|
||
|
||
// Token: 0x0600038E RID: 910 RVA: 0x00015CB8 File Offset: 0x00013EB8
|
||
// Token: 0x04000196 RID: 406
|
||
// Token: 0x0600038F RID: 911 RVA: 0x00015CC0 File Offset: 0x00013EC0
|
||
public bool IsGeneric { get; set; }
|
||
|
||
// Token: 0x06000390 RID: 912 RVA: 0x00015CCC File Offset: 0x00013ECC
|
||
// Token: 0x04000197 RID: 407
|
||
// Token: 0x06000391 RID: 913 RVA: 0x00015CD4 File Offset: 0x00013ED4
|
||
public UniversalTokenInfo[] GenericArguments { get; set; }
|
||
|
||
// Token: 0x06000392 RID: 914 RVA: 0x00015CE0 File Offset: 0x00013EE0
|
||
// Token: 0x04000198 RID: 408
|
||
// Token: 0x06000393 RID: 915 RVA: 0x00015CE8 File Offset: 0x00013EE8
|
||
public int OuterClassGenericClassIdx { get; set; } = -1;
|
||
|
||
// Token: 0x06000394 RID: 916 RVA: 0x00015CF4 File Offset: 0x00013EF4
|
||
// Token: 0x04000199 RID: 409
|
||
// Token: 0x06000395 RID: 917 RVA: 0x00015CFC File Offset: 0x00013EFC
|
||
public int OuterClassGenericMethodIdx { get; set; } = -1;
|
||
|
||
// Token: 0x06000396 RID: 918 RVA: 0x00015D08 File Offset: 0x00013F08
|
||
public override Kind TokenKind() // \u0008\u2006\u2008\u2000\u2002\u200A\u0002
|
||
{
|
||
return Kind.Class0;
|
||
}
|
||
}
|
||
}
|