public CodeTypeDeclarationCollection ConvertToCodeDom(NativeTypeDef typedef, ErrorProvider ep)
{
NativeSymbolBag bag = new NativeSymbolBag(_storage);
bag.AddTypeDef(typedef);
return(ConvertBagToCodeDom(bag, ep));
}
public string ConvertToPInvokeCode(NativeTypeDef typedef)
{
ErrorProvider ep = new ErrorProvider();
CodeTypeDeclarationCollection col = ConvertToCodeDom(typedef, ep);
return(ConvertCodeDomToPInvokeCodeImpl(col, ep));
}
private void VerifyTypeDef(NativeType nt, string name, string targetName)
{
NativeTypeDef td = nt as NativeTypeDef;
Assert.NotNull(td);
Assert.Equal(name, td.DisplayName);
Assert.Equal(targetName, td.RealType.DisplayName);
}
public void BagSaveAndLoad1()
{
NativeProcedure p1 = new NativeProcedure("p1");
p1.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeBoolean);
NativeTypeDef td = new NativeTypeDef("LPWSTR", new NativePointer(BuiltinType.NativeWChar));
p1.Signature.Parameters.Add(new NativeParameter("param1", new NativeNamedType("LPWSTR", td)));
Assert.Equal("boolean p1(LPWSTR param1)", p1.DisplayName);
Assert.Equal("p1(Sig(boolean)(Sal)(param1(LPWSTR(LPWSTR(*(wchar))))(Sal)))", SymbolPrinter.Convert(p1));
var ns = new BasicSymbolStorage();
ns.AddProcedure(p1);
ns.AddTypeDef(td);
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeProcedure ret1 = null;
Assert.True(bag.TryGetGlobalSymbol("p1", out ret1));
bag.AddProcedure(ret1);
Assert.True(bag.TryResolveSymbolsAndValues());
Assert.Equal(SymbolPrinter.Convert(p1), SymbolPrinter.Convert(ret1));
}
/// <summary>
/// Verification of the generated code
/// </summary>
/// <param name="ns"></param>
/// <remarks></remarks>
private static void VerifyGeneratedStorage(BasicSymbolStorage ns)
{
NativeProcedure proc = null;
VerifyTrue(ns.TryGetGlobalSymbol("SendMessageA", out proc));
VerifyTrue(ns.TryGetGlobalSymbol("SendMessageW", out proc));
VerifyTrue(ns.TryGetGlobalSymbol("GetForegroundWindow", out proc));
VerifyTrue(ns.TryGetGlobalSymbol("CreateWellKnownSid", out proc));
NativeTypeDef typedef = null;
VerifyTrue(ns.TryGetGlobalSymbol("LPCSTR", out typedef));
VerifyTrue(ns.TryGetGlobalSymbol("LPWSTR", out typedef));
NativeType defined = null;
VerifyTrue(ns.TryGetType("WNDPROC", out defined));
VerifyTrue(ns.TryGetType("HOOKPROC", out defined));
VerifyTrue(ns.TryGetType("tagPOINT", out defined));
VerifyTrue(ns.TryGetType("_SYSTEM_INFO", out defined));
NativeConstant c = null;
VerifyTrue(ns.TryGetGlobalSymbol("WM_PAINT", out c));
VerifyTrue(ns.TryGetGlobalSymbol("WM_LBUTTONDOWN", out c));
}
public void Iterate4()
{
NativeTypeDef nt1 = new NativeTypeDef("td1");
NativeNamedType nt2 = new NativeNamedType("n1");
nt1.RealType = nt2;
VerifyReachable(nt1, "td1", "n1");
}
private NativeGlobalSymbol ImportTypeDef()
{
var name = _reader.ReadString();
var type = ImportTypeReference();
var typeDef = new NativeTypeDef(name, type);
return(new NativeGlobalSymbol(typeDef));
}
public void AddTypeDef3()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeTypeDef td1 = new NativeTypeDef("td1");
NativeTypeDef td2 = new NativeTypeDef("td1");
bag.AddTypeDef(td1);
Assert.Throws <ArgumentException>(() => bag.AddTypeDef(td2));
}
public void Iterate5()
{
NativeStruct nt1 = new NativeStruct("s1");
NativeTypeDef nt2 = new NativeTypeDef("td1");
NativeNamedType nt3 = new NativeNamedType("n1");
nt2.RealType = nt3;
nt1.Members.Add(new NativeMember("foo", nt2));
VerifyReachable(nt1, "s1", "td1", "n1");
}
public void Dig4()
{
NativePointer pt = new NativePointer(BuiltinType.NativeByte);
Assert.Same(pt, pt.DigThroughTypeDefAndNamedTypes());
NativeTypeDef td = new NativeTypeDef("foo", pt);
Assert.Same(pt, td.DigThroughTypeDefAndNamedTypes());
}
public void Opaque2()
{
NativeNamedType named = new NativeNamedType("foo");
NativePointer ptr = new NativePointer(named);
NativeTypeDef td = new NativeTypeDef("FOOBAR", ptr);
NativeSymbolBag bag = new NativeSymbolBag();
bag.AddTypeDef(td);
Assert.Equal(1, bag.FindUnresolvedNativeSymbolRelationships().Count);
Assert.False(bag.TryResolveSymbolsAndValues());
}
public void TypeRename2()
{
NativeStruct s1 = new NativeStruct("s1");
s1.Members.Add(new NativeMember("m1", new NativeBuiltinType(BuiltinType.NativeChar)));
NativeTypeDef td = new NativeTypeDef("foo", s1);
NativeSymbolTransform transform = new NativeSymbolTransform();
transform.RenameTypeSymbol(td, "s1", "s2");
VerifyTree(td, "foo(s2(m1(char)))");
}
public void Dig1()
{
NativeTypeDef td = new NativeTypeDef("foo");
td.RealType = new NativeBuiltinType(BuiltinType.NativeByte);
Assert.Same(td.RealType, td.DigThroughTypeDefAndNamedTypes());
NativeTypeDef outerTd = new NativeTypeDef("bar");
outerTd.RealType = td;
Assert.Same(td.RealType, outerTd.DigThroughTypeDefAndNamedTypes());
}
public void AddTypeDef1()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeTypeDef td1 = new NativeTypeDef("td1");
bag.AddTypeDef(td1);
NativeType ret1 = null;
Assert.True(bag.TryGetType(td1.DisplayName, out ret1));
Assert.Same(ret1, td1);
}
public void FindOrLoad2()
{
var ns = new BasicSymbolStorage();
ns.AddTypeDef(new NativeTypeDef("td", new NativeBuiltinType(BuiltinType.NativeChar)));
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeTypeDef td = null;
Assert.False(bag.Storage.TryGetGlobalSymbol("td", out td));
Assert.True(bag.TryGetGlobalSymbol("td", out td));
Assert.True(bag.TryGetGlobalSymbol("td", out td));
}
public void Opaque1()
{
NativeNamedType named = new NativeNamedType("struct", "foo");
NativePointer ptr = new NativePointer(named);
NativeTypeDef td = new NativeTypeDef("FOOBAR", ptr);
NativeSymbolBag bag = new NativeSymbolBag();
bag.AddTypeDef(td);
Assert.Equal(1, bag.FindUnresolvedNativeSymbolRelationships().Count);
Assert.True(bag.TryResolveSymbolsAndValues());
Assert.NotNull(named.RealType);
Assert.Equal(NativeSymbolKind.OpaqueType, named.RealType.Kind);
}
public void SaveAndLoad4()
{
NativeTypeDef t1 = new NativeTypeDef("t1");
t1.RealType = new NativeBuiltinType(BuiltinType.NativeByte);
var ns = new BasicSymbolStorage();
ns.AddTypeDef(t1);
NativeType rett1 = null;
Assert.True(ns.TryGetType(t1.Name, out rett1));
Assert.True(NativeTypeEqualityComparer.AreEqualRecursive(rett1, t1));
}
public void Dig6()
{
NativeNamedType named = new NativeNamedType("bar", new NativeTypeDef("td1", BuiltinType.NativeFloat));
NativeTypeDef td = new NativeTypeDef("foo", named);
Assert.Equal(NativeSymbolKind.TypeDefType, td.DigThroughTypeDefAndNamedTypesFor("foo").Kind);
Assert.Same(td, td.DigThroughTypeDefAndNamedTypesFor("foo"));
Assert.Equal(NativeSymbolKind.BuiltinType, td.DigThroughTypeDefAndNamedTypes().Kind);
Assert.Equal(NativeSymbolKind.NamedType, td.DigThroughTypeDefAndNamedTypesFor("bar").Kind);
NativeNamedType named2 = new NativeNamedType("named2", td);
Assert.Equal(NativeSymbolKind.TypeDefType, named2.DigThroughNamedTypesFor("foo").Kind);
Assert.Null(named2.DigThroughNamedTypesFor("bar"));
}
public void Resolve1()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeStruct s1 = new NativeStruct("s1");
bag.AddDefinedType(s1);
NativeTypeDef td1 = new NativeTypeDef("td1");
NativeNamedType n1 = new NativeNamedType("s1");
td1.RealType = n1;
bag.AddTypeDef(td1);
Assert.True(bag.TryResolveSymbolsAndValues());
Assert.Same(s1, n1.RealType);
}
public void AddMixed2()
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeStruct definedNt1 = new NativeStruct("s1");
bag.AddDefinedType(definedNt1);
NativeTypeDef td1 = new NativeTypeDef("s1");
bag.AddTypeDef(td1);
NativeType ret = null;
Assert.True(bag.TryGetType(definedNt1.DisplayName, out ret));
Assert.Same(definedNt1, ret);
Assert.True(bag.TryGetType(td1.DisplayName, out ret));
Assert.Same(definedNt1, ret);
}
private void CollapseTypedefsImpl(NativeSymbol ns, NativeSymbol child)
{
if (ns == null)
{
return;
}
ThrowIfNull(child);
if (child.Kind == NativeSymbolKind.TypeDefType)
{
NativeTypeDef typedef = (NativeTypeDef)child;
if (typedef.RealType != null)
{
ns.ReplaceChild(child, typedef.RealType);
}
}
}
public void TopLevel6()
{
NativeBitVector m1 = new NativeBitVector(5);
NativeBitVector m2 = new NativeBitVector(5);
NativeTypeDef p1 = new NativeTypeDef("foo", m1);
NativeTypeDef p2 = new NativeTypeDef("foo", m2);
NativeTypeEqualityComparer eq = NativeTypeEqualityComparer.TopLevel;
Assert.True(eq.Equals1(p1, p2));
p2.Name = "bar";
Assert.False(eq.Equals1(p1, p2));
p2.Name = p1.Name;
p2.RealType = new NativeBitVector(6);
Assert.False(eq.Equals1(p1, p2));
}
public void ResolveLoad2()
{
var ns = new BasicSymbolStorage();
ns.AddTypeDef(new NativeTypeDef("TEST_INT", BuiltinType.NativeInt32));
NativeStruct s1 = new NativeStruct("s1");
s1.Members.Add(new NativeMember("m1", new NativeNamedType("TEST_INT")));
NativeSymbolBag bag = new NativeSymbolBag(ns);
bag.AddDefinedType(s1);
Assert.True(bag.TryResolveSymbolsAndValues());
NativeTypeDef td = null;
Assert.True(bag.TryGetGlobalSymbol("TEST_INT", out td));
}
private void VerifyReachable(NativeType nt, params string[] names)
{
NativeSymbolBag bag = new NativeSymbolBag();
NativeDefinedType definedNt = nt as NativeDefinedType;
NativeTypeDef typedefNt = nt as NativeTypeDef;
if (definedNt != null)
{
bag.AddDefinedType((NativeDefinedType)nt);
}
else if (typedefNt != null)
{
bag.AddTypeDef((NativeTypeDef)nt);
}
else
{
throw new Exception("Not a searchable type");
}
VerifyReachable(bag, names);
}
public CodeTypeReference GenerateProxyTypeReferenceImpl(NativeProxyType proxyNt, ref string comment)
{
// Check the various proxy types
if (proxyNt.RealType == null)
{
string msg = string.Format("Could not find the real type for {0}", proxyNt.DisplayName);
throw new InvalidOperationException(msg);
}
switch (proxyNt.Kind)
{
case NativeSymbolKind.ArrayType:
comment += proxyNt.DisplayName;
NativeArray arrayNt = (NativeArray)proxyNt;
CodeTypeReference elemRef = GenerateTypeReference(arrayNt.RealType);
CodeTypeReference arrayRef = new CodeTypeReference(elemRef, 1);
return(arrayRef);
case NativeSymbolKind.PointerType:
comment += proxyNt.DisplayName;
NativePointer pointerNt = (NativePointer)proxyNt;
return(new CodeTypeReference(typeof(IntPtr)));
case NativeSymbolKind.TypeDefType:
NativeTypeDef td = (NativeTypeDef)proxyNt;
comment += td.Name + "->";
return(GenerateTypeReferenceImpl(td.RealType, ref comment));
case NativeSymbolKind.NamedType:
// Don't update the comment for named types. Otherwise you get lots of
// comments like DWORD->DWORD->unsigned long
NativeNamedType namedNt = (NativeNamedType)proxyNt;
return(GenerateTypeReferenceImpl(namedNt.RealType, ref comment));
default:
Contract.ThrowInvalidEnumValue(proxyNt.Kind);
return(null);
}
}
public static void Main(string[] args)
{
NativeStorage ns = NativeStorage.LoadFromAssemblyPath;
NativeSymbolBag bag = new NativeSymbolBag(ns);
NativeProcedure ntProc = null;
bag.TryFindOrLoadProcedure("FindFirstFileW", ntProc);
bag.TryFindOrLoadProcedure("FindNextFileW", ntProc);
bag.TryFindOrLoadProcedure("FindClose", ntProc);
bag.TryFindOrLoadProcedure("GetSystemDirectoryW", ntProc);
bag.TryFindOrLoadProcedure("GetWindowTextW", ntProc);
bag.TryFindOrLoadProcedure("EnumWindows", ntProc);
bag.TryFindOrLoadProcedure("GetComputerNameW", ntProc);
bag.TryFindOrLoadProcedure("CreateWellKnownSid", ntProc);
bag.TryFindOrLoadProcedure("CopySid", ntProc);
bag.TryFindOrLoadProcedure("IsEqualSid", ntProc);
bag.TryFindOrLoadProcedure("SHGetFileInfoW", ntProc);
bag.TryFindOrLoadProcedure("GetEnvironmentVariableW", ntProc);
bag.TryFindOrLoadProcedure("atoi", ntProc);
NativeDefinedType ntDefined = null;
NativeTypeDef ntTypedef = null;
bag.TryFindOrLoadDefinedType("WNDPROC", ntDefined);
bag.TryFindOrLoadDefinedType("WNDENUMPROC", ntDefined);
bag.TryFindOrLoadDefinedType("COMSTAT", ntDefined);
bag.TryFindOrLoadDefinedType("_DCB", ntDefined);
bag.TryFindOrLoadDefinedType("_IMAGE_LINENUMBER", ntDefined);
BasicConverter convert = new BasicConverter(LanguageType.VisualBasic, ns);
string code = convert.ConvertToPInvokeCode(bag);
code = "' Generated File ... Re-Run PInvokeTestGen to regenerate this file" + Constants.vbCrLf + "Namespace Generated" + Constants.vbCrLf + code + Constants.vbCrLf + "End Namespace";
IO.File.WriteAllText(args(0), code);
}
/// <summary>
/// Used to create a simple set of types that can be used for testing purposes
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
public static BasicSymbolStorage CreateStandard()
{
var storage = new BasicSymbolStorage();
NativePointer pt1 = default(NativePointer);
NativeTypeDef td1 = default(NativeTypeDef);
NativeTypeDef td2 = default(NativeTypeDef);
NativeStruct s1 = default(NativeStruct);
NativeUnion u1 = default(NativeUnion);
NativeNamedType n1 = default(NativeNamedType);
// Include sal information
List <NativeConstant> list = ProcessSal();
foreach (NativeConstant cur in list)
{
storage.AddConstant(cur);
}
// Bool types
storage.AddTypeDef(new NativeTypeDef("BOOL", BuiltinType.NativeInt32));
storage.AddTypeDef(new NativeTypeDef("DWORD", new NativeBuiltinType(BuiltinType.NativeInt32, true)));
// WPARAM
td1 = new NativeTypeDef("UINT_PTR", new NativeBuiltinType(BuiltinType.NativeInt32, true));
storage.AddTypeDef(new NativeTypeDef("WPARAM", td1));
storage.AddTypeDef(new NativeTypeDef("LPARAM", td1));
// WCHAR
NativeTypeDef wcharTd = new NativeTypeDef("WCHAR", new NativeBuiltinType(BuiltinType.NativeInt16, true));
storage.AddTypeDef(wcharTd);
// CHAR
td1 = new NativeTypeDef("CHAR", BuiltinType.NativeChar);
storage.AddTypeDef(td1);
// TCHAR
td2 = new NativeTypeDef("TCHAR", td1);
storage.AddTypeDef(td2);
// LPWSTR
pt1 = new NativePointer(wcharTd);
td2 = new NativeTypeDef("LPWSTR", pt1);
storage.AddTypeDef(td2);
// LPCWSTR
n1 = new NativeNamedType(wcharTd.Name, wcharTd);
n1.IsConst = true;
pt1 = new NativePointer(n1);
td2 = new NativeTypeDef("LPCWSTR", pt1);
storage.AddTypeDef(td2);
// LPSTR
pt1 = new NativePointer(new NativeBuiltinType(BuiltinType.NativeChar));
td1 = new NativeTypeDef("LPSTR", pt1);
storage.AddTypeDef(td1);
// LPTSTR
storage.AddTypeDef(new NativeTypeDef("LPTSTR", td1));
// LPCSTR
n1 = new NativeNamedType("char", true);
n1.RealType = new NativeBuiltinType(BuiltinType.NativeChar, false);
pt1 = new NativePointer(n1);
td1 = new NativeTypeDef("LPCSTR", pt1);
storage.AddTypeDef(td1);
// LPCTSTR
td2 = new NativeTypeDef("LPCTSTR", td1);
storage.AddTypeDef(td2);
// BSTR
storage.AddTypeDef(new NativeTypeDef("OLECHAR", BuiltinType.NativeWChar));
storage.AddTypeDef(new NativeTypeDef("BSTR", new NativePointer(new NativeTypeDef("OLECHAR", BuiltinType.NativeWChar))));
// Struct with a recrsive reference to itself
s1 = new NativeStruct("RecursiveStruct");
s1.Members.Add(new NativeMember("m1", new NativePointer(new NativeNamedType(s1.Name))));
storage.AddDefinedType(s1);
// Simple struct
s1 = new NativeStruct("S1");
s1.Members.Add(new NativeMember("m1", new NativeBuiltinType(BuiltinType.NativeBoolean)));
storage.AddDefinedType(s1);
// Simulate a few well known structures
// DECIMAL
s1 = new NativeStruct("tagDEC");
storage.AddDefinedType(s1);
storage.AddTypeDef(new NativeTypeDef("DECIMAL", s1));
// CURRENCY
u1 = new NativeUnion("tagCY");
storage.AddDefinedType(u1);
storage.AddTypeDef(new NativeTypeDef("CY", u1));
storage.AddTypeDef(new NativeTypeDef("CURRENCY", new NativeTypeDef("CY", u1)));
// BYTE
storage.AddTypeDef(new NativeTypeDef("BYTE", new NativeBuiltinType(BuiltinType.NativeChar, true)));
return(storage);
}
public NativeGlobalSymbol(NativeTypeDef typeDef) : this(typeDef.NativeName, typeDef)
{
}
private static TypeAlias GetManagedTypeDef(NativeTypeDef typedef)
=> new TypeAlias(comment: typedef.Comment, name: $"{typedef.Name}_ptr");
private void WriteTypeDef(NativeTypeDef typeDef)
{
_writer.WriteNameKind(NativeNameKind.TypeDef);
_writer.WriteString(typeDef.Name);
WriteTypeReference(typeDef.RealType);
}
