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); }