Example #1
0
        public override AST.Type VisitDecayed(DecayedType type)
        {
            throw new NotImplementedException();
            var _type = new CppSharp.AST.DecayedType();

            VisitType(type, _type);
            return(_type);
        }
Example #2
0
        public virtual bool VisitDecayedType(DecayedType decayed, TypeQualifiers quals)
        {
            if (!VisitType(decayed, quals))
            {
                return(false);
            }

            return(decayed.Decayed.Visit(this));
        }
Example #3
0
        public override bool VisitDecayedType(DecayedType decayed,
            TypeQualifiers quals)
        {
            var managedArray = decayed as ManagedArrayType;
            if (managedArray != null)
                return VisitManagedArrayType(managedArray, quals);

            return VisitDecayedType(decayed, quals);
        }
Example #4
0
        public override string VisitDecayedType(DecayedType decayed,
                                                TypeQualifiers quals)
        {
            var managedArray = decayed as ManagedArrayType;

            if (managedArray != null)
            {
                return(managedArray.Typedef.Visit(this));
            }

            return(base.VisitDecayedType(decayed, quals));
        }
Example #5
0
 public static DecayedType __CreateInstance(DecayedType.Internal native)
 {
     return new DecayedType(native);
 }
Example #6
0
 public bool VisitDecayedType(DecayedType decayed, TypeQualifiers quals)
 {
     throw new NotImplementedException();
 }
Example #7
0
 public CSharpTypePrinterResult VisitDecayedType(DecayedType decayed,
                                                 TypeQualifiers quals)
 {
     return(decayed.Decayed.Visit(this));
 }
Example #8
0
 protected DecayedType(DecayedType.Internal* native, bool skipVTables = false)
     : base((CppSharp.Parser.AST.Type.Internal*) null)
 {
     __PointerAdjustment = 0;
     if (native == null)
         return;
     __Instance = new global::System.IntPtr(native);
 }
Example #9
0
 private DecayedType(DecayedType.Internal native, bool skipVTables = false)
     : this(__CopyValue(native), skipVTables)
 {
     __ownsNativeInstance = true;
     NativeToManagedMap[__Instance] = this;
 }
Example #10
0
 internal DecayedType(DecayedType.Internal native)
     : this(__CopyValue(native))
 {
 }
Example #11
0
 protected DecayedType(DecayedType.Internal* native, bool isInternalImpl = false)
     : base((CppSharp.Parser.AST.Type.Internal*) native)
 {
 }
Example #12
0
 public virtual TypePrinterResult VisitDecayedType(DecayedType decayed,
                                                   TypeQualifiers quals)
 {
     throw new NotImplementedException();
 }
Example #13
0
 public abstract TRet VisitDecayed(DecayedType type);
Example #14
0
        public TRet Visit(Parser.AST.Type type)
        {
            if (type.__Instance == IntPtr.Zero)
            {
                return(default(TRet));
            }

            switch (type.Kind)
            {
            case TypeKind.Tag:
            {
                var _type = new TagType(type.__Instance);
                return(VisitTag(_type));
            }

            case TypeKind.Array:
            {
                var _type = new ArrayType(type.__Instance);
                return(VisitArray(_type));
            }

            case TypeKind.Function:
            {
                var _type = new FunctionType(type.__Instance);
                return(VisitFunction(_type));
            }

            case TypeKind.Pointer:
            {
                var _type = new PointerType(type.__Instance);
                return(VisitPointer(_type));
            }

            case TypeKind.MemberPointer:
            {
                var _type = new MemberPointerType(type.__Instance);
                return(VisitMemberPointer(_type));
            }

            case TypeKind.Typedef:
            {
                var _type = new TypedefType(type.__Instance);
                return(VisitTypedef(_type));
            }

            case TypeKind.Attributed:
            {
                var _type = new AttributedType(type.__Instance);
                return(VisitAttributed(_type));
            }

            case TypeKind.Decayed:
            {
                var _type = new DecayedType(type.__Instance);
                return(VisitDecayed(_type));
            }

            case TypeKind.TemplateSpecialization:
            {
                var _type = new TemplateSpecializationType(type.__Instance);
                return(VisitTemplateSpecialization(_type));
            }

            case TypeKind.TemplateParameter:
            {
                var _type = new TemplateParameterType(type.__Instance);
                return(VisitTemplateParameter(_type));
            }

            case TypeKind.TemplateParameterSubstitution:
            {
                var _type = new TemplateParameterSubstitutionType(type.__Instance);
                return(VisitTemplateParameterSubstitution(_type));
            }

            case TypeKind.InjectedClassName:
            {
                var _type = new InjectedClassNameType(type.__Instance);
                return(VisitInjectedClassName(_type));
            }

            case TypeKind.DependentName:
            {
                var _type = new DependentNameType(type.__Instance);
                return(VisitDependentName(_type));
            }

            case TypeKind.Builtin:
            {
                var _type = new BuiltinType(type.__Instance);
                return(VisitBuiltin(_type));
            }
            }

            throw new ArgumentOutOfRangeException();
        }
Example #15
0
 internal DecayedType(DecayedType.Internal native)
     : this(&native)
 {
 }
Example #16
0
 internal DecayedType(DecayedType.Internal* native)
     : this(new global::System.IntPtr(native))
 {
 }
Example #17
0
 private DecayedType(DecayedType.Internal native)
     : this(__CopyValue(native))
 {
     __ownsNativeInstance = true;
 }
Example #18
0
 private static DecayedType.Internal* __CopyValue(DecayedType.Internal native)
 {
     var ret = Marshal.AllocHGlobal(56);
     CppSharp.Parser.AST.DecayedType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
     return (DecayedType.Internal*) ret;
 }
Example #19
0
 private static void* __CopyValue(DecayedType.__Internal native)
 {
     var ret = Marshal.AllocHGlobal(32);
     global::CppSharp.Parser.AST.DecayedType.__Internal.cctor_2(ret, new global::System.IntPtr(&native));
     return ret.ToPointer();
 }
Example #20
0
 private DecayedType(DecayedType.Internal native)
     : this(__CopyValue(native))
 {
     __ownsNativeInstance = true;
     NativeToManagedMap[__Instance] = this;
 }
Example #21
0
 public static DecayedType __CreateInstance(DecayedType.Internal native, bool skipVTables = false)
 {
     return new DecayedType(native, skipVTables);
 }
Example #22
0
 public string VisitDecayedType(DecayedType decayed, TypeQualifiers quals)
 {
     return(decayed.Decayed.Visit(this));
 }
 public bool VisitDecayedType(DecayedType decayed, TypeQualifiers quals)
 {
     return(false);
 }