public static RecordType ReadNextRecordType(
IBinaryReadStream reader)
{
var header = reader.ReadInt32();
return(new RecordType(header));
}
public static GroupListOverlay <T> Factory(
IBinaryReadStream stream,
ReadOnlyMemorySlice <byte> data,
BinaryOverlayFactoryPackage package,
ObjectType objectType,
int offset)
{
List <int> locations = new List <int>();
stream.Position -= package.MetaData.Constants.GroupConstants.HeaderLength;
var groupMeta = stream.GetGroup(package);
var finalPos = stream.Position + groupMeta.TotalLength;
stream.Position += package.MetaData.Constants.GroupConstants.HeaderLength;
// Parse locations
while (stream.Position < finalPos)
{
VariableHeader meta = package.MetaData.Constants.Constants(objectType).VariableMeta(stream.RemainingMemory);
locations.Add(checked ((int)stream.Position - offset));
stream.Position += checked ((int)meta.TotalLength);
}
return(new GroupListOverlay <T>(
locations,
data,
package));
}
public MutagenInterfaceReadStream(
IBinaryReadStream stream,
ParsingBundle metaData,
long offsetReference = 0)
{
_readStream = stream;
this.MetaData = metaData;
this.OffsetReference = offsetReference;
}
public static RecordType GetNextRecordType(
IBinaryReadStream reader,
RecordTypeConverter?recordTypeConverter = null)
{
var header = reader.GetInt32();
var ret = new RecordType(header);
ret = recordTypeConverter.ConvertToStandard(ret);
return(ret);
}
public bool TryGetGroupFrame(IBinaryReadStream stream, out GroupFrame frame, int offset = 0, bool checkIsGroup = true)
{
if (!TryGetGroup(stream, out var meta, offset: offset, checkIsGroup: checkIsGroup))
{
frame = default;
return(false);
}
frame = new GroupFrame(meta, stream.GetSpan(checked ((int)meta.TotalLength)));
return(true);
}
public bool TryReadGroupMemoryFrame(IBinaryReadStream stream, out GroupMemoryFrame frame, bool checkIsGroup = true, bool readSafe = true)
{
if (!TryGetGroup(stream, out var meta, checkIsGroup: checkIsGroup))
{
frame = default;
return(false);
}
frame = new GroupMemoryFrame(meta, stream.ReadMemory(checked ((int)meta.TotalLength), readSafe));
return(true);
}
public bool TryReadSubrecord(IBinaryReadStream stream, out SubrecordHeader meta)
{
if (stream.Remaining < SubConstants.HeaderLength)
{
meta = default;
return(false);
}
meta = ReadSubrecord(stream);
return(true);
}
public bool TryGetSubrecord(IBinaryReadStream stream, RecordType targetType, out SubrecordHeader meta)
{
if (stream.Remaining < SubConstants.HeaderLength)
{
meta = default;
return(false);
}
meta = GetSubrecord(stream);
return(targetType == meta.RecordType);
}
public SubrecordHeader ReadSubrecord(IBinaryReadStream stream, RecordType targetType)
{
var meta = ReadSubrecord(stream);
if (meta.RecordType != targetType)
{
throw new ArgumentException($"Unexpected header type: {meta.RecordType}");
}
return(meta);
}
public bool TryReadSubrecordFrame(IBinaryReadStream stream, RecordType targetType, out SubrecordFrame frame)
{
if (!TryGetSubrecord(stream, targetType, out var meta))
{
frame = default;
return(false);
}
frame = new SubrecordFrame(meta, stream.ReadSpan(meta.TotalLength));
return(true);
}
public static RecordType ReadNextRecordType(
IBinaryReadStream reader,
int lengthLength,
out int contentLength)
{
var ret = ReadNextRecordType(reader);
contentLength = ReadContentLength(reader, lengthLength);
return(ret);
}
public bool TryReadGroup(IBinaryReadStream stream, out GroupHeader header, bool checkIsGroup = true)
{
if (stream.Remaining < GroupConstants.HeaderLength)
{
header = default;
return(false);
}
header = ReadGroup(stream);
return(!checkIsGroup || header.IsGroup);
}
public bool TryReadMod(IBinaryReadStream stream, out ModHeader header)
{
if (stream.Remaining < this.ModHeaderLength)
{
header = default;
return(false);
}
header = new ModHeader(this, stream.ReadSpan(this.ModHeaderLength));
return(true);
}
public bool TryGetGroup(IBinaryReadStream stream, out GroupHeader meta, int offset = 0, bool checkIsGroup = true)
{
if (stream.Remaining < GroupConstants.HeaderLength + offset)
{
meta = default;
return(false);
}
meta = GetGroup(stream, offset);
return(!checkIsGroup || meta.IsGroup);
}
public SubrecordMemoryFrame ReadSubrecordMemoryFrame(IBinaryReadStream stream, RecordType targetType, bool readSafe = false)
{
var meta = GetSubrecord(stream);
if (meta.RecordType != targetType)
{
throw new ArgumentException($"Unexpected header type: {meta.RecordType}");
}
return(new SubrecordMemoryFrame(meta, stream.ReadMemory(meta.TotalLength, readSafe: readSafe)));
}
public bool TryReadSubrecordMemoryFrame(IBinaryReadStream stream, RecordType targetType, out SubrecordMemoryFrame frame, bool readSafe = false)
{
if (!TryGetSubrecord(stream, targetType, out var meta))
{
frame = default;
return(false);
}
frame = new SubrecordMemoryFrame(meta, stream.ReadMemory(meta.TotalLength, readSafe: readSafe));
return(true);
}
public SubrecordFrame ReadSubrecordFrame(IBinaryReadStream stream, RecordType targetType)
{
var meta = GetSubrecord(stream);
if (meta.RecordType != targetType)
{
throw new ArgumentException($"Unexpected header type: {meta.RecordType}");
}
return(new SubrecordFrame(meta, stream.ReadSpan(meta.TotalLength)));
}
public bool TryGetSubrecord(IBinaryReadStream stream, out SubrecordHeader meta, int offset = 0)
{
if (stream.Remaining < SubConstants.HeaderLength + offset)
{
meta = default;
return(false);
}
meta = GetSubrecord(stream, offset);
return(true);
}
public static void FillModTypes(
IBinaryReadStream stream,
ModTypeFillWrapper fill,
BinaryOverlayFactoryPackage package)
{
int? lastParsed = null;
ModHeader headerMeta = stream.GetModHeader(package);
var minimumFinalPos = checked ((int)(stream.Position + headerMeta.TotalLength));
fill(
stream: stream,
finalPos: minimumFinalPos,
offset: 0,
type: headerMeta.RecordType,
lastParsed: lastParsed,
recordTypeConverter: null);
stream.Position = (int)headerMeta.TotalLength;
while (!stream.Complete)
{
GroupHeader groupMeta = stream.GetGroup(package);
if (!groupMeta.IsGroup)
{
throw new ArgumentException("Did not see GRUP header as expected.");
}
if (groupMeta.ContentLength == 0)
{
stream.Position += groupMeta.TotalLength;
continue;
}
minimumFinalPos = checked ((int)(stream.Position + groupMeta.TotalLength));
var parsed = fill(
stream: stream,
finalPos: minimumFinalPos,
offset: 0,
type: groupMeta.ContainedRecordType,
lastParsed: lastParsed,
recordTypeConverter: null);
if (!parsed.KeepParsing)
{
break;
}
if (!parsed.KeepParsing)
{
break;
}
if (minimumFinalPos > stream.Position)
{
stream.Position = checked ((int)minimumFinalPos);
}
lastParsed = parsed.ParsedIndex;
}
}
private static void Read(PexFile file, IBinaryReadStream br)
{
var magic = br.ReadUInt32();
if (magic != PexMagic)
{
throw new InvalidDataException($"File does not have fast code! Magic does not match {PexMagic:x8} is {magic:x8}");
}
file.MajorVersion = br.ReadUInt8();
file.MinorVersion = br.ReadUInt8();
file.GameId = br.ReadUInt16();
file.CompilationTime = br.ReadUInt64().ToDateTime();
file.SourceFileName = br.ReadPrependedString(2);
file.Username = br.ReadPrependedString(2);
file.MachineName = br.ReadPrependedString(2);
var stringsCount = br.ReadUInt16();
var bundle = new PexParseMeta(
file._gameCategory,
br,
new Dictionary <ushort, string>());
for (var i = 0; i < stringsCount; i++)
{
bundle.Strings.Add((ushort)i, br.ReadPrependedString(2));
}
var hasDebugInfo = bundle.Reader.ReadUInt8() == 1;
if (hasDebugInfo)
{
file.DebugInfo = Mutagen.Bethesda.Pex.DebugInfo.Create(bundle);
}
var userFlagCount = br.ReadUInt16();
for (var i = 0; i < userFlagCount; i++)
{
var str = bundle.ReadString();
file.UserFlags[br.ReadUInt8()] = str;
}
var objectCount = br.ReadUInt16();
for (var i = 0; i < objectCount; i++)
{
var pexObject = PexObject.Create(bundle);
file.Objects.Add(pexObject);
}
}
public VariableHeader ReadNextRecordVariableMeta(IBinaryReadStream stream)
{
RecordType rec = new RecordType(stream.GetInt32());
if (rec == Mutagen.Bethesda.Internals.Constants.Group)
{
return(this.GroupConstants.VariableMeta(stream.ReadSpan(this.GroupConstants.HeaderLength)));
}
else
{
return(this.MajorConstants.VariableMeta(stream.ReadSpan(this.MajorConstants.HeaderLength)));
}
}
public static GenderedItem <TItem> Parse <TItem>(
IBinaryReadStream reader,
BinarySubParseDelegate <IBinaryReadStream, TItem> transl)
{
if (!transl(reader, out var male))
{
throw new ArgumentException();
}
if (!transl(reader, out var female))
{
throw new ArgumentException();
}
return(new GenderedItem <TItem>(male, female));
}
public static bool TryParseRecordType(
IBinaryReadStream reader,
int lengthLength,
RecordType expectedHeader)
{
if (TryParse(
reader,
expectedHeader,
out var contentLength,
lengthLength))
{
return(true);
}
return(false);
}
public static long Parse(
IBinaryReadStream reader,
RecordType expectedHeader,
int lengthLength)
{
if (!TryParse(
reader,
expectedHeader,
out var contentLength,
lengthLength))
{
throw new ArgumentException($"Expected header was not read in: {expectedHeader}");
}
return(contentLength);
}
public bool TryReadSubrecord(IBinaryReadStream stream, RecordType targetType, out SubrecordHeader meta)
{
if (stream.Remaining < SubConstants.HeaderLength)
{
meta = default;
return(false);
}
meta = ReadSubrecord(stream);
if (meta.RecordType != targetType)
{
stream.Position -= meta.HeaderLength;
return(false);
}
return(true);
}
public static bool TryGetRecordType(
IBinaryReadStream reader,
RecordType expectedHeader)
{
if (reader.Remaining < Constants.HeaderLength)
{
return(false);
}
var header = reader.GetInt32();
if (expectedHeader.TypeInt != header)
{
return(false);
}
return(true);
}
public static GroupMajorRecordCacheWrapper <T> Factory(
IBinaryReadStream stream,
ReadOnlyMemorySlice <byte> data,
BinaryOverlayFactoryPackage package,
int offset)
{
Dictionary <FormKey, int> locationDict = new Dictionary <FormKey, int>();
stream.Position -= package.MetaData.Constants.GroupConstants.HeaderLength;
var groupMeta = stream.GetGroup(package.MetaData);
var finalPos = stream.Position + groupMeta.TotalLength;
stream.Position += package.MetaData.Constants.GroupConstants.HeaderLength;
// Parse MajorRecord locations
ObjectType?lastParsed = default;
while (stream.Position < finalPos)
{
VariableHeader varMeta = package.MetaData.Constants.NextRecordVariableMeta(stream.RemainingMemory);
if (varMeta.IsGroup)
{
if (lastParsed != ObjectType.Record)
{
throw new DataMisalignedException("Unexpected Group encountered which was not after a major record: " + GroupRecordTypeGetter <T> .GRUP_RECORD_TYPE);
}
stream.Position += checked ((int)varMeta.TotalLength);
lastParsed = ObjectType.Group;
}
else
{
MajorRecordHeader majorMeta = package.MetaData.Constants.MajorRecord(stream.RemainingMemory);
if (majorMeta.RecordType != GroupRecordTypeGetter <T> .GRUP_RECORD_TYPE)
{
throw new DataMisalignedException("Unexpected type encountered when parsing MajorRecord locations: " + majorMeta.RecordType);
}
var formKey = FormKey.Factory(package.MetaData.MasterReferences !, majorMeta.FormID.Raw);
locationDict.Add(formKey, checked ((int)(stream.Position - offset)));
stream.Position += checked ((int)majorMeta.TotalLength);
lastParsed = ObjectType.Record;
}
}
return(new GroupMajorRecordCacheWrapper <T>(
locationDict,
data,
package));
}
public static bool TryParse(
IBinaryReadStream reader,
RecordType expectedHeader,
out long contentLength,
long lengthLength)
{
if (TryGet(
reader,
expectedHeader,
out contentLength,
lengthLength))
{
reader.Position += Constants.HeaderLength + lengthLength;
return(true);
}
return(false);
}
public static ReadOnlyMemorySlice <byte> LockExtractMemory(IBinaryReadStream stream, long min, long max)
{
lock (stream)
{
stream.Position = min;
var size = checked ((int)(max - min));
if (stream.IsPersistantBacking)
{
return(stream.ReadMemory(size));
}
else
{
byte[] data = new byte[size];
stream.Read(data);
return(data);
}
}
}
protected static int ReadContentLength(
IBinaryReadStream reader,
int lengthLength)
{
switch (lengthLength)
{
case 1:
return(reader.ReadUInt8());
case 2:
return(reader.ReadUInt16());
case 4:
return((int)reader.ReadUInt32());
default:
throw new NotImplementedException();
}
}
