1 /*

     2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 package jdk.experimental.bytecode;

    25 

    26 import java.util.function.Consumer;

    27 import java.util.function.ToIntBiFunction;

    28 

    29 public class AnnotationsBuilder<S, T, E> extends AbstractBuilder<S, T, E, AnnotationsBuilder<S, T, E>> {

    30 

    31     GrowableByteBuffer annoAttribute;

    32     int nannos;

    33 

    34     AnnotationsBuilder(PoolHelper<S, T, E> poolHelper, TypeHelper<S, T> typeHelper) {

    35         super(poolHelper, typeHelper);

    36         this.annoAttribute = new GrowableByteBuffer();

    37         annoAttribute.writeChar(0);

    38     }

    39 

    40     public enum Kind {

    41         RUNTIME_VISIBLE,

    42         RUNTIME_INVISIBLE;

    43     }

    44 

    45     enum Tag {

    46         B('B'),

    47         C('C'),

    48         D('D'),

    49         F('F'),

    50         I('I'),

    51         J('J'),

    52         S('S'),

    53         Z('Z'),

    54         STRING('s'),

    55         ENUM('e'),

    56         CLASS('c'),

    57         ANNO('@'),

    58         ARRAY('[');

    59 

    60         char tagChar;

    61 

    62         Tag(char tagChar) {

    63             this.tagChar = tagChar;

    64         }

    65     }

    66 

    67     AnnotationsBuilder<S, T, E> withAnnotation(T annoType, Consumer<? super AnnotationElementBuilder> annotationBuilder) {

    68         annoAttribute.writeChar(poolHelper.putType(annoType));

    69         int offset = annoAttribute.offset;

    70         annoAttribute.writeChar(0);

    71         if (annotationBuilder != null) {

    72             AnnotationElementBuilder _builder = new AnnotationElementBuilder();

    73             int nelems = _builder.withElements(annotationBuilder);

    74             patchCharAt(offset, nelems);

    75         }

    76         nannos++;

    77         return this;

    78     }

    79 

    80     byte[] build() {

    81         patchCharAt(0, nannos);

    82         return annoAttribute.bytes();

    83     }

    84 

    85     private void patchCharAt(int offset, int newChar) {

    86         int prevOffset = annoAttribute.offset;

    87         try {

    88             annoAttribute.offset = offset;

    89             annoAttribute.writeChar(newChar);

    90         } finally {

    91             annoAttribute.offset = prevOffset;

    92         }

    93     }

    94 

    95     @SuppressWarnings({"unchecked", "rawtypes"})

    96     static Consumer NO_BUILDER =

    97             new Consumer() {

    98                 @Override

    99                 public void accept(Object o) {

   100                     //do nothing

   101                 }

   102             };

   103 

   104     public class AnnotationElementBuilder {

   105 

   106         int nelems;

   107 

   108         public AnnotationElementBuilder withString(String name, String s) {

   109             annoAttribute.writeChar(poolHelper.putUtf8(name));

   110             writeStringValue(s);

   111             return this;

   112         }

   113 

   114         private void writeStringValue(String s) {

   115             annoAttribute.writeByte(Tag.STRING.tagChar);

   116             annoAttribute.writeChar(poolHelper.putUtf8(s));

   117             nelems++;

   118         }

   119 

   120         public AnnotationElementBuilder withClass(String name, T s) {

   121             annoAttribute.writeChar(poolHelper.putUtf8(name));

   122             writeClassValue(s);

   123             return this;

   124         }

   125 

   126         private void writeClassValue(T s) {

   127             annoAttribute.writeByte(Tag.CLASS.tagChar);

   128             annoAttribute.writeChar(poolHelper.putType(s));

   129             nelems++;

   130         }

   131 

   132         public AnnotationElementBuilder withEnum(String name, T enumType, int constant) {

   133             annoAttribute.writeChar(poolHelper.putUtf8(name));

   134             writeEnumValue(enumType, constant);

   135             return this;

   136         }

   137 

   138         private void writeEnumValue(T enumType, int constant) {

   139             annoAttribute.writeByte(Tag.ENUM.tagChar);

   140             annoAttribute.writeChar(poolHelper.putType(enumType));

   141             annoAttribute.writeChar(constant);

   142             nelems++;

   143         }

   144 

   145         public AnnotationElementBuilder withAnnotation(String name, T annoType, Consumer<? super AnnotationElementBuilder> annotationBuilder) {

   146             annoAttribute.writeChar(poolHelper.putUtf8(name));

   147             writeAnnotationValue(annoType, annotationBuilder);

   148             return this;

   149         }

   150 

   151         private void writeAnnotationValue(T annoType, Consumer<? super AnnotationElementBuilder> annotationBuilder) {

   152             annoAttribute.writeByte(Tag.ANNO.tagChar);

   153             annoAttribute.writeChar(poolHelper.putType(annoType));

   154             int offset = annoAttribute.offset;

   155             annoAttribute.writeChar(0);

   156             int nelems = withNestedElements(annotationBuilder);

   157             patchCharAt(offset, nelems);

   158             this.nelems++;

   159         }

   160 

   161         public AnnotationElementBuilder withPrimitive(String name, char c) {

   162             annoAttribute.writeChar(poolHelper.putUtf8(name));

   163             writePrimitiveValue(Tag.C, (int)c, PoolHelper::putInt);

   164             return this;

   165         }

   166 

   167         public AnnotationElementBuilder withPrimitive(String name, short s) {

   168             annoAttribute.writeChar(poolHelper.putUtf8(name));

   169             writePrimitiveValue(Tag.S, (int)s, PoolHelper::putInt);

   170             return this;

   171         }

   172 

   173         public AnnotationElementBuilder withPrimitive(String name, byte b) {

   174             annoAttribute.writeChar(poolHelper.putUtf8(name));

   175             writePrimitiveValue(Tag.B, (int)b, PoolHelper::putInt);

   176             return this;

   177         }

   178 

   179         public AnnotationElementBuilder withPrimitive(String name, int i) {

   180             annoAttribute.writeChar(poolHelper.putUtf8(name));

   181             writePrimitiveValue(Tag.I, i, PoolHelper::putInt);

   182             return this;

   183         }

   184 

   185         public AnnotationElementBuilder withPrimitive(String name, float f) {

   186             annoAttribute.writeChar(poolHelper.putUtf8(name));

   187             writePrimitiveValue(Tag.F, f, PoolHelper::putFloat);

   188             return this;

   189         }

   190 

   191         public AnnotationElementBuilder withPrimitive(String name, long l) {

   192             annoAttribute.writeChar(poolHelper.putUtf8(name));

   193             writePrimitiveValue(Tag.J, l, PoolHelper::putLong);

   194             return this;

   195         }

   196 

   197         public AnnotationElementBuilder withPrimitive(String name, double d) {

   198             annoAttribute.writeChar(poolHelper.putUtf8(name));

   199             writePrimitiveValue(Tag.D, d, PoolHelper::putDouble);

   200             return this;

   201         }

   202 

   203         public AnnotationElementBuilder withPrimitive(String name, boolean b) {

   204             annoAttribute.writeChar(poolHelper.putUtf8(name));

   205             writePrimitiveValue(Tag.Z, b ? 1 : 0, PoolHelper::putInt);

   206             return this;

   207         }

   208 

   209         private <Z> void writePrimitiveValue(Tag tag, Z value, ToIntBiFunction<PoolHelper<S, T, E>, Z> poolFunc) {

   210             annoAttribute.writeByte(tag.tagChar);

   211             annoAttribute.writeChar(poolFunc.applyAsInt(poolHelper, value));

   212             nelems++;

   213         }

   214 

   215         AnnotationElementBuilder withStrings(String name, String... ss) {

   216             annoAttribute.writeChar(poolHelper.putUtf8(name));

   217             annoAttribute.writeChar(ss.length);

   218             for (String s : ss) {

   219                 writeStringValue(s);

   220             }

   221             return this;

   222         }

   223 

   224         @SuppressWarnings("unchecked")

   225         AnnotationElementBuilder withClasses(String name, T... cc) {

   226             annoAttribute.writeChar(poolHelper.putUtf8(name));

   227             annoAttribute.writeChar(cc.length);

   228             for (T c : cc) {

   229                 writeClassValue(c);

   230             }

   231             return this;

   232         }

   233 

   234         AnnotationElementBuilder withEnums(String name, T enumType, int... constants) {

   235             annoAttribute.writeChar(poolHelper.putUtf8(name));

   236             annoAttribute.writeChar(constants.length);

   237             for (int c : constants) {

   238                 writeEnumValue(enumType, c);

   239             }

   240             return this;

   241         }

   242 

   243         @SuppressWarnings("unchecked")

   244         public AnnotationElementBuilder withAnnotations(String name, T annoType, Consumer<? super AnnotationElementBuilder>... annotationBuilders) {

   245             annoAttribute.writeChar(poolHelper.putUtf8(name));

   246             annoAttribute.writeChar(annotationBuilders.length);

   247             for (Consumer<? super AnnotationElementBuilder> annotationBuilder : annotationBuilders) {

   248                 writeAnnotationValue(annoType, annotationBuilder);

   249             }

   250             return this;

   251         }

   252 

   253         public AnnotationElementBuilder withPrimitives(String name, char... cc) {

   254             annoAttribute.writeChar(poolHelper.putUtf8(name));

   255             annoAttribute.writeChar(cc.length);

   256             for (char c : cc) {

   257                 writePrimitiveValue(Tag.C, (int)c, PoolHelper::putInt);

   258             }

   259             return this;

   260         }

   261 

   262         public AnnotationElementBuilder withPrimitives(String name, short... ss) {

   263             annoAttribute.writeChar(poolHelper.putUtf8(name));

   264             annoAttribute.writeChar(ss.length);

   265             for (short s : ss) {

   266                 writePrimitiveValue(Tag.S, (int)s, PoolHelper::putInt);

   267             }

   268             return this;

   269         }

   270 

   271         public AnnotationElementBuilder withPrimitives(String name, byte... bb) {

   272             annoAttribute.writeChar(poolHelper.putUtf8(name));

   273             annoAttribute.writeChar(bb.length);

   274             for (byte b : bb) {

   275                 writePrimitiveValue(Tag.B, (int)b, PoolHelper::putInt);

   276             }

   277             return this;

   278         }

   279 

   280         public AnnotationElementBuilder withPrimitives(String name, int... ii) {

   281             annoAttribute.writeChar(poolHelper.putUtf8(name));

   282             annoAttribute.writeChar(ii.length);

   283             for (int i : ii) {

   284                 writePrimitiveValue(Tag.I, i,  PoolHelper::putInt);

   285             }

   286             return this;

   287         }

   288 

   289         public AnnotationElementBuilder withPrimitives(String name, float... ff) {

   290             annoAttribute.writeChar(poolHelper.putUtf8(name));

   291             annoAttribute.writeChar(ff.length);

   292             for (float f : ff) {

   293                 writePrimitiveValue(Tag.F, f, PoolHelper::putFloat);

   294             }

   295             return this;

   296         }

   297 

   298         public AnnotationElementBuilder withPrimitives(String name, long... ll) {

   299             annoAttribute.writeChar(poolHelper.putUtf8(name));

   300             annoAttribute.writeChar(ll.length);

   301             for (long l : ll) {

   302                 writePrimitiveValue(Tag.J, l, PoolHelper::putLong);

   303             }

   304             return this;

   305         }

   306 

   307         public AnnotationElementBuilder withPrimitives(String name, double... dd) {

   308             annoAttribute.writeChar(poolHelper.putUtf8(name));

   309             annoAttribute.writeChar(dd.length);

   310             for (double d : dd) {

   311                 writePrimitiveValue(Tag.D, d, PoolHelper::putDouble);

   312             }

   313             return this;

   314         }

   315 

   316         public AnnotationElementBuilder withPrimitives(String name, boolean... bb) {

   317             annoAttribute.writeChar(poolHelper.putUtf8(name));

   318             annoAttribute.writeChar(bb.length);

   319             for (boolean b : bb) {

   320                 writePrimitiveValue(Tag.Z, b ? 1 : 0, PoolHelper::putInt);

   321             }

   322             return this;

   323         }

   324 

   325         int withNestedElements(Consumer<? super AnnotationElementBuilder> annotationBuilder) {

   326             return withElements(new AnnotationElementBuilder(), annotationBuilder);

   327         }

   328 

   329         int withElements(Consumer<? super AnnotationElementBuilder> annotationBuilder) {

   330             return withElements(this, annotationBuilder);

   331         }

   332 

   333         private int withElements(AnnotationElementBuilder builder, Consumer<? super AnnotationElementBuilder> annotationBuilder) {

   334             annotationBuilder.accept(builder);

   335             return builder.nelems;

   336         }

   337     }

   338 }