1/*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5/*
6 * Licensed to the Apache Software Foundation (ASF) under one or more
7 * contributor license agreements.  See the NOTICE file distributed with
8 * this work for additional information regarding copyright ownership.
9 * The ASF licenses this file to You under the Apache License, Version 2.0
10 * (the "License"); you may not use this file except in compliance with
11 * the License.  You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
21
22package com.sun.org.apache.bcel.internal.util;
23
24import java.io.IOException;
25import java.io.OutputStream;
26import java.io.PrintWriter;
27import java.util.Locale;
28
29import com.sun.org.apache.bcel.internal.Const;
30import com.sun.org.apache.bcel.internal.Repository;
31import com.sun.org.apache.bcel.internal.classfile.ClassParser;
32import com.sun.org.apache.bcel.internal.classfile.ConstantValue;
33import com.sun.org.apache.bcel.internal.classfile.Field;
34import com.sun.org.apache.bcel.internal.classfile.JavaClass;
35import com.sun.org.apache.bcel.internal.classfile.Method;
36import com.sun.org.apache.bcel.internal.classfile.Utility;
37import com.sun.org.apache.bcel.internal.generic.ArrayType;
38import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
39import com.sun.org.apache.bcel.internal.generic.MethodGen;
40import com.sun.org.apache.bcel.internal.generic.Type;
41
42/**
43 * This class takes a given JavaClass object and converts it to a
44 * Java program that creates that very class using BCEL. This
45 * gives new users of BCEL a useful example showing how things
46 * are done with BCEL. It does not cover all features of BCEL,
47 * but tries to mimic hand-written code as close as possible.
48 *
49 * @version $Id: BCELifier.java 1750228 2016-06-25 21:47:44Z ggregory $
50 */
51public class BCELifier extends com.sun.org.apache.bcel.internal.classfile.EmptyVisitor {
52
53    /**
54     * Enum corresponding to flag source.
55     */
56    public enum FLAGS {
57        UNKNOWN,
58        CLASS,
59        METHOD,
60    }
61
62    // The base package name for imports; assumes Const is at the top level
63    // N.B we use the class so renames will be detected by the compiler/IDE
64    private static final String BASE_PACKAGE = Const.class.getPackage().getName();
65    private static final String CONSTANT_PREFIX = Const.class.getSimpleName()+".";
66
67    private final JavaClass _clazz;
68    private final PrintWriter _out;
69    private final ConstantPoolGen _cp;
70
71    /** @param clazz Java class to "decompile"
72     * @param out where to output Java program
73     */
74    public BCELifier(final JavaClass clazz, final OutputStream out) {
75        _clazz = clazz;
76        _out = new PrintWriter(out);
77        _cp = new ConstantPoolGen(_clazz.getConstantPool());
78    }
79
80
81    /** Start Java code generation
82     */
83    public void start() {
84        visitJavaClass(_clazz);
85        _out.flush();
86    }
87
88
89    @Override
90    public void visitJavaClass( final JavaClass clazz ) {
91        String class_name = clazz.getClassName();
92        final String super_name = clazz.getSuperclassName();
93        final String package_name = clazz.getPackageName();
94        final String inter = Utility.printArray(clazz.getInterfaceNames(), false, true);
95        if (!"".equals(package_name)) {
96            class_name = class_name.substring(package_name.length() + 1);
97            _out.println("package " + package_name + ";");
98            _out.println();
99        }
100        _out.println("import " + BASE_PACKAGE + ".generic.*;");
101        _out.println("import " + BASE_PACKAGE + ".classfile.*;");
102        _out.println("import " + BASE_PACKAGE + ".*;");
103        _out.println("import java.io.*;");
104        _out.println();
105        _out.println("public class " + class_name + "Creator {");
106        _out.println("  private InstructionFactory _factory;");
107        _out.println("  private ConstantPoolGen    _cp;");
108        _out.println("  private ClassGen           _cg;");
109        _out.println();
110        _out.println("  public " + class_name + "Creator() {");
111        _out.println("    _cg = new ClassGen(\""
112                + (("".equals(package_name)) ? class_name : package_name + "." + class_name)
113                + "\", \"" + super_name + "\", " + "\"" + clazz.getSourceFileName() + "\", "
114                + printFlags(clazz.getAccessFlags(), FLAGS.CLASS) + ", "
115                + "new String[] { " + inter + " });");
116        _out.println();
117        _out.println("    _cp = _cg.getConstantPool();");
118        _out.println("    _factory = new InstructionFactory(_cg, _cp);");
119        _out.println("  }");
120        _out.println();
121        printCreate();
122        final Field[] fields = clazz.getFields();
123        if (fields.length > 0) {
124            _out.println("  private void createFields() {");
125            _out.println("    FieldGen field;");
126            for (final Field field : fields) {
127                field.accept(this);
128            }
129            _out.println("  }");
130            _out.println();
131        }
132        final Method[] methods = clazz.getMethods();
133        for (int i = 0; i < methods.length; i++) {
134            _out.println("  private void createMethod_" + i + "() {");
135            methods[i].accept(this);
136            _out.println("  }");
137            _out.println();
138        }
139        printMain();
140        _out.println("}");
141    }
142
143
144    private void printCreate() {
145        _out.println("  public void create(OutputStream out) throws IOException {");
146        final Field[] fields = _clazz.getFields();
147        if (fields.length > 0) {
148            _out.println("    createFields();");
149        }
150        final Method[] methods = _clazz.getMethods();
151        for (int i = 0; i < methods.length; i++) {
152            _out.println("    createMethod_" + i + "();");
153        }
154        _out.println("    _cg.getJavaClass().dump(out);");
155        _out.println("  }");
156        _out.println();
157    }
158
159
160    private void printMain() {
161        final String class_name = _clazz.getClassName();
162        _out.println("  public static void main(String[] args) throws Exception {");
163        _out.println("    " + class_name + "Creator creator = new " + class_name + "Creator();");
164        _out.println("    creator.create(new FileOutputStream(\"" + class_name + ".class\"));");
165        _out.println("  }");
166    }
167
168
169    @Override
170    public void visitField( final Field field ) {
171        _out.println();
172        _out.println("    field = new FieldGen(" + printFlags(field.getAccessFlags()) + ", "
173                + printType(field.getSignature()) + ", \"" + field.getName() + "\", _cp);");
174        final ConstantValue cv = field.getConstantValue();
175        if (cv != null) {
176            final String value = cv.toString();
177            _out.println("    field.setInitValue(" + value + ")");
178        }
179        _out.println("    _cg.addField(field.getField());");
180    }
181
182
183    @Override
184    public void visitMethod( final Method method ) {
185        final MethodGen mg = new MethodGen(method, _clazz.getClassName(), _cp);
186        _out.println("    InstructionList il = new InstructionList();");
187        _out.println("    MethodGen method = new MethodGen("
188                + printFlags(method.getAccessFlags(), FLAGS.METHOD) + ", "
189                + printType(mg.getReturnType()) + ", "
190                + printArgumentTypes(mg.getArgumentTypes()) + ", "
191                + "new String[] { " + Utility.printArray(mg.getArgumentNames(), false, true)
192                + " }, \"" + method.getName() + "\", \"" + _clazz.getClassName() + "\", il, _cp);");
193        _out.println();
194        final BCELFactory factory = new BCELFactory(mg, _out);
195        factory.start();
196        _out.println("    method.setMaxStack();");
197        _out.println("    method.setMaxLocals();");
198        _out.println("    _cg.addMethod(method.getMethod());");
199        _out.println("    il.dispose();");
200    }
201
202
203    static String printFlags( final int flags ) {
204        return printFlags(flags, FLAGS.UNKNOWN);
205    }
206
207    /**
208     * Return a string with the flag settings
209     * @param flags the flags field to interpret
210     * @param location the item type
211     * @return the formatted string
212     * @since 6.0 made public
213     */
214    public static String printFlags( final int flags, final FLAGS location ) {
215        if (flags == 0) {
216            return "0";
217        }
218        final StringBuilder buf = new StringBuilder();
219        for (int i = 0, pow = 1; pow <= Const.MAX_ACC_FLAG; i++) {
220            if ((flags & pow) != 0) {
221                if ((pow == Const.ACC_SYNCHRONIZED) && (location == FLAGS.CLASS)) {
222                    buf.append(CONSTANT_PREFIX+"ACC_SUPER | ");
223                } else if ((pow == Const.ACC_VOLATILE) && (location == FLAGS.METHOD)) {
224                    buf.append(CONSTANT_PREFIX+"ACC_BRIDGE | ");
225                } else if ((pow == Const.ACC_TRANSIENT) && (location == FLAGS.METHOD)) {
226                    buf.append(CONSTANT_PREFIX+"ACC_VARARGS | ");
227                } else {
228                    if (i < Const.ACCESS_NAMES_LENGTH) {
229                        buf.append(CONSTANT_PREFIX+"ACC_")
230                                .append(Const.getAccessName(i).toUpperCase(Locale.ENGLISH))
231                                .append( " | ");
232                    } else {
233                        buf.append(String.format (CONSTANT_PREFIX+"ACC_BIT %x | ", pow));
234                    }
235                }
236            }
237            pow <<= 1;
238        }
239        final String str = buf.toString();
240        return str.substring(0, str.length() - 3);
241    }
242
243
244    static String printArgumentTypes( final Type[] arg_types ) {
245        if (arg_types.length == 0) {
246            return "Type.NO_ARGS";
247        }
248        final StringBuilder args = new StringBuilder();
249        for (int i = 0; i < arg_types.length; i++) {
250            args.append(printType(arg_types[i]));
251            if (i < arg_types.length - 1) {
252                args.append(", ");
253            }
254        }
255        return "new Type[] { " + args.toString() + " }";
256    }
257
258
259    static String printType( final Type type ) {
260        return printType(type.getSignature());
261    }
262
263
264    static String printType( final String signature ) {
265        final Type type = Type.getType(signature);
266        final byte t = type.getType();
267        if (t <= Const.T_VOID) {
268            return "Type." + Const.getTypeName(t).toUpperCase(Locale.ENGLISH);
269        } else if (type.toString().equals("java.lang.String")) {
270            return "Type.STRING";
271        } else if (type.toString().equals("java.lang.Object")) {
272            return "Type.OBJECT";
273        } else if (type.toString().equals("java.lang.StringBuffer")) {
274            return "Type.STRINGBUFFER";
275        } else if (type instanceof ArrayType) {
276            final ArrayType at = (ArrayType) type;
277            return "new ArrayType(" + printType(at.getBasicType()) + ", " + at.getDimensions()
278                    + ")";
279        } else {
280            return "new ObjectType(\"" + Utility.signatureToString(signature, false) + "\")";
281        }
282    }
283
284
285    /** Default main method
286     */
287    public static void _main( final String[] argv ) throws Exception {
288        if (argv.length != 1) {
289            System.out.println("Usage: BCELifier classname");
290            System.out.println("\tThe class must exist on the classpath");
291            return;
292        }
293        final JavaClass java_class = getJavaClass(argv[0]);
294        final BCELifier bcelifier = new BCELifier(java_class, System.out);
295        bcelifier.start();
296    }
297
298
299    // Needs to be accessible from unit test code
300    static JavaClass getJavaClass(final String name) throws ClassNotFoundException, IOException {
301        JavaClass java_class;
302        if ((java_class = Repository.lookupClass(name)) == null) {
303            java_class = new ClassParser(name).parse(); // May throw IOException
304        }
305        return java_class;
306    }
307}
308