| /* |
| * reserved comment block |
| * DO NOT REMOVE OR ALTER! |
| */ |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.sun.org.apache.bcel.internal.generic; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.DataInput; |
| import java.io.DataInputStream; |
| import java.io.DataOutputStream; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import com.sun.org.apache.bcel.internal.classfile.AnnotationEntry; |
| import com.sun.org.apache.bcel.internal.classfile.Attribute; |
| import com.sun.org.apache.bcel.internal.classfile.ConstantUtf8; |
| import com.sun.org.apache.bcel.internal.classfile.ElementValuePair; |
| import com.sun.org.apache.bcel.internal.classfile.RuntimeInvisibleAnnotations; |
| import com.sun.org.apache.bcel.internal.classfile.RuntimeInvisibleParameterAnnotations; |
| import com.sun.org.apache.bcel.internal.classfile.RuntimeVisibleAnnotations; |
| import com.sun.org.apache.bcel.internal.classfile.RuntimeVisibleParameterAnnotations; |
| |
| /** |
| * @since 6.0 |
| */ |
| public class AnnotationEntryGen { |
| private int typeIndex; |
| |
| private List<ElementValuePairGen> evs; |
| |
| private final ConstantPoolGen cpool; |
| |
| private boolean isRuntimeVisible = false; |
| |
| /** |
| * Here we are taking a fixed annotation of type Annotation and building a |
| * modifiable AnnotationGen object. If the pool passed in is for a different |
| * class file, then copyPoolEntries should have been passed as true as that |
| * will force us to do a deep copy of the annotation and move the cpool |
| * entries across. We need to copy the type and the element name value pairs |
| * and the visibility. |
| */ |
| public AnnotationEntryGen(final AnnotationEntry a, final ConstantPoolGen cpool, |
| final boolean copyPoolEntries) { |
| this.cpool = cpool; |
| if (copyPoolEntries) { |
| typeIndex = cpool.addUtf8(a.getAnnotationType()); |
| } else { |
| typeIndex = a.getAnnotationTypeIndex(); |
| } |
| isRuntimeVisible = a.isRuntimeVisible(); |
| evs = copyValues(a.getElementValuePairs(), cpool, copyPoolEntries); |
| } |
| |
| private List<ElementValuePairGen> copyValues(final ElementValuePair[] in, final ConstantPoolGen cpool, |
| final boolean copyPoolEntries) { |
| final List<ElementValuePairGen> out = new ArrayList<>(); |
| for (final ElementValuePair nvp : in) { |
| out.add(new ElementValuePairGen(nvp, cpool, copyPoolEntries)); |
| } |
| return out; |
| } |
| |
| private AnnotationEntryGen(final ConstantPoolGen cpool) { |
| this.cpool = cpool; |
| } |
| |
| /** |
| * Retrieve an immutable version of this AnnotationGen |
| */ |
| public AnnotationEntry getAnnotation() { |
| final AnnotationEntry a = new AnnotationEntry(typeIndex, cpool.getConstantPool(), |
| isRuntimeVisible); |
| for (final ElementValuePairGen element : evs) { |
| a.addElementNameValuePair(element.getElementNameValuePair()); |
| } |
| return a; |
| } |
| |
| public AnnotationEntryGen(final ObjectType type, |
| final List<ElementValuePairGen> elements, final boolean vis, |
| final ConstantPoolGen cpool) { |
| this.cpool = cpool; |
| this.typeIndex = cpool.addUtf8(type.getSignature()); |
| evs = elements; |
| isRuntimeVisible = vis; |
| } |
| |
| public static AnnotationEntryGen read(final DataInput dis, |
| final ConstantPoolGen cpool, final boolean b) throws IOException { |
| final AnnotationEntryGen a = new AnnotationEntryGen(cpool); |
| a.typeIndex = dis.readUnsignedShort(); |
| final int elemValuePairCount = dis.readUnsignedShort(); |
| for (int i = 0; i < elemValuePairCount; i++) { |
| final int nidx = dis.readUnsignedShort(); |
| a.addElementNameValuePair(new ElementValuePairGen(nidx, |
| ElementValueGen.readElementValue(dis, cpool), cpool)); |
| } |
| a.isRuntimeVisible(b); |
| return a; |
| } |
| |
| public void dump(final DataOutputStream dos) throws IOException { |
| dos.writeShort(typeIndex); // u2 index of type name in cpool |
| dos.writeShort(evs.size()); // u2 element_value pair count |
| for (final ElementValuePairGen envp : evs) { |
| envp.dump(dos); |
| } |
| } |
| |
| public void addElementNameValuePair(final ElementValuePairGen evp) { |
| if (evs == null) { |
| evs = new ArrayList<>(); |
| } |
| evs.add(evp); |
| } |
| |
| public int getTypeIndex() { |
| return typeIndex; |
| } |
| |
| public final String getTypeSignature() { |
| // ConstantClass c = (ConstantClass)cpool.getConstant(typeIndex); |
| final ConstantUtf8 utf8 = (ConstantUtf8) cpool |
| .getConstant(typeIndex/* c.getNameIndex() */); |
| return utf8.getBytes(); |
| } |
| |
| public final String getTypeName() { |
| return getTypeSignature();// BCELBUG: Should I use this instead? |
| // Utility.signatureToString(getTypeSignature()); |
| } |
| |
| /** |
| * Returns list of ElementNameValuePair objects |
| */ |
| public List<ElementValuePairGen> getValues() { |
| return evs; |
| } |
| |
| @Override |
| public String toString() { |
| final StringBuilder s = new StringBuilder(32); // CHECKSTYLE IGNORE MagicNumber |
| s.append("AnnotationGen:[").append(getTypeName()).append(" #").append(evs.size()).append(" {"); |
| for (int i = 0; i < evs.size(); i++) { |
| s.append(evs.get(i)); |
| if (i + 1 < evs.size()) { |
| s.append(","); |
| } |
| } |
| s.append("}]"); |
| return s.toString(); |
| } |
| |
| public String toShortString() { |
| final StringBuilder s = new StringBuilder(); |
| s.append("@").append(getTypeName()).append("("); |
| for (int i = 0; i < evs.size(); i++) { |
| s.append(evs.get(i)); |
| if (i + 1 < evs.size()) { |
| s.append(","); |
| } |
| } |
| s.append(")"); |
| return s.toString(); |
| } |
| |
| private void isRuntimeVisible(final boolean b) { |
| isRuntimeVisible = b; |
| } |
| |
| public boolean isRuntimeVisible() { |
| return isRuntimeVisible; |
| } |
| |
| |
| /** |
| * Converts a list of AnnotationGen objects into a set of attributes |
| * that can be attached to the class file. |
| * |
| * @param cp The constant pool gen where we can create the necessary name refs |
| * @param annotationEntryGens An array of AnnotationGen objects |
| */ |
| static Attribute[] getAnnotationAttributes(final ConstantPoolGen cp, final AnnotationEntryGen[] annotationEntryGens) { |
| if (annotationEntryGens.length == 0) { |
| return new Attribute[0]; |
| } |
| |
| try { |
| int countVisible = 0; |
| int countInvisible = 0; |
| |
| // put the annotations in the right output stream |
| for (final AnnotationEntryGen a : annotationEntryGens) { |
| if (a.isRuntimeVisible()) { |
| countVisible++; |
| } else { |
| countInvisible++; |
| } |
| } |
| |
| final ByteArrayOutputStream rvaBytes = new ByteArrayOutputStream(); |
| final ByteArrayOutputStream riaBytes = new ByteArrayOutputStream(); |
| try (DataOutputStream rvaDos = new DataOutputStream(rvaBytes); |
| DataOutputStream riaDos = new DataOutputStream(riaBytes)) { |
| |
| rvaDos.writeShort(countVisible); |
| riaDos.writeShort(countInvisible); |
| |
| // put the annotations in the right output stream |
| for (final AnnotationEntryGen a : annotationEntryGens) { |
| if (a.isRuntimeVisible()) { |
| a.dump(rvaDos); |
| } else { |
| a.dump(riaDos); |
| } |
| } |
| } |
| |
| final byte[] rvaData = rvaBytes.toByteArray(); |
| final byte[] riaData = riaBytes.toByteArray(); |
| |
| int rvaIndex = -1; |
| int riaIndex = -1; |
| |
| if (rvaData.length > 2) { |
| rvaIndex = cp.addUtf8("RuntimeVisibleAnnotations"); |
| } |
| if (riaData.length > 2) { |
| riaIndex = cp.addUtf8("RuntimeInvisibleAnnotations"); |
| } |
| |
| final List<Attribute> newAttributes = new ArrayList<>(); |
| if (rvaData.length > 2) { |
| newAttributes.add( |
| new RuntimeVisibleAnnotations(rvaIndex, rvaData.length, |
| new DataInputStream(new ByteArrayInputStream(rvaData)), cp.getConstantPool())); |
| } |
| if (riaData.length > 2) { |
| newAttributes.add( |
| new RuntimeInvisibleAnnotations(riaIndex, riaData.length, |
| new DataInputStream(new ByteArrayInputStream(riaData)), cp.getConstantPool())); |
| } |
| |
| return newAttributes.toArray(new Attribute[newAttributes.size()]); |
| } catch (final IOException e) { |
| System.err.println("IOException whilst processing annotations. " + |
| e.getMessage()); |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Annotations against a class are stored in one of four attribute kinds: |
| * - RuntimeVisibleParameterAnnotations |
| * - RuntimeInvisibleParameterAnnotations |
| */ |
| static Attribute[] getParameterAnnotationAttributes( |
| final ConstantPoolGen cp, |
| final List<AnnotationEntryGen>[] /*Array of lists, array size depends on #params */vec) { |
| final int[] visCount = new int[vec.length]; |
| int totalVisCount = 0; |
| final int[] invisCount = new int[vec.length]; |
| int totalInvisCount = 0; |
| try { |
| for (int i = 0; i < vec.length; i++) { |
| if (vec[i] != null) { |
| for (final AnnotationEntryGen element : vec[i]) { |
| if (element.isRuntimeVisible()) { |
| visCount[i]++; |
| totalVisCount++; |
| } else { |
| invisCount[i]++; |
| totalInvisCount++; |
| } |
| } |
| } |
| } |
| // Lets do the visible ones |
| final ByteArrayOutputStream rvaBytes = new ByteArrayOutputStream(); |
| try (DataOutputStream rvaDos = new DataOutputStream(rvaBytes)) { |
| rvaDos.writeByte(vec.length); // First goes number of parameters |
| for (int i = 0; i < vec.length; i++) { |
| rvaDos.writeShort(visCount[i]); |
| if (visCount[i] > 0) { |
| for (final AnnotationEntryGen element : vec[i]) { |
| if (element.isRuntimeVisible()) { |
| element.dump(rvaDos); |
| } |
| } |
| } |
| } |
| } |
| // Lets do the invisible ones |
| final ByteArrayOutputStream riaBytes = new ByteArrayOutputStream(); |
| try (DataOutputStream riaDos = new DataOutputStream(riaBytes)) { |
| riaDos.writeByte(vec.length); // First goes number of parameters |
| for (int i = 0; i < vec.length; i++) { |
| riaDos.writeShort(invisCount[i]); |
| if (invisCount[i] > 0) { |
| for (final AnnotationEntryGen element : vec[i]) { |
| if (!element.isRuntimeVisible()) { |
| element.dump(riaDos); |
| } |
| } |
| } |
| } |
| } |
| final byte[] rvaData = rvaBytes.toByteArray(); |
| final byte[] riaData = riaBytes.toByteArray(); |
| int rvaIndex = -1; |
| int riaIndex = -1; |
| if (totalVisCount > 0) { |
| rvaIndex = cp.addUtf8("RuntimeVisibleParameterAnnotations"); |
| } |
| if (totalInvisCount > 0) { |
| riaIndex = cp.addUtf8("RuntimeInvisibleParameterAnnotations"); |
| } |
| final List<Attribute> newAttributes = new ArrayList<>(); |
| if (totalVisCount > 0) { |
| newAttributes |
| .add(new RuntimeVisibleParameterAnnotations(rvaIndex, |
| rvaData.length, |
| new DataInputStream(new ByteArrayInputStream(rvaData)), |
| cp.getConstantPool())); |
| } |
| if (totalInvisCount > 0) { |
| newAttributes |
| .add(new RuntimeInvisibleParameterAnnotations(riaIndex, |
| riaData.length, |
| new DataInputStream(new ByteArrayInputStream(riaData)), |
| cp.getConstantPool())); |
| } |
| return newAttributes.toArray(new Attribute[newAttributes.size()]); |
| } catch (final IOException e) { |
| System.err.println("IOException whilst processing parameter annotations." + |
| e.getMessage()); |
| } |
| return null; |
| } |
| |
| } |