Exemple #1
0
        public int GetMemberIndex(IMemberReference reference)
        {
            int classIndex       = GetClassIndex(reference.DeclaringClass);
            int nameAndTypeIndex = GetNameAndTypeIndex(reference.Name, reference.Descriptor);

            MemberRefInfo memberRefInfo;

            switch (reference)
            {
            case IField _:
                memberRefInfo = new FieldRefInfo((ushort)classIndex, (ushort)nameAndTypeIndex);
                break;

            case IMethod _:
                memberRefInfo = new MethodRefInfo((ushort)classIndex, (ushort)nameAndTypeIndex);
                break;

            default:
                throw new NotSupportedException();
            }

            if (!_memberRefInfos.TryGetValue(memberRefInfo, out int index))
            {
                index = AddConstant(memberRefInfo);
                _memberRefInfos.Add(memberRefInfo, index);
            }

            return(index);
        }
Exemple #2
0
        /// <summary>
        /// Reads a single method reference at the current position of the provided reader.
        /// </summary>
        /// <param name="reader">The reader to use.</param>
        /// <returns>The method reference that was read.</returns>
        public new static MethodRefInfo FromReader(IBigEndianReader reader)
        {
            var info = new MethodRefInfo
            {
                StartOffset = reader.Position - 1
            };

            info.ReadRemainingFields(reader);
            return(info);
        }
Exemple #3
0
        internal MethodReference(JavaClassImage classImage, MethodRefInfo methodRefInfo)
        {
            _name = new LazyValue <string>(() =>
            {
                var constantInfo = classImage.ClassFile.ConstantPool.ResolveConstant(methodRefInfo.NameAndTypeIndex);
                return(constantInfo is NameAndTypeInfo nameAndTypeInfo
                    ? classImage.ClassFile.ConstantPool.ResolveString(nameAndTypeInfo.NameIndex) ??
                       $"<<<INVALID({nameAndTypeInfo.NameIndex})>>>"
                    : $"<<<INVALID({methodRefInfo.NameAndTypeIndex})>>>");
            });

            _descriptor = new LazyValue <MethodDescriptor>(() =>
            {
                var constantInfo = classImage.ClassFile.ConstantPool.ResolveConstant(methodRefInfo.NameAndTypeIndex);
                return(constantInfo is NameAndTypeInfo nameAndTypeInfo
                    ? classImage.ResolveMethodDescriptor(nameAndTypeInfo.DescriptorIndex)
                    : null);
            });

            _declaringClass = new LazyValue <ClassReference>(() =>
                                                             classImage.ResolveClass(methodRefInfo.ClassIndex));
        }