Example #1
0
        protected TypeComponent(VirtualMachine virtualMachine, ReferenceType declaringType, string name, string signature, string genericSignature, AccessModifiers modifiers)
            : base(virtualMachine)
        {
            Contract.Requires(virtualMachine != null);
            Contract.Requires<ArgumentNullException>(declaringType != null, "declaringType");

            _declaringType = declaringType;
            _name = name;
            _signature = signature;
            _genericSignature = genericSignature;
            _modifiers = modifiers;
        }
Example #2
0
        internal Method(VirtualMachine virtualMachine, ReferenceType declaringType, string name, string signature, string genericSignature, AccessModifiers modifiers, MethodId methodId)
            : base(virtualMachine, declaringType, name, signature, genericSignature, modifiers)
        {
            Contract.Requires(virtualMachine != null);
            _methodId = methodId;

            List<string> argumentTypeSignatures;
            string returnTypeSignature;
            SignatureHelper.ParseMethodSignature(signature, out argumentTypeSignatures, out returnTypeSignature);

            _argumentTypeSignatures = argumentTypeSignatures.AsReadOnly();
            _argumentTypeNames = argumentTypeSignatures.Select(SignatureHelper.DecodeTypeName).ToList().AsReadOnly();
            _returnTypeSignature = returnTypeSignature;
            _returnTypeName = SignatureHelper.DecodeTypeName(_returnTypeSignature);
        }
Example #3
0
        internal Method GetMirrorOf(ReferenceType declaringType, MethodId methodId)
        {
            IEnumerable <Method> methods = declaringType.GetMethods(false).Cast <Method>();

            return(methods.FirstOrDefault(i => i.MethodId == methodId));
        }
Example #4
0
        protected static void GetInheritedTypes(ReferenceType type, HashSet<ReferenceType> inheritedTypes)
        {
            List<ReferenceType> immediateBases = new List<ReferenceType>();

            ClassType classtype = type as ClassType;
            if (classtype != null)
            {
                ClassType basetype = (ClassType)classtype.GetSuperclass();
                if (basetype != null)
                    immediateBases.Add(basetype);

                immediateBases.AddRange(classtype.GetInterfaces(false).Cast<ReferenceType>());
            }

            InterfaceType interfacetype = type as InterfaceType;
            if (interfacetype != null)
            {
                immediateBases.AddRange(interfacetype.GetSuperInterfaces().Cast<ReferenceType>());
            }

            foreach (var baseType in immediateBases)
            {
                if (inheritedTypes.Add(baseType))
                    GetInheritedTypes(baseType, inheritedTypes);
            }
        }
Example #5
0
 internal Field(VirtualMachine virtualMachine, ReferenceType declaringType, string name, string signature, string genericSignature, AccessModifiers modifiers, FieldId fieldId)
     : base(virtualMachine, declaringType, name, signature, genericSignature, modifiers)
 {
     Contract.Requires(virtualMachine != null);
     _fieldId = fieldId;
 }
Example #6
0
 internal Method GetMirrorOf(ReferenceType declaringType, MethodId methodId)
 {
     IEnumerable<Method> methods = declaringType.GetMethods(false).Cast<Method>();
     return methods.FirstOrDefault(i => i.MethodId == methodId);
 }
Example #7
0
        internal Method GetMirrorOf(ReferenceType declaringType, DeclaredMethodData methodData)
        {
            lock (_methods)
            {
                List<Method> methods;
                if (!_methods.TryGetValue(declaringType.ReferenceTypeId, out methods))
                {
                    methods = new List<Method>();
                    _methods[declaringType.ReferenceTypeId] = methods;
                }

                Method method = methods.SingleOrDefault(i => i.MethodId == methodData.MethodId);
                if (method == null)
                {
                    method = new Method(this, declaringType, methodData.Name, methodData.Signature, methodData.GenericSignature, (AccessModifiers)methodData.Modifiers, methodData.MethodId);
                    methods.Add(method);
                }

                return method;
            }
        }
Example #8
0
        internal Field GetMirrorOf(ReferenceType declaringType, DeclaredFieldData fieldData)
        {
            lock (_fields)
            {
                List<Field> fields;
                if (!_fields.TryGetValue(declaringType.ReferenceTypeId, out fields))
                {
                    fields = new List<Field>();
                    _fields[declaringType.ReferenceTypeId] = fields;
                }

                Field field = fields.SingleOrDefault(i => i.FieldId == fieldData.FieldId);
                if (field == null)
                {
                    field = new Field(this, declaringType, fieldData.Name, fieldData.Signature, fieldData.GenericSignature, (AccessModifiers)fieldData.Modifiers, fieldData.FieldId);
                    fields.Add(field);
                }

                return field;
            }
        }
Example #9
0
        internal ObjectReference GetMirrorOf(Tag tag, ObjectId objectId, ReferenceType type)
        {
            if (tag == default(Tag) && objectId == default(ObjectId))
                return null;

            switch (tag)
            {
            case Tag.Array:
                return new ArrayReference(this, (ArrayId)objectId, type);

            case Tag.Object:
                return new ObjectReference(this, objectId, type);

            case Tag.String:
                return new StringReference(this, (StringId)objectId, type);

            case Tag.Thread:
                return new ThreadReference(this, (ThreadId)objectId, type);

            case Tag.ThreadGroup:
                return new ThreadGroupReference(this, (ThreadGroupId)objectId, type);

            case Tag.ClassLoader:
                return new ClassLoaderReference(this, (ClassLoaderId)objectId, type);

            case Tag.ClassObject:
                return new ClassObjectReference(this, (ClassObjectId)objectId, type);

            case Tag.Invalid:
            case Tag.Byte:
            case Tag.Char:
            case Tag.Float:
            case Tag.Double:
            case Tag.Int:
            case Tag.Long:
            case Tag.Short:
            case Tag.Boolean:
            case Tag.Void:
            default:
                throw new ArgumentException();
            }
        }
Example #10
0
 internal Field(VirtualMachine virtualMachine, ReferenceType declaringType, string name, string signature, string genericSignature, AccessModifiers modifiers, FieldId fieldId)
     : base(virtualMachine, declaringType, name, signature, genericSignature, modifiers)
 {
     Contract.Requires(virtualMachine != null);
     _fieldId = fieldId;
 }