Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 *  Unless required by applicable law or agreed to in writing, software
012 *  distributed under the License is distributed on an "AS IS" BASIS,
013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 *  See the License for the specific language governing permissions and
015 *  limitations under the License.
016 */
017package org.apache.bcel.generic;
018
019import java.io.ByteArrayInputStream;
020import java.io.ByteArrayOutputStream;
021import java.io.DataInput;
022import java.io.DataInputStream;
023import java.io.DataOutputStream;
024import java.io.IOException;
025import java.util.ArrayList;
026import java.util.List;
027import java.util.stream.Collectors;
028
029import org.apache.bcel.classfile.AnnotationEntry;
030import org.apache.bcel.classfile.Attribute;
031import org.apache.bcel.classfile.ConstantUtf8;
032import org.apache.bcel.classfile.ElementValuePair;
033import org.apache.bcel.classfile.RuntimeInvisibleAnnotations;
034import org.apache.bcel.classfile.RuntimeInvisibleParameterAnnotations;
035import org.apache.bcel.classfile.RuntimeVisibleAnnotations;
036import org.apache.bcel.classfile.RuntimeVisibleParameterAnnotations;
037import org.apache.commons.lang3.ArrayUtils;
038import org.apache.commons.lang3.stream.Streams;
039
040/**
041 * @since 6.0
042 */
043public class AnnotationEntryGen {
044
045    static final AnnotationEntryGen[] EMPTY_ARRAY = {};
046
047    /**
048     * Converts a list of AnnotationGen objects into a set of attributes that can be attached to the class file.
049     *
050     * @param cp The constant pool gen where we can create the necessary name refs
051     * @param annotationEntryGens An array of AnnotationGen objects
052     */
053    static Attribute[] getAnnotationAttributes(final ConstantPoolGen cp, final AnnotationEntryGen[] annotationEntryGens) {
054        if (ArrayUtils.isEmpty(annotationEntryGens)) {
055            return Attribute.EMPTY_ARRAY;
056        }
057
058        try {
059            int countVisible = 0;
060            int countInvisible = 0;
061
062            // put the annotations in the right output stream
063            for (final AnnotationEntryGen a : annotationEntryGens) {
064                if (a.isRuntimeVisible()) {
065                    countVisible++;
066                } else {
067                    countInvisible++;
068                }
069            }
070
071            final ByteArrayOutputStream rvaBytes = new ByteArrayOutputStream();
072            final ByteArrayOutputStream riaBytes = new ByteArrayOutputStream();
073            try (DataOutputStream rvaDos = new DataOutputStream(rvaBytes); DataOutputStream riaDos = new DataOutputStream(riaBytes)) {
074
075                rvaDos.writeShort(countVisible);
076                riaDos.writeShort(countInvisible);
077
078                // put the annotations in the right output stream
079                for (final AnnotationEntryGen a : annotationEntryGens) {
080                    if (a.isRuntimeVisible()) {
081                        a.dump(rvaDos);
082                    } else {
083                        a.dump(riaDos);
084                    }
085                }
086            }
087
088            final byte[] rvaData = rvaBytes.toByteArray();
089            final byte[] riaData = riaBytes.toByteArray();
090
091            int rvaIndex = -1;
092            int riaIndex = -1;
093
094            if (rvaData.length > 2) {
095                rvaIndex = cp.addUtf8("RuntimeVisibleAnnotations");
096            }
097            if (riaData.length > 2) {
098                riaIndex = cp.addUtf8("RuntimeInvisibleAnnotations");
099            }
100
101            final List<Attribute> newAttributes = new ArrayList<>();
102            if (rvaData.length > 2) {
103                newAttributes
104                    .add(new RuntimeVisibleAnnotations(rvaIndex, rvaData.length, new DataInputStream(new ByteArrayInputStream(rvaData)), cp.getConstantPool()));
105            }
106            if (riaData.length > 2) {
107                newAttributes.add(
108                    new RuntimeInvisibleAnnotations(riaIndex, riaData.length, new DataInputStream(new ByteArrayInputStream(riaData)), cp.getConstantPool()));
109            }
110
111            return newAttributes.toArray(Attribute.EMPTY_ARRAY);
112        } catch (final IOException e) {
113            System.err.println("IOException whilst processing annotations");
114            e.printStackTrace();
115        }
116        return null;
117    }
118
119    /**
120     * Annotations against a class are stored in one of four attribute kinds: - RuntimeVisibleParameterAnnotations -
121     * RuntimeInvisibleParameterAnnotations
122     */
123    static Attribute[] getParameterAnnotationAttributes(final ConstantPoolGen cp,
124        final List<AnnotationEntryGen>[] /* Array of lists, array size depends on #params */ vec) {
125        final int[] visCount = new int[vec.length];
126        int totalVisCount = 0;
127        final int[] invisCount = new int[vec.length];
128        int totalInvisCount = 0;
129        try {
130            for (int i = 0; i < vec.length; i++) {
131                if (vec[i] != null) {
132                    for (final AnnotationEntryGen element : vec[i]) {
133                        if (element.isRuntimeVisible()) {
134                            visCount[i]++;
135                            totalVisCount++;
136                        } else {
137                            invisCount[i]++;
138                            totalInvisCount++;
139                        }
140                    }
141                }
142            }
143            // Lets do the visible ones
144            final ByteArrayOutputStream rvaBytes = new ByteArrayOutputStream();
145            try (DataOutputStream rvaDos = new DataOutputStream(rvaBytes)) {
146                rvaDos.writeByte(vec.length); // First goes number of parameters
147                for (int i = 0; i < vec.length; i++) {
148                    rvaDos.writeShort(visCount[i]);
149                    if (visCount[i] > 0) {
150                        for (final AnnotationEntryGen element : vec[i]) {
151                            if (element.isRuntimeVisible()) {
152                                element.dump(rvaDos);
153                            }
154                        }
155                    }
156                }
157            }
158            // Lets do the invisible ones
159            final ByteArrayOutputStream riaBytes = new ByteArrayOutputStream();
160            try (DataOutputStream riaDos = new DataOutputStream(riaBytes)) {
161                riaDos.writeByte(vec.length); // First goes number of parameters
162                for (int i = 0; i < vec.length; i++) {
163                    riaDos.writeShort(invisCount[i]);
164                    if (invisCount[i] > 0) {
165                        for (final AnnotationEntryGen element : vec[i]) {
166                            if (!element.isRuntimeVisible()) {
167                                element.dump(riaDos);
168                            }
169                        }
170                    }
171                }
172            }
173            final byte[] rvaData = rvaBytes.toByteArray();
174            final byte[] riaData = riaBytes.toByteArray();
175            int rvaIndex = -1;
176            int riaIndex = -1;
177            if (totalVisCount > 0) {
178                rvaIndex = cp.addUtf8("RuntimeVisibleParameterAnnotations");
179            }
180            if (totalInvisCount > 0) {
181                riaIndex = cp.addUtf8("RuntimeInvisibleParameterAnnotations");
182            }
183            final List<Attribute> newAttributes = new ArrayList<>();
184            if (totalVisCount > 0) {
185                newAttributes.add(new RuntimeVisibleParameterAnnotations(rvaIndex, rvaData.length, new DataInputStream(new ByteArrayInputStream(rvaData)),
186                    cp.getConstantPool()));
187            }
188            if (totalInvisCount > 0) {
189                newAttributes.add(new RuntimeInvisibleParameterAnnotations(riaIndex, riaData.length, new DataInputStream(new ByteArrayInputStream(riaData)),
190                    cp.getConstantPool()));
191            }
192            return newAttributes.toArray(Attribute.EMPTY_ARRAY);
193        } catch (final IOException e) {
194            System.err.println("IOException whilst processing parameter annotations");
195            e.printStackTrace();
196        }
197        return null;
198    }
199
200    public static AnnotationEntryGen read(final DataInput dis, final ConstantPoolGen cpool, final boolean b) throws IOException {
201        final AnnotationEntryGen a = new AnnotationEntryGen(cpool);
202        a.typeIndex = dis.readUnsignedShort();
203        final int elemValuePairCount = dis.readUnsignedShort();
204        for (int i = 0; i < elemValuePairCount; i++) {
205            final int nidx = dis.readUnsignedShort();
206            a.addElementNameValuePair(new ElementValuePairGen(nidx, ElementValueGen.readElementValue(dis, cpool), cpool));
207        }
208        a.isRuntimeVisible(b);
209        return a;
210    }
211
212    private int typeIndex;
213
214    private List<ElementValuePairGen> evs;
215
216    private final ConstantPoolGen cpool;
217
218    private boolean isRuntimeVisible;
219
220    /**
221     * Here we are taking a fixed annotation of type Annotation and building a modifiable AnnotationGen object. If the pool
222     * passed in is for a different class file, then copyPoolEntries should have been passed as true as that will force us
223     * to do a deep copy of the annotation and move the cpool entries across. We need to copy the type and the element name
224     * value pairs and the visibility.
225     */
226    public AnnotationEntryGen(final AnnotationEntry a, final ConstantPoolGen cpool, final boolean copyPoolEntries) {
227        this.cpool = cpool;
228        if (copyPoolEntries) {
229            typeIndex = cpool.addUtf8(a.getAnnotationType());
230        } else {
231            typeIndex = a.getAnnotationTypeIndex();
232        }
233        isRuntimeVisible = a.isRuntimeVisible();
234        evs = copyValues(a.getElementValuePairs(), cpool, copyPoolEntries);
235    }
236
237    private AnnotationEntryGen(final ConstantPoolGen cpool) {
238        this.cpool = cpool;
239    }
240
241    public AnnotationEntryGen(final ObjectType type, final List<ElementValuePairGen> elements, final boolean vis, final ConstantPoolGen cpool) {
242        this.cpool = cpool;
243        this.typeIndex = cpool.addUtf8(type.getSignature());
244        evs = elements;
245        isRuntimeVisible = vis;
246    }
247
248    public void addElementNameValuePair(final ElementValuePairGen evp) {
249        if (evs == null) {
250            evs = new ArrayList<>();
251        }
252        evs.add(evp);
253    }
254
255    private List<ElementValuePairGen> copyValues(final ElementValuePair[] in, final ConstantPoolGen cpool, final boolean copyPoolEntries) {
256        return Streams.of(in).map(nvp -> new ElementValuePairGen(nvp, cpool, copyPoolEntries)).collect(Collectors.toList());
257    }
258
259    public void dump(final DataOutputStream dos) throws IOException {
260        dos.writeShort(typeIndex); // u2 index of type name in cpool
261        dos.writeShort(evs.size()); // u2 element_value pair count
262        for (final ElementValuePairGen envp : evs) {
263            envp.dump(dos);
264        }
265    }
266
267    /**
268     * Retrieve an immutable version of this AnnotationGen
269     */
270    public AnnotationEntry getAnnotation() {
271        final AnnotationEntry a = new AnnotationEntry(typeIndex, cpool.getConstantPool(), isRuntimeVisible);
272        for (final ElementValuePairGen element : evs) {
273            a.addElementNameValuePair(element.getElementNameValuePair());
274        }
275        return a;
276    }
277
278    public int getTypeIndex() {
279        return typeIndex;
280    }
281
282    public final String getTypeName() {
283        return getTypeSignature(); // BCELBUG: Should I use this instead?
284        // Utility.signatureToString(getTypeSignature());
285    }
286
287    public final String getTypeSignature() {
288        // ConstantClass c = (ConstantClass) cpool.getConstant(typeIndex);
289        final ConstantUtf8 utf8 = (ConstantUtf8) cpool.getConstant(typeIndex/* c.getNameIndex() */);
290        return utf8.getBytes();
291    }
292
293    /**
294     * Returns list of ElementNameValuePair objects.
295     *
296     * @return list of ElementNameValuePair objects.
297     */
298    public List<ElementValuePairGen> getValues() {
299        return evs;
300    }
301
302    public boolean isRuntimeVisible() {
303        return isRuntimeVisible;
304    }
305
306    private void isRuntimeVisible(final boolean b) {
307        isRuntimeVisible = b;
308    }
309
310    public String toShortString() {
311        final StringBuilder s = new StringBuilder();
312        s.append("@").append(getTypeName()).append("(");
313        for (int i = 0; i < evs.size(); i++) {
314            s.append(evs.get(i));
315            if (i + 1 < evs.size()) {
316                s.append(",");
317            }
318        }
319        s.append(")");
320        return s.toString();
321    }
322
323    @Override
324    public String toString() {
325        final StringBuilder s = new StringBuilder(32); // CHECKSTYLE IGNORE MagicNumber
326        s.append("AnnotationGen:[").append(getTypeName()).append(" #").append(evs.size()).append(" {");
327        for (int i = 0; i < evs.size(); i++) {
328            s.append(evs.get(i));
329            if (i + 1 < evs.size()) {
330                s.append(",");
331            }
332        }
333        s.append("}]");
334        return s.toString();
335    }
336
337}