public void Iterate4() { NativeTypeDef nt1 = new NativeTypeDef("td1"); NativeNamedType nt2 = new NativeNamedType("n1"); nt1.RealType = nt2; VerifyReachable(nt1, "td1", "n1"); }
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 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 Dig2() { NativeNamedType named = new NativeNamedType("foo"); named.RealType = new NativeBuiltinType(BuiltinType.NativeByte); Assert.Same(named.RealType, named.DigThroughTypeDefAndNamedTypes()); NativeNamedType outerNamed = new NativeNamedType("bar"); outerNamed.RealType = named; Assert.Same(named.RealType, outerNamed.DigThroughTypeDefAndNamedTypes()); }
private bool TryResolveNamedTypeCore(NativeNamedType namedType, out NativeType type, out bool loadedFromNextLookup) { if (string.IsNullOrEmpty(namedType.Qualification)) { // If there is no qualification then just load the type by it's name return(this.TryFindTypeCore(namedType.Name, out type, out loadedFromNextLookup)); } // When there is a qualification it is either struct, union or enum. Try and load the defined type // for the name and then make sure that it is the correct type if (!TryFindTypeCore(namedType.Name, out type, out loadedFromNextLookup)) { type = null; return(false); } var definedNt = type as NativeDefinedType; if (definedNt == null) { type = null; return(false); } string typeQualification = null; switch (definedNt.Kind) { case NativeSymbolKind.StructType: typeQualification = "struct"; break; case NativeSymbolKind.UnionType: typeQualification = "union"; break; case NativeSymbolKind.EnumType: typeQualification = "enum"; break; default: return(false); } string qual = namedType.Qualification; if ("class" == qual) { qual = "struct"; } return(typeQualification == qual); }
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 IgnoreNamedTypes() { NativeEnum e1 = new NativeEnum("e"); NativeEnum e2 = new NativeEnum("e"); NativeNamedType n2 = new NativeNamedType("e", e2); e1.Values.Add(new NativeEnumValue("e", "v1")); e2.Values.Add(new NativeEnumValue("e", "v1")); NativeTypeEqualityComparer eq = NativeTypeEqualityComparer.TopLevel; Assert.True(eq.Equals1(e1, n2)); }
private NativeType DigThroughNamedType(NativeType nt) { while ((NativeSymbolKind.NamedType == nt.Kind)) { NativeNamedType namedtype = (NativeNamedType)nt; if (namedtype.RealType == null) { break; } nt = namedtype.RealType; } return(nt); }
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); }
private void CollapseNamedTypesImpl(NativeSymbol ns, NativeSymbol child) { if (ns == null) { return; } ThrowIfNull(child); if (child.Kind == NativeSymbolKind.NamedType) { NativeNamedType namedNt = (NativeNamedType)child; if (namedNt.RealType != null) { ns.ReplaceChild(child, namedNt.RealType); } } }
/// <summary> /// Try and resolve the unresolved symbols in the system /// </summary> private ResolveResult ResolveCoreSymbols(ErrorProvider ep) { var succeeded = true; var needMoreWork = false; foreach (NativeSymbolRelationship rel in this.FindUnresolvedNativeSymbolRelationships()) { // Values and value expressions are resolved in a different pass. if (rel.Symbol.Kind == NativeSymbolKind.Value || rel.Symbol.Kind == NativeSymbolKind.ValueExpression) { continue; } // In this pass we are resolving the named type instances. NativeNamedType namedType = rel.Symbol as NativeNamedType; if (namedType == null) { ep.AddError($"Failed to resolve {rel.Symbol.Kind} -> '{rel.Symbol.DisplayName}'"); continue; } NativeType nt = null; bool loadedFromNextLookup; if (TryResolveNamedTypeCore(namedType, out nt, out loadedFromNextLookup)) { Debug.Assert(nt != null); namedType.RealType = nt; needMoreWork = true; } else if (rel.Parent != null && rel.Parent.Kind == NativeSymbolKind.PointerType && !string.IsNullOrEmpty(namedType.Qualification)) { // When we have a pointer to an unresolved type, treat this as an opaque type ep.AddWarning($"Treating '{namedType.DisplayName}' as pointer to opaque type"); namedType.RealType = new NativeOpaqueType(); } else { ep.AddError($"Failed to resolve name '{namedType.DisplayName}'"); succeeded = false; } } return(new ResolveResult(succeeded, needMoreWork)); }
public void TopLevel7() { NativeBitVector m1 = new NativeBitVector(5); NativeBitVector m2 = new NativeBitVector(5); NativeNamedType p1 = new NativeNamedType("foo", m1); NativeNamedType p2 = new NativeNamedType("foo", m2); NativeTypeEqualityComparer eq = NativeTypeEqualityComparer.TopLevel; Assert.True(eq.Equals1(p1, p2)); // We just dig right through named types unless they don't have an underlying // real type p2.Name = "bar"; Assert.True(eq.Equals1(p1, p2)); p2.Name = p1.Name; p2.RealType = new NativeBitVector(6); Assert.False(eq.Equals1(p1, p2)); }
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); } }
/// <summary> /// Try and resolve this <see cref="NativeNamedType"/> to a real type or at least /// the next level. /// </summary> public bool TryResolveNamedType(NativeNamedType namedType, out NativeType type) { bool loadedFromNextLookup; return(TryResolveNamedTypeCore(namedType, out type, out loadedFromNextLookup)); }
/// <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 void Dig3() { NativeNamedType named = new NativeNamedType("foo"); Assert.Null(named.DigThroughTypeDefAndNamedTypes()); }