void ReadString(IO.EndianReader s)
{
if (UseDirectEncoding)
{
}
else
{
String = s.ReadString(IsUnicode ? kUnicodeEncoding : kAnsiEncoding);
}
}
public string ReadName(int nameOffset)
{
if (NameData == null || nameOffset >= NameData.Length)
{
throw new InvalidOperationException(nameOffset.ToString("X8"));
}
NameDataReader.Seek(nameOffset);
return(NameDataReader.ReadString(Memory.Strings.StringStorage.CStringAscii));
}
/// <summary>Read the string values from a stream</summary>
/// <param name="s"></param>
public void ReadStrings(IO.EndianReader s)
{
Contract.Requires(s != null);
if (ioStringLengths == null)
{
for (int x = 0; x < mPool.Count; x++)
{
AddFromRead(x, s.ReadString(mEncoding));
}
}
else
{
for (int x = 0; x < Count; x++)
{
AddFromRead(x, s.ReadString(mEncoding, ioStringLengths[x]));
}
ioStringLengths = null;
}
}
public static void Assert(IO.EndianReader s, string expected, Memory.Strings.StringStorage storage)
{
Contract.Requires(s != null);
Contract.Requires(!string.IsNullOrEmpty(expected));
string signature = s.ReadString(storage, expected.Length);
if (signature != expected)
{
throw new SignatureMismatchException(s.BaseStream,
expected, signature);
}
}
public static bool VerifyIsPkg(IO.EndianReader s)
{
Contract.Requires <InvalidOperationException>(s.BaseStream.CanRead);
Contract.Requires <InvalidOperationException>(s.BaseStream.CanSeek);
var base_stream = s.BaseStream;
if ((base_stream.Length - base_stream.Position) < kHeaderLength)
{
return(false);
}
string sig = s.ReadString(Memory.Strings.StringStorage.AsciiString);
ulong version = s.ReadUInt64();
long file_entry_count = s.ReadInt64();
base_stream.Seek(-kHeaderLength, SeekOrigin.Current);
return(sig == kSignature &&
version < (ulong)CaPackageVersion.kNumberOf &&
file_entry_count >= kMinFileEntryCount);
}
void ReadFileNamesChunk(IO.EndianStream s)
{
var eraUtil = s.Owner as EraFileUtil;
var filenames_chunk = mFiles[0];
if (eraUtil != null &&
!eraUtil.Options.Test(EraFileUtilOptions.SkipVerification))
{
ValidateAdler32(filenames_chunk, s);
ValidateHashes(filenames_chunk, s);
}
filenames_chunk.FileName = kFileNamesTableName;
byte[] filenames_buffer = filenames_chunk.GetBuffer(s);
using (var ms = new System.IO.MemoryStream(filenames_buffer, false))
using (var er = new IO.EndianReader(ms, s.ByteOrder))
{
for (int x = FileChunksFirstIndex; x < mFiles.Count; x++)
{
var file = mFiles[x];
if (file.FileNameOffset != er.BaseStream.Position)
{
throw new System.IO.InvalidDataException(string.Format(
"#{0} {1} has bad filename offset {2} != {3}",
FileIndexToListingIndex(x),
file.EntryId.ToString("X16"),
file.FileNameOffset.ToString("X8"),
er.BaseStream.Position.ToString("X8")
));
}
file.FileName = er.ReadString(Memory.Strings.StringStorage.CStringAscii);
}
}
}
public void Read(IO.EndianReader s)
{
switch (Type)
{
case XmbVariantType.Int: s.Read(out Int); break;
case XmbVariantType.Single: s.Read(out Single); break;
case XmbVariantType.Double: s.Read(out Double); break;
case XmbVariantType.String:
String = s.ReadString(IsUnicode ? kUnicodeEncoding : kAnsiEncoding);
break;
case XmbVariantType.Vector:
if (VectorLength >= 1)
{
s.Read(out Vector4d.X);
}
if (VectorLength >= 2)
{
s.Read(out Vector4d.Y);
}
if (VectorLength >= 3)
{
s.Read(out Vector4d.Z);
}
if (VectorLength >= 4)
{
s.Read(out Vector4d.W);
}
break;
default: throw new KSoft.Debug.UnreachableException(Type.ToString());
}
}
internal void ReadLanguageStrings(IO.EndianReader buffer, uint langBitmask = uint.MaxValue)
{
Contract.Assert(LanguageRegistry.NumberOfLanguages <= Bits.kInt32BitCount,
nameof(langBitmask) + " is too small to actually be a language bitvector");
Contract.Assert(mLanguageOffsets != null);
for (int x = 0; x < mLanguageOffsets.Length; x++)
{
int offset = mLanguageOffsets[x];
if (offset.IsNone())
{
continue;
}
else if (!Bitwise.Flags.Test(langBitmask, 1U << x))
{
continue;
}
buffer.Seek(offset);
mLanguageStrings[x] = buffer.ReadString(Memory.Strings.StringStorage.CStringUtf8);
}
LanguageOffsetsDispose();
}
