protected static byte[] Decompress(byte[] decrypted, IBinaryReader reader, byte[] key, int keyMod) {
int destIndex = 0;
while (reader.Position < reader.Length) {
if (destIndex >= decrypted.Length)
break;
byte flags = reader.ReadByte();
for (int mask = 1; mask != 0x100; mask <<= 1) {
if (reader.Position >= reader.Length)
break;
if (destIndex >= decrypted.Length)
break;
if ((flags & mask) != 0) {
int displ = (int)reader.Read7BitEncodedUInt32();
int size = (int)reader.Read7BitEncodedUInt32();
Copy(decrypted, destIndex - displ, decrypted, destIndex, size);
destIndex += size;
}
else {
byte b = reader.ReadByte();
if (key != null)
b ^= key[destIndex % keyMod];
decrypted[destIndex++] = b;
}
}
}
return decrypted;
}
internal void Deserialize(IBinaryReader reader, int count)
{
for (int i = 0; i < count; i++)
{
_excerpts.Add(reader.ReadString());
}
}
/** <inheritDoc /> */
public void ReadBinary(IBinaryReader reader)
{
Byte = reader.ReadByte("Byte");
ByteArray = reader.ReadByteArray("ByteArray");
Char = reader.ReadChar("Char");
CharArray = reader.ReadCharArray("CharArray");
Short = reader.ReadShort("Short");
ShortArray = reader.ReadShortArray("ShortArray");
Int = reader.ReadInt("Int");
IntArray = reader.ReadIntArray("IntArray");
Long = reader.ReadLong("Long");
LongArray = reader.ReadLongArray("LongArray");
Boolean = reader.ReadBoolean("Boolean");
BooleanArray = reader.ReadBooleanArray("BooleanArray");
Float = reader.ReadFloat("Float");
FloatArray = reader.ReadFloatArray("FloatArray");
Double = reader.ReadDouble("Double");
DoubleArray = reader.ReadDoubleArray("DoubleArray");
Decimal = reader.ReadDecimal("Decimal");
DecimalArray = reader.ReadDecimalArray("DecimalArray");
Date = reader.ReadTimestamp("Date");
DateArray = reader.ReadTimestampArray("DateArray");
String = reader.ReadString("String");
StringArray = reader.ReadStringArray("StringArray");
Guid = reader.ReadObject<Guid>("Guid");
GuidArray = reader.ReadGuidArray("GuidArray");
}
/// <summary>
/// Initializes a new instance of the <see cref="ComputeFuncJob"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public ComputeFuncJob(IBinaryReader reader)
{
var reader0 = (BinaryReader) reader.GetRawReader();
_clo = reader0.ReadObject<IComputeFunc>();
_arg = reader0.ReadObject<object>();
}
///<summary>
///</summary>
///<param name = "reader"></param>
public BinaryPropertyDeserializer(IBinaryReader reader)
{
if (reader == null) {
throw new ArgumentNullException("reader");
}
_reader = reader;
}
internal void Deserialize(IBinaryReader reader, MatchParseContext context)
{
_docId = (context.LongIdentifiers) ? reader.ReadInt64() : reader.ReadInt32();
_weight = reader.ReadInt32();
AttributesValues.Deserialize(reader, context);
}
/** <inheritDoc /> */
public void ReadBinary(IBinaryReader reader)
{
StreetNumber = reader.ReadInt("streetNum");
FlatNumber = reader.ReadInt("flatNum");
City = reader.ReadString("city");
Street = reader.ReadString("street");
}
static bool ReadHeader(IBinaryReader reader, out ushort flags, out uint codeSize) {
byte b = reader.ReadByte();
switch (b & 7) {
case 2:
case 6:
flags = 2;
codeSize = (uint)(b >> 2);
return true;
case 3:
flags = (ushort)((reader.ReadByte() << 8) | b);
uint headerSize = (byte)(flags >> 12);
ushort maxStack = reader.ReadUInt16();
codeSize = reader.ReadUInt32();
uint localVarSigTok = reader.ReadUInt32();
reader.Position += -12 + headerSize * 4;
if (headerSize < 3)
flags &= 0xFFF7;
return true;
default:
flags = 0;
codeSize = 0;
return false;
}
}
public byte[] Decrypt() {
if (reader.ReadUInt32() != 0x58455245)
throw new InvalidDataException("Invalid EREX sig");
if (reader.ReadInt32() > 1)
throw new ApplicationException("Invalid EREX file");
byte flags = reader.ReadByte();
bool isEncrypted = (flags & 1) != 0;
bool isDeflated = (flags & 2) != 0;
int length = reader.ReadInt32();
if (length < 0)
throw new ApplicationException("Invalid length");
if (isEncrypted)
ReadKey();
if (isDeflated)
reader = Inflate(length);
if (isEncrypted)
reader = Decrypt(length);
return reader.ReadBytes(length);
}
public ImageReader(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, byte[] data)
{
this.deobfuscatorContext = deobfuscatorContext;
this.module = module;
this.reader = MemoryImageStream.Create(data);
this.memberRefConverter = new MemberRefConverter(module);
}
/// <summary>
/// Initializes a new instance of the <see cref="ContinuousQueryFilterHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public ContinuousQueryFilterHolder(IBinaryReader reader)
{
var rawReader = (BinaryReader) reader.GetRawReader();
_filter = rawReader.ReadObject<object>();
_keepBinary = rawReader.ReadBoolean();
}
internal void Deserialize(IBinaryReader reader)
{
FlushTag = reader.ReadInt32();
if (FlushTag < 0)
{
throw new SphinxException(String.Format(Messages.Exception_CouldNotFlushIndexAttributeValues, FlushTag));
}
}
public static MethodBodyHeader ParseMethodBody(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
try {
return ParseMethodBody2(reader, out code, out extraSections);
}
catch (IOException) {
throw new InvalidMethodBody();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializableObjectHolder"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
public SerializableObjectHolder(IBinaryReader reader)
{
Debug.Assert(reader != null);
var reader0 = (BinaryReader) reader.GetRawReader();
_item = new BinaryFormatter().Deserialize(new BinaryStreamAdapter(reader0.Stream), null);
}
/// <summary>
/// Reads the column
/// </summary>
/// <param name="reader">A reader positioned on this column</param>
/// <returns>The column value</returns>
public uint Read(IBinaryReader reader) {
switch (size) {
case 1: return reader.ReadByte();
case 2: return reader.ReadUInt16();
case 4: return reader.ReadUInt32();
default: throw new InvalidOperationException("Invalid column size");
}
}
public OperationDataMapper(IXmlReader xmlReader, IBinaryReader binaryReader, ISpatialRecordMapper spatialRecordMapper, ISectionMapper sectionMapper, IUniqueIdMapper uniqueIdMapper)
{
_spatialRecordMapper = spatialRecordMapper;
_sectionMapper = sectionMapper;
_uniqueIdMapper = uniqueIdMapper;
_xmlReader = xmlReader;
_binaryReader = binaryReader;
}
ResourceReader(ModuleDef module, IBinaryReader reader, CreateResourceDataDelegate createResourceDataDelegate) {
this.reader = reader;
this.resourceDataCreator = new ResourceDataCreator(module);
this.createResourceDataDelegate = createResourceDataDelegate;
var stream = reader as IImageStream;
this.baseFileOffset = stream == null ? 0 : (long)stream.FileOffset;
}
CustomAttributeReader(ModuleDef module, IBinaryReader reader, bool ownRerader)
{
this.module = module;
this.reader = reader;
this.ownReader = ownRerader;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
}
public static byte[] readExtraSections(IBinaryReader reader)
{
try {
return readExtraSections2(reader);
}
catch (IOException) {
throw new InvalidMethodBody();
}
}
static uint readUInt32(IBinaryReader reader)
{
try {
return reader.Read7BitEncodedUInt32();
}
catch {
throw new ResourceReaderException("Invalid encoded int32");
}
}
/// <summary>
/// Read binary object.
/// </summary>
/// <param name="obj">Instantiated empty object.</param>
/// <param name="reader">Reader.</param>
/// <exception cref="BinaryObjectException">Type is not registered in serializer: + type.Name</exception>
public void ReadBinary(object obj, IBinaryReader reader)
{
var binarizable = obj as IBinarizable;
if (binarizable != null)
binarizable.ReadBinary(reader);
else
GetDescriptor(obj).Read(obj, reader);
}
internal void Deserialize(IBinaryReader reader, int count)
{
for (int i = 0; i < count; i++)
{
SearchQueryResult result = new SearchQueryResult();
result.Deserialize(reader);
_queryResults.Add(result);
}
}
CustomAttributeReader(ModuleDefMD readerModule, uint offset)
{
this.module = readerModule;
this.reader = readerModule.BlobStream.CreateStream(offset);
this.ownReader = true;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
}
static byte[] TryCreateIcon(IBinaryReader reader, ResourceDirectory iconDir) {
try {
reader.Position = 0;
var outStream = new MemoryStream();
var writer = new BinaryWriter(outStream);
// Write GRPICONDIR
writer.Write(reader.ReadUInt16());
writer.Write(reader.ReadUInt16());
ushort numImages;
writer.Write(numImages = reader.ReadUInt16());
var entries = new List<GrpIconDirEntry>();
for (int i = 0; i < numImages; i++) {
var e = new GrpIconDirEntry();
entries.Add(e);
e.bWidth = reader.ReadByte();
e.bHeight = reader.ReadByte();
e.bColorCount = reader.ReadByte();
e.bReserved = reader.ReadByte();
e.wPlanes = reader.ReadUInt16();
e.wBitCount = reader.ReadUInt16();
e.dwBytesInRes = reader.ReadUInt32();
e.nID = reader.ReadUInt16();
}
uint dataOffset = 2 * 3 + (uint)entries.Count * 0x10;
foreach (var e in entries) {
writer.Write(e.bWidth);
writer.Write(e.bHeight);
writer.Write(e.bColorCount);
writer.Write(e.bReserved);
writer.Write(e.wPlanes);
writer.Write(e.wBitCount);
writer.Write(e.dwBytesInRes);
writer.Write(dataOffset);
dataOffset += e.dwBytesInRes;
}
foreach (var e in entries) {
var d = iconDir.Directories.FirstOrDefault(a => a.Name == new ResourceName(e.nID));
if (d == null || d.Data.Count == 0)
return null;
var r = d.Data[0].Data;
Debug.Assert(r.Length == e.dwBytesInRes);
if (r.Length < e.dwBytesInRes)
return null;
r.Position = 0;
writer.Write(r.ReadBytes((int)e.dwBytesInRes), 0, (int)e.dwBytesInRes);
}
return outStream.ToArray();
}
catch (IOException) {
}
return null;
}
/// <summary>
/// Default ctor for marshalling.
/// </summary>
/// <param name="reader"></param>
public ComputeJobHolder(IBinaryReader reader)
{
Debug.Assert(reader != null);
var reader0 = (BinaryReader) reader.GetRawReader();
_ignite = reader0.Marshaller.Ignite;
_job = reader0.ReadObject<IComputeJob>();
}
internal void Deserialize(IBinaryReader reader, bool deserializeAdditionalStatistics)
{
TokenizedForm = reader.ReadString();
NormalizedForm = reader.ReadString();
if (deserializeAdditionalStatistics)
{
DocumentsCount = reader.ReadInt32();
HitsCount = reader.ReadInt32();
}
}
public static bool Verify(IBinaryReader reader) {
try {
byte[] code, extraSections;
ParseMethodBody(reader, out code, out extraSections);
return true;
}
catch (InvalidMethodBody) {
return false;
}
}
CustomAttributeReader(ModuleDef module, IBinaryReader reader, GenericParamContext gpContext)
{
this.module = module;
this.reader = reader;
this.ownReader = false;
this.genericArguments = null;
this.recursionCounter = new RecursionCounter();
this.verifyReadAllBytes = false;
this.gpContext = gpContext;
}
internal virtual ControlCode ProcessChar(IBinaryReader reader, StringBuilder sb, ref int count)
{
short ch = reader.ReadShort();
count++;
ControlCode code = controlCodes.FirstOrDefault(cc => cc.Code == ch);
if (code != null)
{
if (code.Code != -1)
{
sb.Append('[');
if (code.Tag != null)
{
sb.Append(code.Tag);
}
else
{
sb.Append(((ushort)ch).ToString("X4"));
}
for (int i = 0; i < code.Arguments; i++)
{
ch = reader.ReadShort();
count++;
sb.Append(' ');
sb.Append(((ushort)ch).ToString("X4"));
}
sb.Append(']');
}
}
else
{
if (charLookup.ContainsKey(ch))
{
sb.Append(charLookup[ch]);
}
else
{
sb.Append('[');
sb.Append(((ushort)ch).ToString("X4"));
sb.Append(']');
}
}
return code;
}
public virtual bool Decrypt(IBinaryReader fileDataReader, DumpedMethod dm) {
if (fileDataReader.ReadByte() != 0x2A)
return false; // Not a RET
methodsDataReader.Position = fileDataReader.ReadCompressedUInt32();
dm.mhCodeSize = methodsDataReader.ReadCompressedUInt32();
dm.code = methodsDataReader.ReadBytes((int)dm.mhCodeSize);
if ((dm.mhFlags & 8) != 0)
dm.extraSections = MethodBodyParser.ReadExtraSections(methodsDataReader);
if (!DecryptCode(dm))
return false;
return true;
}
public MethodDefReader(ImageReader imageReader, IBinaryReader reader)
{
this.bmd = new BabelMethodDef();
this.methodRefReader = new MethodRefReader(imageReader, reader, bmd);
this.methodBodyReader = new MethodBodyReader(imageReader, reader);
}
static byte[] Decompress(IBinaryReader reader, byte[] key, int keyMod)
{
return(Decompress(new byte[reader.Read7BitEncodedUInt32()], reader, key, keyMod));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="reader">A reader positioned at the start of a .NET method body</param>
/// <param name="parameters">Method parameters</param>
/// <param name="gpContext">Generic parameter context</param>
public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader reader, IList <Parameter> parameters, GenericParamContext gpContext)
: this(opResolver, reader, null, parameters, gpContext)
{
}
public MethodRefReader(ImageReader imageReader, IBinaryReader reader, BabelMethodreference bmr)
{
this.imageReader = imageReader;
this.reader = reader;
this.bmr = bmr;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="codeReader">A reader positioned at the start of a .NET method body</param>
/// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't
/// present or if <paramref name="codeReader"/> contains the exception handlers</param>
/// <param name="parameters">Method parameters</param>
public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList <Parameter> parameters)
: this(opResolver, codeReader, ehReader, parameters, new GenericParamContext())
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="data">The data</param>
public BinaryReaderChunk(IBinaryReader data)
: this(data, (uint)data.Length)
{
}
public void Decode(ISession session, IBinaryReader reader)
{
START:
try
{
object data;
lock (reader.Stream)
{
if (mSize == 0)
{
if (reader.Length < 4)
{
return;
}
mSize = reader.ReadInt32();
}
if (reader.Length < mSize)
{
return;
}
Type type = TypeHandler.ReadType(reader);
int bodySize = reader.ReadInt32();
data = reader.Stream.Deserialize(bodySize, type);
Message msg = data as Message;
if (msg != null)
{
msg.Track("message decode start");
msg.IsLocal = false;
int datasize = reader.ReadInt32();
MessageType msgType = TypeHandler.GetMessageType(msg.DataType);
if (msgType.IsCustomSerializer)
{
ISerializer body = msgType.Create();
body.Deserialize(reader);
msg.Data = body;
}
else
{
msg.Data = reader.Stream.Deserialize(datasize, msgType.Type);
}
msg.Track("message decode completed");
}
mSize = 0;
}
try
{
if (Completed != null)
{
Completed(this, mCompletedEventArgs.SetInfo(session, data));
}
}
catch (Exception e_)
{
session.Server.Error(e_, session, "session packet process object error!");
}
if (reader.Length == 0)
{
return;
}
goto START;
}
catch (Exception e_)
{
session.Server.Error(e_, session, "session packet decode error!");
session.Dispose();
}
}
static byte ReadByteAt(IBinaryReader reader, int offs)
{
reader.Position = offs;
return(reader.ReadByte());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="reader">A reader positioned at the start of a .NET method body</param>
/// <param name="method">Use parameters from this method</param>
public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader reader, MethodDef method)
: this(opResolver, reader, null, method.Parameters, new GenericParamContext())
{
}
/** <inheritdoc /> */
public void ReadBinary(IBinaryReader reader)
{
TestProperty = reader.ReadInt("TestProp");
}
/** <inheritdoc /> */
public void ReadBinary(IBinaryReader reader)
{
var r = reader.GetRawReader();
ThrowErr = r.ReadBoolean();
}
/** <inheritdoc /> */
public void ReadBinary(IBinaryReader reader)
{
TestProperty = reader.ReadInt("TestProp");
throw new Exception("Expected exception");
}
/** */
public void ReadBinary(IBinaryReader reader)
{
Id = reader.ReadInt("Id");
Title = reader.ReadString("Title");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="data">The data</param>
/// <param name="virtualSize">Virtual size of <paramref name="data"/></param>
public BinaryReaderChunk(IBinaryReader data, uint virtualSize)
{
this.data = data;
this.virtualSize = virtualSize;
}
byte[] Decompress(IBinaryReader reader)
{
return(Decompress(reader, decryptionKey, decryptionKeyMod));
}
public override void ReadFromBinary(IBinaryReader reader)
{
//int count = 0, i = 0;
//while (i < reader.Arguments.Length)
//{
// count++;
// i += reader.Arguments[i] + 1;
//}
//_fontNames = new string[count];
//count = 0;
//i = 0;
//while (i < reader.Arguments.Length)
//{
// char[] a = new char[reader.Arguments[i]];
// for (int j = 0; j < reader.Arguments[i]; j++)
// a[j] = (char)reader.Arguments[i + j + 1];
// _fontNames[count] = new string(a);
// count++;
// i += reader.Arguments[i] + 1;
//}
while (reader.CurrentArg < reader.ArgumentsCount)
{
FontNames.Add(reader.ReadFixedString());
}
//FontNames = new string[reader.ArgumentsCount];
//for (int i = 0; i < reader.ArgumentsCount; i++)
//{
// FontNames[i] = reader.ReadFixedString();
//}
//_fonts = new FontWrapper[_fontNames.Length];
//i = 0;
//foreach (var fontName in _fontNames)
//{
// var key = normalizeFontName(fontName);
// if (_fontMapping.ContainsKey(key))
// {
// _fonts[i++] = _fontMapping[key];
// }
// else {
// FontFamily decodedFont = FontFamily.Families.FirstOrDefault( f => f.Name == fontName);
// FontStyle style = FontStyle.Regular;
// if (decodedFont == null && fontName.Contains(" "))
// {
// var values = fontName.Split(' ');
// var name = values[0];
// decodedFont = FontFamily.Families.FirstOrDefault(f => f.Name == name);
// for(int v = 1; v<values.Length; v++)
// {
// if (values[v].Equals("bold", System.StringComparison.OrdinalIgnoreCase))
// style = style | FontStyle.Bold;
// if (values[v].Equals("italic", System.StringComparison.OrdinalIgnoreCase) || values[v].Equals("oblique", System.StringComparison.OrdinalIgnoreCase))
// style = style | FontStyle.Italic;
// }
// }
// if (decodedFont != null)
// // XXX: assume non symbolic encoding, is that right?
// _fonts[i++] = new FontWrapper(new Font(decodedFont, DEFAULT_FONT_SIZE, style), false);
// else
// _fonts[i++] = new FontWrapper(new Font(fontName, DEFAULT_FONT_SIZE), false);
// }
//}
}
bool CheckResourceV106(IBinaryReader reader)
{
decrypter = DecrypterV106.Create(reader);
return(decrypter != null);
}
public TextPacketParser(IBinaryReader reader, Buffer <byte> buffer)
{
buffer.EnsureCapacity(260);
m_reader = reader;
m_buffer = buffer;
}
/** <inheritdoc /> */
public void ReadBinary(object obj, IBinaryReader reader)
{
// No-op.
}
public void ReadBinary(IBinaryReader reader)
{
Int = reader.ReadInt("Int");
Str = reader.GetRawReader().ReadString();
}
/// <summary>
/// Creates a CIL method body or returns an empty one if <paramref name="codeReader"/> doesn't
/// point to the start of a valid CIL method body.
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="codeReader">A reader positioned at the start of a .NET method body</param>
/// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't
/// present or if <paramref name="codeReader"/> contains the exception handlers</param>
/// <param name="parameters">Method parameters</param>
/// <param name="gpContext">Generic parameter context</param>
public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList <Parameter> parameters, GenericParamContext gpContext)
{
var mbReader = new MethodBodyReader(opResolver, codeReader, ehReader, parameters, gpContext);
if (!mbReader.Read())
{
return(new CilBody());
}
return(mbReader.CreateCilBody());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="codeReader">A reader positioned at the start of a .NET method body</param>
/// <param name="ehReader">Exception handler reader or <c>null</c> if exceptions aren't
/// present or if <paramref name="codeReader"/> contains the exception handlers</param>
/// <param name="parameters">Method parameters</param>
/// <param name="gpContext">Generic parameter context</param>
public MethodBodyReader(IInstructionOperandResolver opResolver, IBinaryReader codeReader, IBinaryReader ehReader, IList <Parameter> parameters, GenericParamContext gpContext)
: base(codeReader, parameters)
{
this.opResolver = opResolver;
this.exceptionsReader = ehReader;
this.gpContext = gpContext;
}
public override void ReadFromBinary(IBinaryReader reader)
{
Point1 = reader.ReadPoint();
Point2 = reader.ReadPoint();
}
/// <summary>
/// Reads the field.
/// <para />
/// Java side does not have counterparts for byte, ushort, uint, ulong.
/// For such fields we write a special boolean field indicating the type.
/// If special field is present, then the value has to be converted to .NET-specific type.
/// </summary>
private static object ReadField(IBinaryReader reader, string fieldName, ICollection <int> dotNetFields)
{
var fieldVal = reader.ReadObject <object>(fieldName);
if (fieldVal == null)
{
return(null);
}
var fieldType = fieldVal.GetType();
unchecked
{
if (fieldType == typeof(byte))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? (sbyte)(byte)fieldVal : fieldVal);
}
if (fieldType == typeof(short))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? (ushort)(short)fieldVal : fieldVal);
}
if (fieldType == typeof(int))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? (uint)(int)fieldVal : fieldVal);
}
if (fieldType == typeof(long))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? (ulong)(long)fieldVal : fieldVal);
}
if (fieldType == typeof(byte[]))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? ConvertArray <byte, sbyte>((byte[])fieldVal) : fieldVal);
}
if (fieldType == typeof(short[]))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? ConvertArray <short, ushort>((short[])fieldVal) : fieldVal);
}
if (fieldType == typeof(int[]))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? ConvertArray <int, uint>((int[])fieldVal) : fieldVal);
}
if (fieldType == typeof(long[]))
{
return(dotNetFields.Contains(BinaryUtils.GetStringHashCode(fieldName))
? ConvertArray <long, ulong>((long[])fieldVal) : fieldVal);
}
}
return(fieldVal);
}
public void ReadBinary(IBinaryReader reader)
{
throw new BinaryObjectException("Expected");
}
public MethodRefReader(ImageReader imageReader, IBinaryReader reader)
: this(imageReader, reader, new BabelMethodreference())
{
}
/// <summary>
/// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't
/// point to the start of a valid CIL method body.
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="reader">A reader positioned at the start of a .NET method body</param>
/// <param name="parameters">Method parameters</param>
public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, IList <Parameter> parameters)
{
return(CreateCilBody(opResolver, reader, null, parameters, new GenericParamContext()));
}
/// <summary>
/// Creates a CIL method body or returns an empty one if <paramref name="reader"/> doesn't
/// point to the start of a valid CIL method body.
/// </summary>
/// <param name="opResolver">The operand resolver</param>
/// <param name="reader">A reader positioned at the start of a .NET method body</param>
/// <param name="method">Use parameters from this method</param>
/// <param name="gpContext">Generic parameter context</param>
public static CilBody CreateCilBody(IInstructionOperandResolver opResolver, IBinaryReader reader, MethodDef method, GenericParamContext gpContext)
{
return(CreateCilBody(opResolver, reader, null, method.Parameters, gpContext));
}
public Type ReadType(IBinaryReader reader)
{
string typeName = reader.ReadLine();
return(GetType(typeName));
}
/// <summary>
/// Gets the streaming context.
/// </summary>
private static StreamingContext GetStreamingContext(IBinaryReader reader)
{
return(new StreamingContext(StreamingContextStates.All, reader));
}
