public static X86MethodBody FromReadingContext(ReadingContext context)
{
var body = new X86MethodBody();
body._readingContext = context.CreateSubContext(context.Reader.StartPosition);
return(body);
}
protected override ModuleReference ReadMember(MetadataToken token, ReadingContext context)
{
return(new ModuleReference(Header, token, new MetadataRow <uint>()
{
Column1 = context.Reader.ReadIndex(TableStream.StringIndexSize)
}));
}
public void ConvertWithIndexEndTest()
{
var config = new CsvConfiguration {
HasHeaderRecord = false
};
var rowMock = new Mock <ICsvReaderRow>();
var currentRecord = new[] { "1", "one", "1", "2", "3" };
var context = new ReadingContext(new StringReader(string.Empty), config, false)
{
Record = currentRecord
};
rowMock.Setup(m => m.Configuration).Returns(config);
rowMock.Setup(m => m.Context).Returns(context);
rowMock.Setup(m => m.GetField(It.IsAny <Type>(), It.IsAny <int>())).Returns <Type, int>((type, index) => Convert.ToInt32(currentRecord[index]));
var data = new CsvPropertyMapData(typeof(Test).GetProperty("List"))
{
Index = 2,
IndexEnd = 3
};
data.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
var converter = new CollectionGenericConverter();
var list = (List <int?>)converter.ConvertFromString("1", rowMock.Object, data);
Assert.AreEqual(2, list.Count);
Assert.AreEqual(1, list[0]);
Assert.AreEqual(2, list[1]);
}
public static VTableHeader FromReadingContext(ReadingContext readingContext)
{
var tableHeader = new VTableHeader();
tableHeader.Rva = readingContext.Reader.ReadUInt32();
ushort size = readingContext.Reader.ReadUInt16();
tableHeader.Attributes = (VTableAttributes)readingContext.Reader.ReadUInt16();
long fileOffset = readingContext.Assembly.RvaToFileOffset(tableHeader.Rva);
var tokensReader = readingContext.Reader.CreateSubReader(fileOffset, size * (tableHeader.Is32Bit ? sizeof(int) : sizeof(long)));
for (int i = 0; i < size; i++)
{
var token = new MetadataToken(tokensReader.ReadUInt32());
MetadataMember member;
if (readingContext.Assembly.NetDirectory.MetadataHeader.GetStream <TableStream>()
.TryResolveMember(token, out member))
{
tableHeader.Table.Add(member);
}
if (tableHeader.Is64Bit)
{
tokensReader.ReadUInt32();
}
}
return(tableHeader);
}
public static VTablesDirectory FromReadingContext(ReadingContext readingContext)
{
return(new VTablesDirectory()
{
_readingContext = readingContext
});
}
protected override TypeSpecification ReadMember(MetadataToken token, ReadingContext context)
{
return(new TypeSpecification(Header, token, new MetadataRow <uint>()
{
Column1 = context.Reader.ReadIndex(TableStream.BlobIndexSize)
}));
}
public void ConvertWithIndexEndTest()
{
var config = new CsvHelper.Configuration.Configuration {
HasHeaderRecord = false
};
var rowMock = new Mock <IReaderRow>();
var headers = new[] { "Id", "Name", "Prop1", "Prop2", "Prop3" };
var currentRecord = new[] { "1", "One", "1", "2", "3" };
var context = new ReadingContext(new StringReader(string.Empty), config, false)
{
HeaderRecord = headers,
Record = currentRecord
};
rowMock.Setup(m => m.Configuration).Returns(config);
rowMock.Setup(m => m.Context).Returns(context);
rowMock.Setup(m => m.GetField(It.IsAny <Type>(), It.IsAny <int>())).Returns <Type, int>((type, index) => Convert.ToInt32(currentRecord[index]));
var data = new MemberMapData(typeof(Test).GetProperty("Dictionary"))
{
Index = 2,
IndexEnd = 3
};
data.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture;
var converter = new IDictionaryGenericConverter();
var dictionary = (IDictionary)converter.ConvertFromString("1", rowMock.Object, data);
Assert.AreEqual(2, dictionary.Count);
Assert.AreEqual(1, dictionary["Prop1"]);
Assert.AreEqual(2, dictionary["Prop2"]);
}
internal static MetadataHeader FromReadingContext(ReadingContext context)
{
var reader = context.Reader;
var header = new MetadataHeader
{
StartOffset = reader.Position,
Signature = reader.ReadUInt32(),
MajorVersion = reader.ReadUInt16(),
MinorVersion = reader.ReadUInt16(),
Reserved = reader.ReadUInt32(),
VersionLength = reader.ReadUInt32(),
};
header.VersionString = Encoding.ASCII.GetString(reader.ReadBytes((int)header.VersionLength));
header.Flags = reader.ReadUInt16();
var streamCount = reader.ReadUInt16();
for (int i = 0; i < streamCount; i++)
{
var streamHeader = MetadataStreamHeader.FromReadingContext(context);
header.StreamHeaders.Add(streamHeader);
}
return(header);
}
protected override MetadataRow <uint> ReadRow(ReadingContext context, MetadataToken token)
{
return(new MetadataRow <uint>(token)
{
Column1 = context.Reader.ReadUInt32(),
});
}
protected override EncMap ReadMember(MetadataToken token, ReadingContext context)
{
return(new EncMap(Header, token, new MetadataRow <uint>()
{
Column1 = context.Reader.ReadUInt32(),
}));
}
public static VTableHeader FromReadingContext(ReadingContext readingContext)
{
var tableHeader = new VTableHeader();
tableHeader.Rva = readingContext.Reader.ReadUInt32();
ushort size = readingContext.Reader.ReadUInt16();
tableHeader.Attributes = (VTableAttributes) readingContext.Reader.ReadUInt16();
long fileOffset = readingContext.Assembly.RvaToFileOffset(tableHeader.Rva);
var tokensReader = readingContext.Reader.CreateSubReader(fileOffset, size * (tableHeader.Is32Bit ? sizeof (int) : sizeof (long)));
for (int i = 0; i < size; i++)
{
var token = new MetadataToken(tokensReader.ReadUInt32());
MetadataMember member;
if (readingContext.Assembly.NetDirectory.MetadataHeader.GetStream<TableStream>()
.TryResolveMember(token, out member))
{
tableHeader.Table.Add(member);
}
if (tableHeader.Is64Bit)
tokensReader.ReadUInt32();
}
return tableHeader;
}
public void ReadConvertNoIndexEndTest()
{
var config = new CsvHelper.Configuration.Configuration {
HasHeaderRecord = false
};
var rowMock = new Mock <IReaderRow>();
var currentRecord = new[] { "1", "one", "1", "2", "3" };
var context = new ReadingContext(new StringReader(string.Empty), config, false)
{
Record = currentRecord
};
rowMock.Setup(m => m.Configuration).Returns(config);
rowMock.Setup(m => m.Context).Returns(context);
rowMock.Setup(m => m.GetField(It.IsAny <Type>(), It.IsAny <int>())).Returns <Type, int>((type, index) => Convert.ToInt32(currentRecord[index]));
var data = new MemberMapData(typeof(Test).GetTypeInfo().GetProperty("List"))
{
Index = 2,
TypeConverterOptions = { CultureInfo = CultureInfo.CurrentCulture }
};
var converter = new ArrayConverter();
var enumerable = (int?[])converter.ConvertFromString("1", rowMock.Object, data);
var list = enumerable.ToList();
Assert.AreEqual(3, list.Count);
Assert.AreEqual(1, list[0]);
Assert.AreEqual(2, list[1]);
Assert.AreEqual(3, list[2]);
}
/// <summary>
/// Event, wenn Daten nicht richtig gelesen werden konnten
/// </summary>
/// <param name="obj"></param>
private void BadDataResponse(ReadingContext obj)
{
int row = obj.Row;
string col = obj.Field;
Debug.WriteLine($"{row} -- {col}", "BadDataResponse");
}
public Data ReadData(string type, ReadingContext context)
{
if (Document.Basics.TryGetValue(type, out var basicSchema))
{
return(ReadBasicFunc(basicSchema, context));
}
if (Document.Enums.TryGetValue(type, out var enumSchema))
{
return(ReadEnum(enumSchema, context));
}
if (Document.Bitfields.TryGetValue(type, out var bitFieldsSchema))
{
return(ReadBitField(bitFieldsSchema, context));
}
if (Document.Bitflags.TryGetValue(type, out var bitflagsSchema))
{
return(ReadBitFlags(bitflagsSchema, context));
}
if (Document.Compounds.TryGetValue(type, out var compoundSchema))
{
return(ReadCompound(compoundSchema, context));
}
if (Document.NiObjects.TryGetValue(type, out var niObjectSchema))
{
return(ReadNiObject(niObjectSchema, context));
}
throw new Exception();
}
Data ReadCompound(CompoundSchema compound, ReadingContext parentContext)
{
if (ReadExtraCompoundFunc != null &&
ReadExtraCompoundFunc(compound, parentContext, out var data))
{
return(data);
}
var state = Document.ParameterLookup.BuildCompoundState(compound, parentContext.Argument);
var interpreter = new Interpreter(state);
var compoundData = new Dictionary <string, Data>();
foreach (var fieldSchema in compound.Fields)
{
var fieldData = ReadField(fieldSchema, interpreter, parentContext);
if (fieldData == null)
{
continue;
}
//state.Set(fieldSchema, Oldvalue.From(fieldData));
compoundData[fieldSchema.Name] = fieldData;
}
return(new CompoundData()
{
Fields = compoundData,
Schema = compound,
});
}
internal static ImageSymbolImport FromReadingContext(ReadingContext context)
{
var reader = context.Reader;
var application = context.Assembly;
var optionalHeader = application.NtHeaders.OptionalHeader;
var import = new ImageSymbolImport(optionalHeader.Magic == OptionalHeaderMagic.Pe32Plus
? reader.ReadUInt64()
: reader.ReadUInt32());
if (import.Lookup == 0)
{
return(import);
}
import.IsImportByOrdinal = import.Lookup >> (optionalHeader.Magic == OptionalHeaderMagic.Pe32Plus ? 63 : 31) == 1;
if (!import.IsImportByOrdinal)
{
import.HintName =
HintName.FromReadingContext(context.CreateSubContext(application.RvaToFileOffset(import.HintNameRva)));
}
return(import);
}
Data ReadField(FieldSchema fieldSchema, Interpreter interpreter, ReadingContext parentContext)
{
var type = parentContext.ReadType(fieldSchema.Type);
var argument = Expressions.GetArgument(fieldSchema, interpreter);
var childContext = parentContext.Extend(fieldSchema, argument);
if (!parentContext.Version.MatchesVersionConstraint(fieldSchema.MinVersion, fieldSchema.MaxVersion))
{
return(null);
}
if (!Expressions.CheckCondition(fieldSchema, interpreter))
{
return(null);
}
if (!Expressions.CheckVersionCondition(fieldSchema, parentContext.VersionInterpreter))
{
return(null);
}
if (!Inheritance.CheckIncludedInType(fieldSchema, parentContext.Parent))
{
return(null);
}
if (fieldSchema.IsMultiDimensional)
{
var count = Expressions.GetCount(fieldSchema, interpreter);
var elements = new List <Data>(count);
for (int i = 0; i < count; i++)
{
elements.Add(ReadData(type, childContext));
}
return(new ListData(elements));
}
return(ReadData(type, childContext));
}
NiObjectData ReadNiObject(NiObjectSchema niObject,
ReadingContext parentContext)
{
var fields = Inheritance.GetFields(niObject);
var state = Document.ParameterLookup.BuildNiObjectState(niObject);
var interpreter = new Interpreter(state);
var childContext = parentContext.Extend(niObject);
var niObjectData = new Dictionary <string, Data>();
foreach (var fieldSchema in fields)
{
var fieldData = ReadField(fieldSchema, interpreter, childContext);
if (fieldData == null)
{
continue;
}
//state.Set(fieldSchema, Oldvalue.From(fieldData));
niObjectData[fieldSchema.Name] = fieldData;
}
return(new NiObjectData()
{
Name = niObject.Name,
Fields = niObjectData,
Schema = niObject,
});
}
protected override PropertyPtr ReadMember(MetadataToken token, ReadingContext context)
{
return(new PropertyPtr(Header, token, new MetadataRow <uint>()
{
Column1 = context.Reader.ReadIndex(TableStream.GetTable <PropertyDefinition>().IndexSize)
}));
}
private static void BadDataFound(ReadingContext context)
{
int row = context.Row;
long position = context.BytePosition;
Debugger.Break();
}
protected override AssemblyProcessor ReadMember(MetadataToken token, ReadingContext context)
{
return(new AssemblyProcessor(Header, token, new MetadataRow <uint>()
{
Column1 = context.Reader.ReadUInt32(),
}));
}
internal static ImageNetDirectory FromReadingContext(ReadingContext context)
{
var reader = context.Reader;
var directory = new ImageNetDirectory
{
_readingContext = context,
StartOffset = reader.Position,
Cb = reader.ReadUInt32(),
MajorRuntimeVersion = reader.ReadUInt16(),
MinorRuntimeVersion = reader.ReadUInt16(),
MetadataDirectory = ImageDataDirectory.FromReadingContext(context),
Flags = (ImageNetDirectoryFlags)reader.ReadUInt32(),
EntryPointToken = reader.ReadUInt32(),
ResourcesDirectory = ImageDataDirectory.FromReadingContext(context),
StrongNameSignatureDirectory = ImageDataDirectory.FromReadingContext(context),
CodeManagerTableDirectory = ImageDataDirectory.FromReadingContext(context),
VTableFixupsDirectory = ImageDataDirectory.FromReadingContext(context),
ExportAddressTableJumpsDirectory = ImageDataDirectory.FromReadingContext(context),
ManagedNativeHeaderDirectory = ImageDataDirectory.FromReadingContext(context),
};
return(directory);
}
protected override StandAloneSignature ReadMember(MetadataToken token, ReadingContext context)
{
return(new StandAloneSignature(Header, token, new MetadataRow <uint>()
{
Column1 = context.Reader.ReadIndex(TableStream.BlobIndexSize)
}));
}
protected override MetadataRow <uint> ReadRow(ReadingContext context, MetadataToken token)
{
return(new MetadataRow <uint>(token)
{
Column1 = context.Reader.ReadIndex(TableStream.BlobIndexSize)
});
}
BasicData ReadEnum(EnumSchema enumSchema, ReadingContext context)
{
if (Document.Basics.TryGetValue(enumSchema.Storage, out var basicSchema))
{
return(ReadBasicFunc(basicSchema, context));
}
throw new Exception();
}
private ExcelParser(IXLRangeBase range, CsvConfiguration configuration)
{
Workbook = range.Worksheet.Workbook;
this.range = range;
Configuration = configuration ?? new CsvConfiguration(CultureInfo.InvariantCulture);
Context = new ReadingContext(TextReader.Null, Configuration, false);
FieldCount = range.CellsUsed().Max(cell => cell.Address.ColumnNumber) - range.CellsUsed().Min(cell => cell.Address.ColumnNumber) + 1;
}
private void AddError(ParseResult <TRecord> result, string message, ReadingContext context)
{
var error = $"{message} Row number {context.RawRow}, Field \"{(context.CurrentIndex > 0 ? context.HeaderRecord[context.CurrentIndex] : "unknown")}\", Raw record \"{context.RawRecord}\"";
result.Errors.Add(error);
Log.Logger().Error(error);
}
private ExcelParser(ExcelRangeBase range, CsvConfiguration configuration)
{
Workbook = range.Worksheet.Workbook;
this._range = range;
Configuration = configuration ?? new CsvConfiguration(CultureInfo.CurrentCulture);
Context = new ReadingContext(TextReader.Null, Configuration, false);
FieldCount = range.Worksheet.Dimension.Columns;
}
BasicData ReadBitFlags(BitflagsSchema bitflagsSchema, ReadingContext context)
{
if (Document.Basics.TryGetValue(bitflagsSchema.Storage, out var basicSchema))
{
return(ReadBasicFunc(basicSchema, context));
}
throw new Exception();
}
internal static BaseRelocationEntry FromReadingContext(ReadingContext context)
{
long offset = context.Reader.Position;
var value = context.Reader.ReadUInt16();
return new BaseRelocationEntry((BaseRelocationType) (value >> 12), (ushort) (value & 0x0FFF))
{
StartOffset = offset
};
}
/// <summary>
/// Handles cases when invalid data raises <see cref="BadDataException"/>.
/// </summary>
/// <param name="readingContext">CSV parsing context.</param>
/// <exception cref="BadDataException"></exception>
private static void BadDataFound(ReadingContext readingContext)
{
if (readingContext.Field.Contains('\"')) // Allow double quotes in parameter names
{
return;
}
throw new BadDataException(readingContext, $"File contains bad / invalid data: {readingContext.Field}");
}
internal static CustomMetadataStream FromReadingContext(ReadingContext context)
{
long position = context.Reader.Position;
return(new CustomMetadataStream(context.Reader.ReadBytes((int)context.Reader.Length))
{
StartOffset = position
});
}
public static X86MethodBody FromReadingContext(ReadingContext context)
{
var body = new X86MethodBody();
body._readingContext = context.CreateSubContext(context.Reader.StartPosition);
return body;
}
internal abstract void SetReadingContext(ReadingContext readingContext);
internal static MetadataStreamHeader FromReadingContext(ReadingContext context)
{
var reader = context.Reader;
var header = new MetadataStreamHeader
{
_readingContext = context,
StartOffset = reader.Position,
Offset = reader.ReadUInt32(),
Size = reader.ReadUInt32(),
Name = reader.ReadAlignedAsciiString(4),
};
return header;
}
internal static ImageNetDirectory FromReadingContext(ReadingContext context)
{
var reader = context.Reader;
var directory = new ImageNetDirectory
{
_readingContext = context,
StartOffset = reader.Position,
Cb = reader.ReadUInt32(),
MajorRuntimeVersion = reader.ReadUInt16(),
MinorRuntimeVersion = reader.ReadUInt16(),
MetadataDirectory = ImageDataDirectory.FromReadingContext(context),
Flags = (ImageNetDirectoryFlags)reader.ReadUInt32(),
EntryPointToken = reader.ReadUInt32(),
ResourcesDirectory = ImageDataDirectory.FromReadingContext(context),
StrongNameSignatureDirectory = ImageDataDirectory.FromReadingContext(context),
CodeManagerTableDirectory = ImageDataDirectory.FromReadingContext(context),
VTableFixupsDirectory = ImageDataDirectory.FromReadingContext(context),
ExportAddressTableJumpsDirectory = ImageDataDirectory.FromReadingContext(context),
ManagedNativeHeaderDirectory = ImageDataDirectory.FromReadingContext(context),
};
return directory;
}
internal static CustomMetaDataStream FromReadingContext(ReadingContext context)
{
return new CustomMetaDataStream(context.Reader.ReadBytes((int)context.Reader.Length));
}
internal static ImageResourceDataEntry FromReadingContext(ReadingContext context)
{
var reader = context.Reader;
var entry = new ImageResourceDataEntry
{
StartOffset = reader.Position,
OffsetToData = reader.ReadUInt32(),
Size = reader.ReadUInt32(),
CodePage = reader.ReadUInt32(),
Reserved = reader.ReadUInt32(),
};
entry._dataReaderContext = context.CreateSubContext(context.Assembly.RvaToFileOffset(entry.OffsetToData));
return entry;
}
public sealed override void Read(StreamHandler reader)
{
var elements = this.PacketElements;
var ctx = new ReadingContext(reader);
for (int i = 0; i < elements.Length; i++)
s_reading[(int)elements[i]](this, ctx);
}
public MeterValueValue()
{
this.contextField = ReadingContext.SamplePeriodic;
this.formatField = ValueFormat.Raw;
this.measurandField = Measurand.EnergyActiveImportRegister;
this.locationField = Location.Outlet;
this.unitField = UnitOfMeasure.Wh;
}
public static MethodBody FromReadingContext(MethodDefinition method, ReadingContext context)
{
var reader = context.Reader;
var body = new MethodBody(method)
{
StartOffset = reader.Position,
};
var bodyHeader = reader.ReadByte();
uint codeSize;
if ((bodyHeader & 0x3) == 0x3)
{
reader.Position--;
var fatBodyHeader = reader.ReadUInt16();
var headerSize = (fatBodyHeader >> 12) * 4;
var hasSections = (fatBodyHeader & 0x8) == 0x8;
body.InitLocals = (fatBodyHeader & 0x10) == 0x10;
body.MaxStack = reader.ReadUInt16();
codeSize = reader.ReadUInt32();
var localVarSig = reader.ReadUInt32();
if (localVarSig != 0)
{
var header = method.Header;
var tableStream = header.GetStream<TableStream>();
MetadataMember signature;
tableStream.TryResolveMember(new MetadataToken(localVarSig), out signature);
body.Signature = signature as StandAloneSignature;
}
if (hasSections)
{
body._sectionReadingContext = context.CreateSubContext(reader.Position + codeSize);
body._sectionReadingContext.Reader.Align(4);
}
}
else if ((bodyHeader & 0x2) == 0x2)
{
codeSize = (uint)(bodyHeader >> 2);
body.MaxStack = 8;
}
else
throw new ArgumentException("Invalid method body header signature.");
body._msilReadingContext = context.CreateSubContext(reader.Position, (int)codeSize);
return body;
}
public static VTablesDirectory FromReadingContext(ReadingContext readingContext)
{
return new VTablesDirectory()
{
_readingContext = readingContext
};
}
