internal static (object, uint) Read(IDefinitionReader reader)
{
var parameterCount = reader.ReadValueU8();
var type = reader.ReadReference <ClassDefinition>();
return(new Constructor(parameterCount, type), 9);
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var enumeration = reader.ReadReference <EnumerationDefinition>();
var enumeral = reader.ReadReference <EnumeralDefinition>();
return(new EnumConst(enumeration, enumeral), 16);
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var type = reader.ReadReference <ClassDefinition>();
var unknown = reader.ReadValueU8();
return(new DynamicCast(type, unknown), 9);
}
public static (object, uint) Read(IDefinitionReader reader)
{
var targetOffset = reader.ReadValueS16();
targetOffset += 1 + 2; // make relative to the instruction
return(targetOffset, 2);
}
// All of these readers are completely temporary while research is on-going.
// TODO(gibbed): concrete types for all of this.
internal static (Instruction, uint) Read(IDefinitionReader reader)
{
uint size = 0;
var op = (Opcode)reader.ReadValueU8();
size++;
if (_Lookup.TryGetValue(op, out var handler) == false)
{
throw new FormatException($"no handler for {op}");
}
Instruction instance;
instance.Op = op;
if (handler.read == null)
{
instance.Argument = null;
}
else
{
var(argument, argumentSize) = handler.read(reader);
instance.Argument = argument;
size += argumentSize;
}
instance.LoadInfo = default;
return(instance, size);
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var type = reader.ReadReference <NativeDefinition>();
var size = reader.ReadValueU8();
return(new EnumCast(type, size), 9);
}
public static (object, uint) Read(IDefinitionReader reader)
{
var bytes = reader.ReadBytes();
var unknown = reader.ReadValueU8();
return((bytes, unknown), (uint)bytes.Length + 5);
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var type = reader.ReadReference <NativeDefinition>();
var firstCaseOffset = reader.ReadValueS16();
firstCaseOffset += 1 + 8 + 2; // make relative to the instruction
return(new Switch(type, firstCaseOffset), 10);
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var nextOffset = reader.ReadValueS16();
var sourceLine = reader.ReadValueU16();
var function = reader.ReadReference <FunctionDefinition>();
nextOffset += 1 + 2; // make relative to the instruction
return(new FinalFunc_Offset(nextOffset, sourceLine, function), 12);
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var jumpOffset = reader.ReadValueS16();
var sourceLine = reader.ReadValueU16();
var function = reader.ReadName();
jumpOffset += 1 + 2; // make relative to the instruction
return(new VirtualFunc(jumpOffset, sourceLine, function), 12);
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
this.Value = reader.ReadValueS64();
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
this.Type = reader.ReadReference <NativeDefinition>();
this.Unknown28 = reader.ReadValueU8();
}
internal static (object, uint) Read(IDefinitionReader reader)
{
var falseOffset = reader.ReadValueS16();
falseOffset += 1 + 2; // make relative to the instruction
var trueOffset = reader.ReadValueS16();
trueOffset += 1 + 2 + 2; // make relative to the instruction
return(new SwitchLabel(falseOffset, trueOffset), 4);
}
public static (object, uint) Read(IDefinitionReader reader)
{
var unknown0 = reader.ReadValueU16();
var unknown1 = reader.ReadValueU32();
var unknown2 = reader.ReadValueU16();
var unknown3 = reader.ReadValueU16();
var unknown4 = reader.ReadValueU8();
var unknown5 = reader.ReadValueU64();
return((unknown0, unknown1, unknown2, unknown3, unknown4, unknown5), 19);
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
this.Id = reader.ReadValueU32();
this.PathHash = reader.ReadValueU64();
this.Path = reader.ReadStringU16();
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var nativeType = (NativeType)reader.ReadValueU8();
this.NativeType = nativeType;
this.BaseType = HasBaseType(NativeType) == true?reader.ReadReference() : null;
this.ArraySize = nativeType == NativeType.StaticArray ? reader.ReadValueU32() : 0;
}
internal static Instruction[] Read(IDefinitionReader reader, uint count)
{
var result = new List <Instruction>();
for (uint i = 0; i < count;)
{
InstructionLoadInfo loadInfo;
loadInfo.BasePosition = reader.Position;
loadInfo.Offset = i;
var(instruction, size) = InstructionHandlers.Read(reader);
instruction.LoadInfo = loadInfo;
result.Add(instruction);
i += size;
}
return(result.ToArray());
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
// TODO(gibbed): maybe visibility?
var unknown2A = reader.ReadValueU8();
var size = reader.ReadValueU8();
var enumerals = reader.ReadReferences <EnumeralDefinition>();
var unknown29 = reader.ReadValueB8();
this.Unknown2A = unknown2A;
this.Size = size;
this.Enumerals.Clear();
this.Enumerals.AddRange(enumerals);
this.Unknown29 = unknown29;
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var type = reader.ReadReference <NativeDefinition>();
var flags = (LocalFlags)reader.ReadValueU8();
var unknownFlags = flags & ~KnownFlags;
if (unknownFlags != LocalFlags.None)
{
throw new FormatException();
}
this.Type = type;
this.Flags = flags;
}
internal static Instruction[] Read(IDefinitionReader reader, uint size)
{
var pairs = new List <(Instruction instruction, uint instructionOffset)>();
var offsetsToIndices = new Dictionary <long, int>();
uint instructionOffset;
int index;
for (instructionOffset = 0, index = 0; instructionOffset < size; index++)
{
offsetsToIndices[instructionOffset] = index;
var loadPosition = reader.Position;
var(instruction, instructionSize) = Read(reader);
instruction.LoadPosition = loadPosition;
pairs.Add((instruction, instructionOffset));
instructionOffset += instructionSize;
}
FixupJumps(pairs, offsetsToIndices);
return(pairs.Select(p => p.instruction).ToArray());
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var visibility = (Visibility)reader.ReadValueU8();
var flags = (ClassFlags)reader.ReadValueU16();
var unknownFlags = flags & ~KnownFlags;
if (unknownFlags != ClassFlags.None)
{
throw new FormatException();
}
var baseClass = reader.ReadReference <ClassDefinition>();
var functions = (flags & ClassFlags.HasFunctions) != 0
? reader.ReadReferences <FunctionDefinition>()
: new FunctionDefinition[0];
var unknown20s = (flags & ClassFlags.Unknown5) != 0
? reader.ReadReferences <PropertyDefinition>()
: new PropertyDefinition[0];
var unknown30s = (flags & ClassFlags.Unknown8) != 0
? reader.ReadReferences <PropertyDefinition>()
: new PropertyDefinition[0];
this.Functions.Clear();
this.Unknown20s.Clear();
this.Unknown30s.Clear();
this.Visibility = visibility;
this.Flags = flags;
this.BaseClass = baseClass;
this.Functions.AddRange(functions);
this.Unknown20s.AddRange(unknown20s);
this.Unknown30s.AddRange(unknown30s);
}
public ReaderConfiguration(string fileExtension, IDefinitionReader definitionReader) : this(fileExtension, File.Exists, definitionReader)
{
}
public static (object, uint) Read(IDefinitionReader reader)
{
return(reader.ReadValueU8(), 1);
}
public static (object, uint) Read(IDefinitionReader reader)
{
var definition = reader.ReadReference <T>();
return(definition, 8);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="definitionReader">Service base definition Reader.</param>
/// <param name="location">Services implementation folder.</param>
public SimpleServiceManager(IDefinitionReader definitionReader, string location)
{
_location = location;
_definitionReader = definitionReader;
_serviceContainer = new ServiceContainer();
}
public ReaderConfiguration(string fileExtension, Func <string, bool> isCreateableUsingFile, IDefinitionReader definitionReader)
{
FileExtension = fileExtension;
IsCreateableUsingFile = isCreateableUsingFile;
DefinitionReader = definitionReader;
}
public static (object, uint) Read(IDefinitionReader reader)
{
var native = reader.ReadReference <NativeDefinition>();
return(native, 8);
}
private delegate(object, uint) ReadDelegate(IDefinitionReader reader);
public static (object, uint) Read(IDefinitionReader reader)
{
return(reader.ReadResource(), 8);
}
internal override void Deserialize(IDefinitionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var visibility = (Visibility)reader.ReadValueU8();
var flags = (FunctionFlags)reader.ReadValueU32();
var unknownFlags = flags & ~KnownFlags;
if (unknownFlags != FunctionFlags.None)
{
throw new FormatException();
}
SourceFileDefinition sourceFile;
uint sourceLine;
if ((flags & FunctionFlags.IsNative) == 0)
{
sourceFile = reader.ReadReference <SourceFileDefinition>();
sourceLine = reader.ReadValueU32();
}
else
{
sourceFile = null;
sourceLine = 0;
}
Definition returnType;
bool unknown50;
if ((flags & FunctionFlags.HasReturnValue) != 0)
{
returnType = reader.ReadReference();
unknown50 = reader.ReadValueB8();
}
else
{
returnType = null;
unknown50 = false;
}
var unknown58 = (flags & FunctionFlags.Unknown8) != 0 ? reader.ReadReference() : null;
var parameters = (flags & FunctionFlags.HasParameters) != 0
? reader.ReadReferences <ParameterDefinition>()
: new ParameterDefinition[0];
var locals = (flags & FunctionFlags.HasLocals) != 0
? reader.ReadReferences <LocalDefinition>()
: new LocalDefinition[0];
var unknown98 = (flags & FunctionFlags.Unknown6) != 0
? reader.ReadValueU32()
: default;
var unknownA0 = (flags & FunctionFlags.Unknown12) != 0
? reader.ReadValueU8()
: default;
long bodyPosition = -1;
Instruction[] instructions;
if ((flags & FunctionFlags.HasBody) != 0)
{
var bodySize = reader.ReadValueU32();
bodyPosition = reader.Position;
instructions = Instructions.Read(reader, bodySize);
}
else
{
instructions = new Instruction[0];
}
this.Parameters.Clear();
this.Locals.Clear();
this.Body.Clear();
this.Visibility = visibility;
this.Flags = flags;
this.SourceFile = sourceFile;
this.SourceLine = sourceLine;
this.ReturnType = returnType;
this.Unknown50 = unknown50;
this.Unknown58 = unknown58;
this.Parameters.AddRange(parameters);
this.Locals.AddRange(locals);
this.Unknown98 = unknown98;
this.UnknownA0 = unknownA0;
this.BodyLoadPosition = bodyPosition;
this.Body.AddRange(instructions);
}
