internal override uint BinarySize()
{
uint local_count = (uint)locals.Length;
long body_size = LEB128.SizeOf(local_count) + (uint)locals.Select(x => (long)x.BinarySize()).Sum() + code.Length;
return(LEB128.SizeOf((uint)body_size) + LEB128.SizeOf(local_count) + (uint)locals.Select(x => (long)x.BinarySize()).Sum() + (uint)code.Length);
}
public FunctionBody(BinaryReader reader)
{
// Bit of a hack, but we use positions in this method, so we need to ensure it works
if (!reader.BaseStream.CanSeek)
{
throw new NotSupportedException("Stream passed does not support seeking.");
}
uint body_size = LEB128.ReadUInt32(reader);
var before_pos = reader.BaseStream.Position;
uint local_count = LEB128.ReadUInt32(reader);
if (local_count > int.MaxValue)
{
throw new NotImplementedException($"Count larger than {int.MaxValue} bytes not supported.");
}
locals = new LocalEntry[local_count];
for (uint i = 0; i < local_count; i++)
{
locals[i] = new LocalEntry(reader);
}
var after_pos = reader.BaseStream.Position;
code = reader.ReadBytes((int)(body_size - (after_pos - before_pos)));
if (code[code.Length - 1] != (byte)WebAssemblyOpcode.END)
{
throw new Exception($"File is invalid. Expected byte {WebAssemblyOpcode.END}, received {code[code.Length-1]}.");
}
}
internal override void SaveAsWASM(BinaryWriter writer)
{
LEB128.WriteUInt32(writer, memory_index);
offset.SaveAsWASM(writer);
LEB128.WriteUInt32(writer, (uint)data.Length);
writer.Write(data);
}
internal override uint BinarySize()
{
var module_len = Encoding.UTF8.GetByteCount(module_str);
var field_len = Encoding.UTF8.GetByteCount(field_str);
uint size = LEB128.SizeOf(module_len) + LEB128.SizeOf(field_len) + (uint)module_len + (uint)field_len + sizeof(byte);
switch (kind)
{
case WebAssemblyExternalKind.Function:
size += LEB128.SizeOf((uint)type);
break;
case WebAssemblyExternalKind.Table:
size += ((TableType)type).BinarySize();
break;
case WebAssemblyExternalKind.Memory:
size += ((MemoryType)type).BinarySize();
break;
case WebAssemblyExternalKind.Global:
size += ((GlobalType)type).BinarySize();
break;
}
return(size);
}
internal override void SaveAsWASM(BinaryWriter writer)
{
var module = Encoding.UTF8.GetBytes(module_str);
var field = Encoding.UTF8.GetBytes(field_str);
LEB128.WriteUInt32(writer, (uint)module.Length);
writer.Write(module);
LEB128.WriteUInt32(writer, (uint)field.Length);
writer.Write(field);
writer.Write((byte)kind);
switch (kind)
{
case WebAssemblyExternalKind.Function:
LEB128.WriteUInt32(writer, (uint)type);
break;
case WebAssemblyExternalKind.Table:
((TableType)type).SaveAsWASM(writer);
break;
case WebAssemblyExternalKind.Memory:
((MemoryType)type).SaveAsWASM(writer);
break;
case WebAssemblyExternalKind.Global:
((GlobalType)type).SaveAsWASM(writer);
break;
}
}
internal override void SaveAsWASM(BinaryWriter writer)
{
base.SaveAsWASM(writer);
LEB128.WriteUInt32(writer, (uint)entries.Length);
foreach (var entry in entries)
{
entry.SaveAsWASM(writer);
}
}
internal override void SaveAsWASM(BinaryWriter writer)
{
LEB128.WriteUInt7(writer, (byte)(maximum != null ? 1 : 0));
LEB128.WriteUInt32(writer, initial);
if (maximum != null)
{
LEB128.WriteUInt32(writer, (uint)maximum);
}
}
internal override void SaveAsWASM(BinaryWriter writer)
{
var field = Encoding.UTF8.GetBytes(field_str);
LEB128.WriteUInt32(writer, (uint)field.Length);
writer.Write(field);
writer.Write((byte)kind);
LEB128.WriteUInt32(writer, index);
}
private static bool LoadSprites(ChunkReader chunkIO, ChunkId idOuter, Wad2 wad, ref Dictionary <long, WadSprite> outSprites)
{
if (idOuter != Wad2Chunks.Sprites)
{
return(false);
}
var sprites = new Dictionary <long, WadSprite>();
long obsoleteIndex = 0; // Move this into each chunk once we got rid of old style *.wad2 files.
chunkIO.ReadChunks((id, chunkSize) =>
{
if (id != Wad2Chunks.Sprite)
{
return(false);
}
int width = LEB128.ReadInt(chunkIO.Raw);
int height = LEB128.ReadInt(chunkIO.Raw);
byte[] imageData = null;
RectangleInt2 rect = new RectangleInt2();
chunkIO.ReadChunks((id2, chunkSize2) =>
{
if (id2 == Wad2Chunks.SpriteIndex)
{
obsoleteIndex = chunkIO.ReadChunkLong(chunkSize2);
}
else if (id2 == Wad2Chunks.SpriteData)
{
imageData = chunkIO.ReadChunkArrayOfBytes(chunkSize2);
}
else if (id2 == Wad2Chunks.SpriteSides)
{
rect.X0 = chunkIO.Raw.ReadInt32();
rect.Y0 = chunkIO.Raw.ReadInt32();
rect.X1 = chunkIO.Raw.ReadInt32();
rect.Y1 = chunkIO.Raw.ReadInt32();
}
else
{
return(false);
}
return(true);
});
sprites.Add(obsoleteIndex++, new WadSprite {
Texture = new WadTexture(ImageC.FromByteArray(imageData, width, height)),
Alignment = rect
})
;
return(true);
});
outSprites = sprites;
return(true);
}
internal override void SaveAsWASM(BinaryWriter writer)
{
LEB128.WriteUInt32(writer, table_index);
offset.SaveAsWASM(writer);
LEB128.WriteUInt32(writer, (uint)function_index.Length);
foreach (var elem in function_index)
{
LEB128.WriteUInt32(writer, elem);
}
}
internal override void SaveAsWASM(BinaryWriter writer)
{
base.SaveAsWASM(writer);
byte[] name_bytes = Encoding.UTF8.GetBytes(name);
LEB128.WriteUInt32(writer, (uint)name_bytes.Length);
writer.Write(name_bytes);
writer.Write(payload_data);
}
public TableType(BinaryReader reader)
{
sbyte type = LEB128.ReadInt7(reader);
if (type != (int)WebAssemblyType.anyfunc)
{
throw new Exception($"File is invalid. Expected byte '{WebAssemblyType.anyfunc}', received '{type}'.");
}
element_type = WebAssemblyType.anyfunc;
limits = new ResizeLimit(reader);
}
public DataSegment(BinaryReader reader)
{
memory_index = LEB128.ReadUInt32(reader);
offset = new InitExpr(reader);
uint count = LEB128.ReadUInt32(reader);
if (count > int.MaxValue)
{
throw new NotImplementedException($"Count larger than {int.MaxValue} bytes not supported.");
}
data = reader.ReadBytes((int)count);
}
public ElementSegment(BinaryReader reader)
{
table_index = LEB128.ReadUInt32(reader);
offset = new InitExpr(reader);
uint num_elem = LEB128.ReadUInt32(reader);
function_index = new uint[num_elem];
for (uint i = 0; i < num_elem; i++)
{
function_index[i] = LEB128.ReadUInt32(reader);
}
}
public LocalEntry(BinaryReader reader)
{
count = LEB128.ReadUInt32(reader);
var tmp_type = reader.ReadByte();
if (!Enum.IsDefined(typeof(WebAssemblyType), tmp_type))
{
throw new Exception($"File is invalid. Expected WebAssemblyType, received '{tmp_type}'.");
}
type = (WebAssemblyType)tmp_type;
}
internal override void SaveAsWASM(BinaryWriter writer)
{
uint local_count = (uint)locals.Length;
uint body_size = LEB128.SizeOf(local_count) + (uint)locals.Select(x => (long)x.BinarySize()).Sum() + (uint)code.Length;
LEB128.WriteUInt32(writer, body_size);
LEB128.WriteUInt32(writer, local_count);
foreach (var local in locals)
{
local.SaveAsWASM(writer);
}
writer.Write(code);
}
public void SizeOfTest()
{
// sizeof(Int7) is always 1 byte
Assert.AreEqual(LEB128.SizeOf((byte)0), 1u);
Assert.AreEqual(LEB128.SizeOf((byte)255), 1u);
Assert.AreEqual(LEB128.SizeOf((sbyte)-1), 1u);
Assert.AreEqual(LEB128.SizeOf((sbyte)127), 1u);
Assert.AreEqual(LEB128.SizeOf(0), 1u);
Assert.AreEqual(LEB128.SizeOf(0u), 1u);
Assert.AreEqual(LEB128.SizeOf(int.MaxValue), 5u);
Assert.AreEqual(LEB128.SizeOf(int.MinValue), 5u);
Assert.AreEqual(LEB128.SizeOf(uint.MaxValue), 5u);
}
public CustomSection(string name, byte[] payload_data) : base(WebAssemblyModuleID.Custom)
{
if (payload_data.LongLength > int.MaxValue)
{
throw new NotImplementedException($"Payload longer than {int.MaxValue} bytes not supported.");
}
this.name = name;
this.payload_data = payload_data;
uint name_bytes = (uint)Encoding.UTF8.GetByteCount(name);
payload_len = LEB128.SizeOf(name_bytes) + name_bytes + (uint)payload_data.Length;
}
public ImportEntry(BinaryReader reader)
{
uint module_len = LEB128.ReadUInt32(reader);
if (module_len > int.MaxValue)
{
throw new NotImplementedException($"String longer than {int.MaxValue} bytes not supported.");
}
module_str = Encoding.UTF8.GetString(reader.ReadBytes((int)module_len));
uint field_len = LEB128.ReadUInt32(reader);
if (field_len > int.MaxValue)
{
throw new NotImplementedException($"String longer than {int.MaxValue} bytes not supported.");
}
field_str = Encoding.UTF8.GetString(reader.ReadBytes((int)field_len));
byte tmp_kind = reader.ReadByte();
if (!Enum.IsDefined(typeof(WebAssemblyExternalKind), tmp_kind))
{
throw new Exception($"File is invalid. Expected 0, 1, 2, or 3, received '{tmp_kind}'.");
}
kind = (WebAssemblyExternalKind)tmp_kind;
switch (kind)
{
case WebAssemblyExternalKind.Function:
type = LEB128.ReadUInt32(reader);
break;
case WebAssemblyExternalKind.Table:
var table_tmp = new TableType(reader);
type = table_tmp;
break;
case WebAssemblyExternalKind.Memory:
var memory_tmp = new MemoryType(reader);
type = memory_tmp;
break;
case WebAssemblyExternalKind.Global:
var global_tmp = new GlobalType(reader);
type = global_tmp;
break;
}
}
private static void WriteTextures(ChunkWriter chunkIO, List <WadTexture> textureTable)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.Textures, () =>
{
foreach (var texture in textureTable)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.Texture, () =>
{
LEB128.Write(chunkIO.Raw, texture.Image.Width);
LEB128.Write(chunkIO.Raw, texture.Image.Height);
chunkIO.WriteChunkArrayOfBytes(Wad2Chunks.TextureData, texture.Image.ToByteArray());
});
}
});
}
public CustomSection(BinaryReader reader) : base(reader)
{
uint name_len = LEB128.ReadUInt32(reader);
name = Encoding.UTF8.GetString(reader.ReadBytes((int)name_len));
uint payload_size = payload_len - (LEB128.SizeOf(name_len) + name_len);
if (payload_size > int.MaxValue)
{
throw new NotImplementedException($"Payload longer than {int.MaxValue} bytes not supported.");
}
payload_data = reader.ReadBytes((int)payload_size);
}
public CodeSection(BinaryReader reader) : base(reader)
{
uint count = LEB128.ReadUInt32(reader);
if (count > int.MaxValue)
{
throw new NotImplementedException($"Count larger than {int.MaxValue} bytes not supported.");
}
bodies = new FunctionBody[count];
for (uint i = 0; i < count; i++)
{
bodies[i] = new FunctionBody(reader);
}
}
public DataSection(BinaryReader reader) : base(reader)
{
uint count = LEB128.ReadUInt32(reader);
if (count > int.MaxValue)
{
throw new NotImplementedException($"Count larger than {int.MaxValue} bytes not supported.");
}
entries = new DataSegment[count];
for (uint i = 0; i < count; i++)
{
entries[i] = new DataSegment(reader);
}
}
public GlobalSection(BinaryReader reader) : base(reader)
{
uint count = LEB128.ReadUInt32(reader);
if (count > int.MaxValue)
{
throw new NotImplementedException($"Count larger than {int.MaxValue} bytes not supported.");
}
globals = new GlobalVariable[count];
for (uint i = 0; i < count; i++)
{
globals[i] = new GlobalVariable(reader);
}
}
public void ReadTest(MemoryStream stream)
{
BinaryReader reader = new BinaryReader(stream);
Assert.AreEqual(LEB128.ReadUInt32(reader), 0xFF00FF00u);
Assert.AreEqual(LEB128.ReadUInt32(reader), 0xAABBAAu);
Assert.AreEqual(LEB128.ReadUInt32(reader), 0xCCu);
Assert.AreEqual(LEB128.ReadUInt7(reader), 0x11u);
Assert.AreEqual(LEB128.ReadUInt7(reader), 0x7Fu);
Assert.AreEqual(LEB128.ReadInt32(reader), 0x7F00FF00);
Assert.AreEqual(LEB128.ReadInt32(reader), 0xAABBAA);
Assert.AreEqual(LEB128.ReadInt32(reader), 0xCC);
Assert.AreEqual(LEB128.ReadInt32(reader), -1);
Assert.AreEqual(LEB128.ReadInt7(reader), 0x11);
Assert.AreEqual(LEB128.ReadInt7(reader), -1);
}
//public static TimeSpan ReadDiffTimeMcsAsTimeSpan(Stream stream)
//{
// var microseconds = ReadDiffTimeMcs(stream);
// var ticks = (long)microseconds * 10;
// return new TimeSpan( ticks );
//}
public static string ReadString(Stream stream)
{
var sz = LEB128.ReadULEB128(stream);
const long MAX_STR = 128 * 1024;
if (sz > MAX_STR)
{
throw new FinancialException(StringConsts.SECDB_STREAM_CORRUPTED_ERROR + "ReadString(): sz={0}>max={1}".Args(sz, MAX_STR));
}
var buf = new byte[sz];
readFromStream(stream, buf, (int)sz);
return(Encoding.UTF8.GetString(buf));
}
public void WriteTest(MemoryStream stream)
{
BinaryWriter writer = new BinaryWriter(stream);
LEB128.WriteUInt32(writer, 0xFF00FF00);
LEB128.WriteUInt32(writer, 0xAABBAA);
LEB128.WriteUInt32(writer, 0xCC);
LEB128.WriteUInt7(writer, 0x11);
LEB128.WriteUInt7(writer, 0x7F);
LEB128.WriteInt32(writer, 0x7F00FF00);
LEB128.WriteInt32(writer, 0xAABBAA);
LEB128.WriteInt32(writer, 0xCC);
LEB128.WriteInt32(writer, -1);
LEB128.WriteInt7(writer, 0x11);
LEB128.WriteInt7(writer, -1);
}
private static bool LoadTextures(ChunkReader chunkIO, ChunkId idOuter, Wad2 wad, ref Dictionary <long, WadTexture> outTextures)
{
if (idOuter != Wad2Chunks.Textures)
{
return(false);
}
Dictionary <long, WadTexture> textures = new Dictionary <long, WadTexture>();
long obsoleteIndex = 0; // Move this into each chunk once we got rid of old style *.wad2 files.
chunkIO.ReadChunks((id, chunkSize) =>
{
if (id != Wad2Chunks.Texture)
{
return(false);
}
var width = LEB128.ReadInt(chunkIO.Raw);
var height = LEB128.ReadInt(chunkIO.Raw);
byte[] textureData = null;
chunkIO.ReadChunks((id2, chunkSize2) =>
{
if (id2 == Wad2Chunks.TextureIndex)
{
obsoleteIndex = chunkIO.ReadChunkLong(chunkSize2);
}
if (id2 == Wad2Chunks.TextureData)
{
textureData = chunkIO.ReadChunkArrayOfBytes(chunkSize2);
}
else
{
return(false);
}
return(true);
});
var texture = ImageC.FromByteArray(textureData, width, height);
texture.ReplaceColor(new ColorC(255, 0, 255, 255), new ColorC(0, 0, 0, 0));
textures.Add(obsoleteIndex++, new WadTexture(texture));
return(true);
});
outTextures = textures;
return(true);
}
private static void WriteSpriteSequences(ChunkWriter chunkIO, Wad2 wad, List <WadSprite> spriteTable)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.SpriteSequences, () =>
{
foreach (var sequence in wad.SpriteSequences.Values)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.SpriteSequence, () =>
{
LEB128.Write(chunkIO.Raw, sequence.Id.TypeId);
foreach (var spr in sequence.Sprites)
{
chunkIO.WriteChunkInt(Wad2Chunks.SpriteSequenceSpriteIndex, spriteTable.IndexOf(spr));
}
});
}
});
}
private static void WriteStatics(ChunkWriter chunkIO, Wad2 wad, List <WadTexture> textureTable)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.Statics, () =>
{
foreach (var staticMesh in wad.Statics)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.Static, () =>
{
var s = staticMesh.Value;
LEB128.Write(chunkIO.Raw, s.Id.TypeId);
LEB128.Write(chunkIO.Raw, s.Flags);
LEB128.Write(chunkIO.Raw, (short)s.LightingType);
WriteMesh(chunkIO, s.Mesh, textureTable);
chunkIO.WriteChunkInt(Wad2Chunks.StaticAmbientLight, s.AmbientLight);
foreach (var light in s.Lights)
{
chunkIO.WriteChunkWithChildren(Wad2Chunks.StaticLight, () =>
{
chunkIO.WriteChunkVector3(Wad2Chunks.StaticLightPosition, light.Position);
chunkIO.WriteChunkFloat(Wad2Chunks.StaticLightRadius, light.Radius);
chunkIO.WriteChunkFloat(Wad2Chunks.StaticLightIntensity, light.Intensity);
});
}
chunkIO.WriteChunkWithChildren(Wad2Chunks.StaticVisibilityBox, () =>
{
chunkIO.WriteChunkVector3(Wad2Chunks.MeshBoundingBoxMin, s.VisibilityBox.Minimum);
chunkIO.WriteChunkVector3(Wad2Chunks.MeshBoundingBoxMax, s.VisibilityBox.Maximum);
});
chunkIO.WriteChunkWithChildren(Wad2Chunks.StaticCollisionBox, () =>
{
chunkIO.WriteChunkVector3(Wad2Chunks.MeshBoundingBoxMin, s.CollisionBox.Minimum);
chunkIO.WriteChunkVector3(Wad2Chunks.MeshBoundingBoxMax, s.CollisionBox.Maximum);
});
//chunkIO.WriteChunkString(Wad2Chunks.StaticName, s.Name);
});
}
});
}
