private bool EqualsProxyCore(NativeProxyType left, NativeProxyType right)
        {
            bool ret = false;

            switch (left.Kind)
            {
            case NativeSymbolKind.ArrayType:
                NativeArray a1 = (NativeArray)left;
                NativeArray a2 = (NativeArray)right;

                ret = a1.ElementCount == a2.ElementCount;
                break;

            case NativeSymbolKind.NamedType:
                ret = (0 == string.CompareOrdinal(((NativeNamedType)left).Name, ((NativeNamedType)right).Name));
                break;

            case NativeSymbolKind.TypeDefType:
                ret = (0 == string.CompareOrdinal(((NativeTypeDef)left).Name, ((NativeTypeDef)right).Name));
                break;

            case NativeSymbolKind.PointerType:
                ret = true;
                break;

            default:
                ret = false;
                break;
            }

            if (!ret)
            {
                return(false);
            }

            if (left.RealType == null && right.RealType == null)
            {
                return(ret);
            }

            if (left.RealType == null || right.RealType == null)
            {
                return(false);
            }

            return(EqualsCore(left.RealType, right.RealType));
        }
Example #2
0
        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);
            }
        }