public void StCreate()
{
SerializedType st = new PrimitiveType_v1(Domain.SignedInt, 4);
Assert.AreEqual("prim(SignedInt,4)", st.ToString());
st = new PointerType_v1(new PrimitiveType_v1(Domain.UnsignedInt, 4));
Assert.AreEqual("ptr(prim(UnsignedInt,4))", st.ToString());
}
public void MacTi_PtrChain()
{
var decls = new List <Declaration>
{
new TypeDeclaration("GrafPort", new Record {
Fields = new List <Field>
{
new Field(new List <string> {
"test"
}, new Primitive(PrimitiveType_v1.Int32()))
}
}),
new TypeDeclaration("DialogPtr", new TypeReference("WindowPtr")),
new TypeDeclaration("GrafPtr", new Pointer(new TypeReference("GrafPort"))),
new TypeDeclaration("WindowPtr", new TypeReference("GrafPtr"))
};
Given_TypeImporter();
typeimporter.LoadTypes(decls);
Assert.AreEqual(32, typelib.Types["GrafPtr"].BitSize);
Assert.AreEqual(32, typelib.Types["WindowPtr"].BitSize);
Assert.AreEqual(32, typelib.Types["DialogPtr"].BitSize);
}
public void Ici_load_do_with_16bit_load()
{
var ici = new InlineCodeInterpreter(constants);
var ssig = new SerializedSignature
{
Arguments = new[]
{
new Argument_v1
{
Name = "d",
Type = new ReferenceType_v1 {
Referent = PrimitiveType_v1.Int32(),
Size = 4,
}
},
},
};
var svc = ici.BuildSystemCallFromMachineCode(
"GetTime", ssig, Opcodes(0x205F, 0x2038, 0x020c, 0xa9c6));
Assert.AreEqual("A9C6", svc.SyscallInfo.Vector);
var reg = (Register_v1)svc.Signature.Arguments[0].Kind;
Assert.AreEqual("a0", reg.Name);
}
public void Ici_Push_Zero_Constant()
{
var ici = new InlineCodeInterpreter(constants);
var ssig = new SerializedSignature
{
Arguments = new[]
{
new Argument_v1
{
Name = "act",
Type = PrimitiveType_v1.Bool(),
},
new Argument_v1
{
Name = "lHandle",
Type = new PrimitiveType_v1 {
Domain = Domain.Pointer, ByteSize = 4
},
},
},
};
var svc = ici.BuildSystemCallFromMachineCode(
"LActivate", ssig, Opcodes(0x4267, 0xA9E7));
Assert.AreEqual("A9E7", svc.SyscallInfo.Vector);
Assert.AreEqual("4", svc.SyscallInfo.StackValues[0].Offset);
Assert.AreEqual("0000", svc.SyscallInfo.StackValues[0].Value);
}
public void Tlldr_LoadGlobalByOrdinal()
{
var typelib = new TypeLibrary();
platform = new Mock <IPlatform>();
platform.Setup(p => p.DefaultCallingConvention).Returns("__cdecl");
platform.Setup(p => p.Architecture).Returns(new FakeArchitecture(new ServiceContainer()));
var tlldr = new TypeLibraryDeserializer(platform.Object, true, typelib);
tlldr.Load(new SerializedLibrary
{
ModuleName = "stdlib",
Globals = new List <GlobalVariable_v1>
{
new GlobalVariable_v1
{
Name = "errno",
Ordinal = 42,
Type = PrimitiveType_v1.Int32(),
}
}
});
var stdlib = typelib.Modules["stdlib"];
var globalByName = stdlib.GlobalsByName["errno"];
var globalByOrdinal = stdlib.GlobalsByOrdinal[42];
Assert.AreSame(globalByName, globalByOrdinal);
}
public List <ImageSymbol> GetAllSymbols()
{
return(new List <ImageSymbol>
{
ImageSymbol.Procedure(
arch.Object,
Address.Ptr64(0x12340000),
"MyFunction",
signature: new SerializedSignature
{
Arguments = new Argument_v1[]
{
new Argument_v1("arg1", PrimitiveType_v1.Int32(), new StackVariable_v1(), false),
new Argument_v1("arg2", new PointerType_v1(PrimitiveType_v1.Char8())
{
PointerSize = 4
}, new StackVariable_v1(), false),
},
ReturnValue = new Argument_v1
{
Type = PrimitiveType_v1.Int32()
}
})
});
}
public void X86_64Psig_MixedIntsFloats()
{
var pser = Given_ProcedureSerializer();
var ssig = new SerializedSignature
{
ReturnValue = new Argument_v1 {
Type = PrimitiveType_v1.Int32()
},
Arguments = new Argument_v1[]
{
new Argument_v1 {
Type = PrimitiveType_v1.Int32(), Name = "a"
},
new Argument_v1 {
Type = PrimitiveType_v1.Real64(), Name = "b"
},
new Argument_v1 {
Type = PointerType_v1.Create(PrimitiveType_v1.Char8(), 8), Name = "c"
},
new Argument_v1 {
Type = PrimitiveType_v1.Real64(), Name = "d"
},
new Argument_v1 {
Type = PrimitiveType_v1.Real32(), Name = "e"
},
}
};
var sig = pser.Deserialize(ssig, frame);
Assert.AreEqual("rax", sig.ReturnValue.Storage.ToString());
ExpectArgs(sig, "rcx", "xmm1", "r8", "xmm3", "Stack +0008");
}
public void ProcSer_Deserialize_thiscall_function()
{
var ssig = new SerializedSignature
{
Convention = "__thiscall",
Arguments = new Argument_v1[]
{
new Argument_v1
{
Name = "self",
Type = new PointerType_v1 {
DataType = PrimitiveType_v1.Int32(), PointerSize = 4
}
},
new Argument_v1
{
Name = "arg1",
Type = new PointerType_v1 {
DataType = PrimitiveType_v1.Int32(), PointerSize = 4
}
},
}
};
Given_ProcedureSerializer("__thiscall");
mr.ReplayAll();
var sig = ser.Deserialize(ssig, arch.CreateFrame());
var sExp =
@"void foo(Register (ptr32 int32) self, Stack (ptr32 int32) arg1)
// stackDelta: 8; fpuStackDelta: 0; fpuMaxParam: -1
";
Assert.AreEqual(sExp, sig.ToString("foo", FunctionType.EmitFlags.AllDetails));
}
public void Ici_Two_Register_Arguments()
{
var ici = new InlineCodeInterpreter(constants);
var ssig = new SerializedSignature
{
Arguments = new[] {
new Argument_v1
{
Name = "vblBlockPtr",
Type = new PrimitiveType_v1 {
Domain = Domain.Pointer, ByteSize = 4
}
},
new Argument_v1
{
Name = "theSlot",
Type = PrimitiveType_v1.Int16()
},
},
ReturnValue = new Argument_v1
{
Type = PrimitiveType_v1.Int16()
}
};
var svc = ici.BuildSystemCallFromMachineCode(
"SlotVInstall", ssig, Opcodes(0x301F, 0x205F, 0xA06F, 0x3E80));
Assert.AreEqual("A06F", svc.SyscallInfo.Vector);
Assert.AreEqual("a0", ((Register_v1)svc.Signature.Arguments[0].Kind).Name);
Assert.AreEqual("d0", ((Register_v1)svc.Signature.Arguments[1].Kind).Name);
Assert.AreEqual("d0", ((Register_v1)svc.Signature.ReturnValue.Kind).Name);
}
public void Ici_Push_Register_Constant()
{
var ici = new InlineCodeInterpreter(constants);
var ssig = new SerializedSignature
{
Arguments = new[]
{
new Argument_v1
{
Name = "act",
Type = new ReferenceType_v1 {
Referent = PrimitiveType_v1.Int16(),
Size = 4,
}
},
},
ReturnValue = new Argument_v1
{
Type = PrimitiveType_v1.Int16(),
}
};
var svc = ici.BuildSystemCallFromMachineCode(
"GetFrontProcess", ssig, Opcodes(0x70FF, 0x2F00, 0x3F3C, 0x0039, 0xA88F));
Assert.AreEqual("A88F", svc.SyscallInfo.Vector);
Assert.AreEqual("4", svc.SyscallInfo.StackValues[0].Offset);
Assert.AreEqual("0039", svc.SyscallInfo.StackValues[0].Value);
Assert.AreEqual("6", svc.SyscallInfo.StackValues[1].Offset);
Assert.AreEqual("ffffffff", svc.SyscallInfo.StackValues[1].Value);
}
public SerializedType VisitRangeType(RangeType rangeType)
{
var low = rangeType.Low.Accept(ceval).ToInt64();
var hi = rangeType.High.Accept(ceval).ToInt64();
var delta = hi - low + 1;
if (delta < 0)
{
throw new NotImplementedException("Range overflow.");
}
if (delta < 256)
{
return(low < 0
? PrimitiveType_v1.SChar8()
: PrimitiveType_v1.UChar8());
}
if (delta < 65536)
{
return(low <= 0
? PrimitiveType_v1.Int16()
: PrimitiveType_v1.UInt16());
}
if (delta < (1L << 32))
{
return(low <= 0
? PrimitiveType_v1.Int32()
: PrimitiveType_v1.UInt32());
}
return(PrimitiveType_v1.Int64());
}
public void TycoUserSegmentedData()
{
var addrUserData = Address.SegPtr(0xC30, 0x0042);
var addrSeg = Address.SegPtr(0xC30, 0);
var seg = new ImageSegment("seg0C30", addrSeg, new ByteMemoryArea(addrSeg, new byte[0x100]), AccessMode.ReadWriteExecute);
seg.Identifier = new Identifier("seg0C30", PrimitiveType.SegmentSelector, MemoryStorage.Instance);
var program = new ProgramBuilder().BuildProgram();
program.SegmentMap.AddSegment(seg);
program.User = new UserData
{
Globals =
{
{
addrUserData, new GlobalDataItem_v2
{
Name = "myGlobal",
DataType = PrimitiveType_v1.Real32(),
}
}
}
};
var eqb = new EquivalenceClassBuilder(program.TypeFactory, program.TypeStore, eventListener);
eqb.EnsureSegmentTypeVariables(program.SegmentMap.Segments.Values);
var tyco = Given_TypeCollector(program);
tyco.CollectUserGlobalVariableTypes();
Assert.AreEqual("42: myGlobal: real32", program.TypeStore.SegmentTypes[seg].Fields.First().ToString());
}
public DataType VisitPrimitive(PrimitiveType_v1 primitive)
{
var pt = PrimitiveType.Create(primitive.Domain, primitive.ByteSize * DataType.BitsPerByte);
pt.Qualifier = primitive.Qualifier;
return(pt);
}
public void MacTi_Point()
{
var decls = new List <Declaration>
{
new TypeDeclaration("Point", new Record {
Fields = new List <Field>
{
new Field(new List <string> {
"x"
}, new Primitive {
Type = PrimitiveType_v1.Int16()
}),
new Field(new List <string> {
"y"
}, new Primitive {
Type = PrimitiveType_v1.Int16()
})
}
}),
};
Given_TypeImporter();
typeimporter.LoadTypes(decls);
Assert.AreEqual(32, typelib.Types["Point"].BitSize);
}
public void TycoUserData()
{
var addrUserData = Address.Ptr32(0x00001400);
var program = new ProgramBuilder().BuildProgram();
program.User = new UserData
{
Globals =
{
{
addrUserData, new GlobalDataItem_v2
{
Name = "xAcceleration",
DataType = PrimitiveType_v1.Real64()
}
}
}
};
new EquivalenceClassBuilder(program.TypeFactory, program.TypeStore, eventListener).Build(program);
var tyco = Given_TypeCollector(program);
tyco.CollectGlobalType();
tyco.CollectUserGlobalVariableTypes();
Then_GlobalFieldsAre(program, "1400: xAcceleration: real64");
}
public void Tlldr_typedef_forwarded_struct_size()
{
Given_ArchitectureStub();
var typelib = new TypeLibrary();
var tlldr = new TypeLibraryDeserializer(platform.Object, true, typelib);
new SerializedTypedef
{
Name = "_sized_struct",
DataType = new StructType_v1
{
Name = "sized_struct",
}
}.Accept(tlldr);
new StructType_v1
{
Name = "sized_struct",
Fields = new StructField_v1[]
{
new StructField_v1 {
Name = "foo",
Offset = 0,
Type = PrimitiveType_v1.Int64(),
}
},
ByteSize = 8,
}.Accept(tlldr);
var str = (StructureType)typelib.Types["_sized_struct"];
var expected = @"(struct ""sized_struct"" 0008 (0 int64 foo))";
Assert.AreEqual(expected, str.ToString());
}
public SerializedType VisitStringType(Core.Pascal.StringType strType)
{
return(new StringType_v2
{
CharType = PrimitiveType_v1.Char8(),
Termination = StringType_v2.MsbTermination,
});
}
public void StCreate()
{
SerializedType st = new PrimitiveType_v1(Domain.SignedInt, 4);
Assert.AreEqual("prim(SignedInt,4)", st.ToString());
st = new PointerType_v1(new PrimitiveType_v1(Domain.UnsignedInt, 4));
Assert.AreEqual("ptr(prim(UnsignedInt,4))", st.ToString());
}
public DataType VisitPrimitive(PrimitiveType_v1 primitive)
{
var bitSize = primitive.Domain != Domain.Boolean
? DataType.BitsPerByte * primitive.ByteSize
: 1;
return(PrimitiveType.Create(primitive.Domain, bitSize));
}
public void SvArm32Ps_mmap()
{
var ssig = new SerializedSignature
{
ReturnValue = new Argument_v1
{
Type = new PointerType_v1
{
PointerSize = 4,
DataType = new VoidType_v1(),
}
},
Arguments = new Argument_v1[]
{
new Argument_v1
{
Name = "addr",
Type = new PointerType_v1
{
PointerSize = 4,
DataType = new VoidType_v1(),
}
},
new Argument_v1
{
Name = "length",
Type = PrimitiveType_v1.UInt32(),
},
new Argument_v1
{
Name = "prot",
Type = PrimitiveType_v1.Int32(),
},
new Argument_v1
{
Name = "flags",
Type = PrimitiveType_v1.Int32(),
},
new Argument_v1
{
Name = "fd",
Type = PrimitiveType_v1.Int32(),
},
new Argument_v1
{
Name = "offset",
Type = PrimitiveType_v1.Int32(),
}
}
};
Given_ProcedureSerializer();
mr.ReplayAll();
var sig = ser.Deserialize(ssig, arch.CreateFrame());
var args = sig.Parameters;
}
public void SvArm32Ps_Load_IntArgs()
{
var ssig = new SerializedSignature
{
Arguments = new Argument_v1[] {
new Argument_v1
{
Name = "dc",
Type = PrimitiveType_v1.Int16(),
},
new Argument_v1
{
Name = "b1",
Type = PrimitiveType_v1.SChar8(),
},
new Argument_v1
{
Name = "w2",
Type = PrimitiveType_v1.Int32(),
},
new Argument_v1
{
Name = "h3",
Type = PrimitiveType_v1.Int16(),
},
new Argument_v1
{
Name = "b4",
Type = PrimitiveType_v1.UChar8(),
},
new Argument_v1
{
Name = "w5",
Type = PrimitiveType_v1.Int32(),
},
new Argument_v1
{
Name = "foo",
Type = PrimitiveType_v1.Int32()
}
}
};
Given_ProcedureSerializer();
mr.ReplayAll();
var sig = ser.Deserialize(ssig, arch.CreateFrame());
var args = sig.Parameters;
Assert.AreEqual("r0", args[0].Storage.ToString());
Assert.AreEqual("r1", args[1].Storage.ToString());
Assert.AreEqual("r2", args[2].Storage.ToString());
Assert.AreEqual("r3", args[3].Storage.ToString());
Assert.AreEqual("Stack +0000", args[4].Storage.ToString());
Assert.AreEqual("Stack +0004", args[5].Storage.ToString());
Assert.AreEqual("Stack +0008", args[6].Storage.ToString());
}
public StringBuilder VisitPrimitive(PrimitiveType_v1 primitive)
{
switch (primitive.Domain)
{
case Domain.None:
sb.Append("void");
break;
case Domain.SignedInt:
switch (primitive.ByteSize)
{
case 4: sb.Append("int"); break;
case 8: sb.Append("__int64"); break;
default: throw new NotImplementedException();
}
break;
case Domain.UnsignedInt:
switch (primitive.ByteSize)
{
case 4: sb.Append("unsigned int");
break;
default: throw new NotImplementedException();
}
break;
case Domain.Character:
switch (primitive.ByteSize)
{
case 1: sb.Append("char"); break;
case 2: sb.Append("wchar_t"); break;
}
break;
case Domain.Character | Domain.UnsignedInt:
switch (primitive.ByteSize)
{
case 1: sb.Append("char"); break;
default: throw new NotImplementedException();
}
break;
default:
throw new NotSupportedException(string.Format("Domain {0} is not supported.", primitive.Domain));
}
if (name != null)
{
sb.AppendFormat(" {0}", name);
}
return(sb);
}
private void AddIntrinsicTypes(List <Declaration> declarations)
{
declarations.AddRange(new[] {
new TypeDeclaration(
"OBJECT",
new Primitive(PrimitiveType_v1.Ptr32())),
new TypeDeclaration(
"Comp",
new Primitive(PrimitiveType_v1.Ptr32()))
});
}
public DataType VisitPrimitive(PrimitiveType_v1 primitive)
{
var bitSize = primitive.Domain != Domain.Boolean
? DataType.BitsPerByte * primitive.ByteSize
: 1;
var pt = PrimitiveType.Create(primitive.Domain, bitSize);
pt.Qualifier = primitive.Qualifier;
return(pt);
}
public void Ici_PostCallStackUpdate()
{
var ici = new InlineCodeInterpreter(constants);
var ssig = new SerializedSignature
{
Arguments = new Argument_v1[0],
ReturnValue = new Argument_v1 {
Type = PrimitiveType_v1.Int16()
}
};
var svc = ici.BuildSystemCallFromMachineCode("CountADBs", ssig, Opcodes(0xA077, 0x3E80));
Assert.AreEqual("A077", svc.SyscallInfo.Vector);
Assert.AreEqual("d0", ((Register_v1)svc.Signature.ReturnValue.Kind).Name);
}
public void SudSave_UserGlobal_issue_201()
{
var platform = new TestPlatform
{
};
var program = new Program
{
Platform = platform,
User = new UserData
{
ExtractResources = true,
Globals =
{
{
Address.Ptr32(0x01234),
new GlobalDataItem_v2
{
DataType = PrimitiveType_v1.Real32(),
Name = "pi"
}
}
}
}
};
var sw = new StringWriter();
When_SaveToTextWriter(program, sw);
var sExp =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<project xmlns=""http://schemata.jklnet.org/Reko/v4"">
<input>
<user>
<global>
<Address>00001234</Address>
<prim domain=""Real"" size=""4"" />
<Name>pi</Name>
</global>
<registerValues />
</user>
</input>
</project>";
if (sw.ToString() != sExp)
{
Debug.Print("{0}", sw.ToString());
}
Assert.AreEqual(sExp, sw.ToString());
}
private SerializedType Type()
{
switch (str[i++])
{
case 'b': return(PrimitiveType_v1.Bool());
case 'c': return(PrimitiveType_v1.Char8());
case 'h': return(PrimitiveType_v1.UChar8());
case 's': return(PrimitiveType_v1.Int16());
case 'r': return(PrimitiveType_v1.UInt16());
case 'i': return(PrimitiveType_v1.Int32());
case 'j': return(PrimitiveType_v1.UInt32());
case 'l': return(PrimitiveType_v1.Int64());
case 'm': return(PrimitiveType_v1.UInt64());
case 'w': return(PrimitiveType_v1.WChar16());
case 'f': return(PrimitiveType_v1.Real32());
case 'd': return(PrimitiveType_v1.Real64());
case 'P': return(new PointerType_v1 {
DataType = Type(), PointerSize = ptrSize
});
case 'R': return(new ReferenceType_v1 {
Referent = Type(), Size = ptrSize
});
default:
--i;
if (char.IsDigit(str[i]))
{
return(new TypeReference_v1
{
TypeName = SimpleName(),
});
}
throw new NotImplementedException(string.Format("Unknown GCC type code '{0}'.", str[i]));
}
}
public void SvArm32Ps_DeserializeFpuReturnValue()
{
var ssig = new SerializedSignature
{
ReturnValue = new Argument_v1
{
Type = PrimitiveType_v1.Real64(),
}
};
Given_ProcedureSerializer();
mr.ReplayAll();
var sig = ser.Deserialize(ssig, arch.CreateFrame());
Assert.AreEqual("Sequence r1:r0", sig.ReturnValue.Storage.ToString());
}
public void Ici_Load_Word_Constant_To_Register()
{
var ici = new InlineCodeInterpreter(constants);
var ssig = new SerializedSignature
{
Arguments = new []
{
new Argument_v1
{
Name = "typecode",
Type = PrimitiveType_v1.Int32(),
},
new Argument_v1
{
Name = "dataPtr",
Type = new PrimitiveType_v1 {
Domain = Domain.Pointer, ByteSize = 4
},
},
new Argument_v1
{
Name = "result",
Type = new ReferenceType_v1
{
Referent = new TypeReference_v1 {
TypeName = "AEDesc"
}
}
}
},
ReturnValue = new Argument_v1
{
Type = PrimitiveType_v1.Int16()
}
};
var svc = ici.BuildSystemCallFromMachineCode(
"AECreateDesc", ssig, Opcodes(0x303C, 0x0825, 0xA816));
Assert.AreEqual("A816", svc.SyscallInfo.Vector);
Assert.AreEqual("d0", svc.SyscallInfo.RegisterValues[0].Register);
Assert.AreEqual("0825", svc.SyscallInfo.RegisterValues[0].Value);
}
public void SvX86Ps_DeserializeFpuArgument()
{
var ssig = new SerializedSignature
{
Convention = "stdapi",
ReturnValue = RegArg(PrimitiveType_v1.Int32(), "eax"),
Arguments = new Argument_v1[] {
StackArg(PrimitiveType_v1.Real64(), "rArg04")
}
};
Given_ProcedureSerializer();
mr.ReplayAll();
var sig = ser.Deserialize(ssig, arch.CreateFrame());
Assert.AreEqual("Register int32 test(Stack real64 rArg04)", sig.ToString("test"));
}
public void SvArm32Ps_Load_cdecl()
{
var ssig = new SerializedSignature
{
Arguments = new Argument_v1[] {
new Argument_v1
{
Name = "foo",
Type = PrimitiveType_v1.Int32(),
}
}
};
Given_ProcedureSerializer();
mr.ReplayAll();
var sig = ser.Deserialize(ssig, arch.CreateFrame());
Assert.AreEqual(0, sig.StackDelta);
}
public SerializedType ParseDataTypeCode(List<Argument_v1> compoundArgs)
{
if (PeekAndDiscard('?'))
{
switch (str[i++])
{
case 'A': break;
case 'B': /* const */ break;
default: Error("Expected 'A' or 'B', but saw '{0}'.", str[i - 1]); break;
}
}
switch (str[i++])
{
case '0': return compoundArgs[0].Type;
case '1': return compoundArgs[1].Type;
case '2': return compoundArgs[2].Type;
case '3': return compoundArgs[3].Type;
case '4': return compoundArgs[4].Type;
case '5': return compoundArgs[5].Type;
case '6': return compoundArgs[6].Type;
case '7': return compoundArgs[7].Type;
case '8': return compoundArgs[8].Type;
case '9': return compoundArgs[9].Type;
case 'A': return ParsePointer(compoundArgs); //$TODO: really is a reference but is implemented as a pointer on Win32...
case 'C': return new PrimitiveType_v1(Domain.Character | Domain.SignedInt, 1);
case 'D': return new PrimitiveType_v1(Domain.Character, 1);
case 'E': return new PrimitiveType_v1(Domain.Character | Domain.UnsignedInt, 1);
case 'F': return new PrimitiveType_v1(Domain.SignedInt, 2);
case 'G': return new PrimitiveType_v1(Domain.UnsignedInt, 2);
case 'H': return new PrimitiveType_v1(Domain.SignedInt, 4);
case 'I': return new PrimitiveType_v1(Domain.UnsignedInt, 4);
case 'J': return new PrimitiveType_v1(Domain.SignedInt, 4); // 'long' on Win32 is actually 4 bytes
case 'K': return new PrimitiveType_v1(Domain.UnsignedInt, 4); // 'long' on Win32 is actually 4 bytes
case 'M': return new PrimitiveType_v1(Domain.Real, 4);
case 'N': return new PrimitiveType_v1(Domain.Real, 8);
case 'O': return new PrimitiveType_v1(Domain.Real, 10);
case 'P': return ParsePointer(compoundArgs); // pointer
case 'Q': return ParsePointer(compoundArgs); // const pointer
case 'R': return ParsePointer(compoundArgs); // volatile pointer
case 'T': return ParseStructure(compoundArgs); // union
case 'U': return ParseStructure(compoundArgs); // struct (see below)
case 'V': return ParseStructure(compoundArgs); // class (see below)
case 'W': return ParseEnum(compoundArgs);
case 'X': return new VoidType_v1(); // void (as in 'void return value', 'X' terminates argument list)
case '_':
PrimitiveType_v1 prim;
switch (str[i++])
{
case 'J': prim = new PrimitiveType_v1(Domain.SignedInt, 8); break; // __int64
case 'K': prim = new PrimitiveType_v1(Domain.UnsignedInt, 8); break; // unsigned __int64
case 'N': prim = new PrimitiveType_v1(Domain.Boolean, 1); break; // bool
case 'W': prim = new PrimitiveType_v1(Domain.Character, 2); break; // wchar_t
default: Error("Unsupported type code '_{0}'.", str[i - 1]); return null;
}
compoundArgs.Add(new Argument_v1 { Type = prim });
return prim;
default: Error("Unsupported type code '{0}'.", str[i - 1]); return null;
}
}
private bool LoadParameter(SerializedSignature ssig, List<Argument_v1> args)
{
if (PeekAndDiscard(TokenType.NUMBER))
return true;
Token tok = Peek();
if (tok.Type != TokenType.ID)
return false;
Get();
SerializedType type = null;
switch (tok.Value)
{
case "word":
case "s_word":
type = new PrimitiveType_v1(PrimitiveType.Word16.Domain, 2);
break;
case "long":
type = new PrimitiveType_v1(PrimitiveType.Word32.Domain, 4);
break;
//$TODO: need SegmentedPointerType
case "segptr":
case "segstr":
type = new PrimitiveType_v1(Domain.SegPointer, 4);
break;
case "ptr":
type = new PrimitiveType_v1(Domain.Pointer, 4);
break;
case "str":
type = PointerType_v1.Create(PrimitiveType_v1.Char8(), 4);
break;
case "wstr":
type = PointerType_v1.Create(PrimitiveType_v1.WChar16(), 4);
break;
case "uint16":
type = PrimitiveType_v1.UInt16();
break;
case "uint32":
type = PrimitiveType_v1.UInt32();
break;
case "uint64":
type = PrimitiveType_v1.UInt64();
break;
case "int16":
type = PrimitiveType_v1.Int16();
break;
case "int32":
type = PrimitiveType_v1.Int32();
break;
case "int64":
type = PrimitiveType_v1.Int64();
break;
default: throw new Exception("Unknown: " + tok.Value);
}
args.Add(new Argument_v1 { Type = type });
return true;
}
