ConstructorGenerator.java revision 1354:a5e202d6eb99 
1/*
2 * Copyright (c) 2010, 2013, 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.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package jdk.nashorn.internal.tools.nasgen;
27
28import static jdk.internal.org.objectweb.asm.Opcodes.ACC_FINAL;
29import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
30import static jdk.internal.org.objectweb.asm.Opcodes.H_INVOKESTATIC;
31import static jdk.internal.org.objectweb.asm.Opcodes.V1_7;
32import static jdk.nashorn.internal.tools.nasgen.StringConstants.CONSTRUCTOR_SUFFIX;
33import static jdk.nashorn.internal.tools.nasgen.StringConstants.DEFAULT_INIT_DESC;
34import static jdk.nashorn.internal.tools.nasgen.StringConstants.INIT;
35import static jdk.nashorn.internal.tools.nasgen.StringConstants.OBJECT_DESC;
36import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_DESC;
37import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_FIELD_NAME;
38import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_SETCONSTRUCTOR;
39import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_SETCONSTRUCTOR_DESC;
40import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_TYPE;
41import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_INIT_DESC3;
42import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_INIT_DESC4;
43import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_TYPE;
44import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETARITY;
45import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETARITY_DESC;
46import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETPROTOTYPE;
47import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETPROTOTYPE_DESC;
48import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_TYPE;
49import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_INIT_DESC;
50import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_TYPE;
51
52import java.io.FileOutputStream;
53import java.io.IOException;
54import java.util.List;
55import jdk.internal.org.objectweb.asm.Handle;
56
57/**
58 * This class generates constructor class for a @ScriptClass annotated class.
59 *
60 */
61public class ConstructorGenerator extends ClassGenerator {
62    private final ScriptClassInfo scriptClassInfo;
63    private final String className;
64    private final MemberInfo constructor;
65    private final int memberCount;
66    private final List<MemberInfo> specs;
67
68    ConstructorGenerator(final ScriptClassInfo sci) {
69        this.scriptClassInfo = sci;
70
71        this.className = scriptClassInfo.getConstructorClassName();
72        this.constructor = scriptClassInfo.getConstructor();
73        this.memberCount = scriptClassInfo.getConstructorMemberCount();
74        this.specs = scriptClassInfo.getSpecializedConstructors();
75    }
76
77    byte[] getClassBytes() {
78        // new class extending from ScriptObject
79        final String superClass = (constructor != null)? SCRIPTFUNCTIONIMPL_TYPE : SCRIPTOBJECT_TYPE;
80        cw.visit(V1_7, ACC_FINAL, className, null, superClass, null);
81        if (memberCount > 0) {
82            // add fields
83            emitFields();
84            // add <clinit>
85            emitStaticInitializer();
86        }
87        // add <init>
88        emitConstructor();
89
90        if (constructor == null) {
91            emitGetClassName(scriptClassInfo.getName());
92        }
93
94        cw.visitEnd();
95        return cw.toByteArray();
96    }
97
98    // --Internals only below this point
99    private void emitFields() {
100        // Introduce "Function" type instance fields for each
101        // constructor @Function in script class and introduce instance
102        // fields for each constructor @Property in the script class.
103        for (MemberInfo memInfo : scriptClassInfo.getMembers()) {
104            if (memInfo.isConstructorFunction()) {
105                addFunctionField(memInfo.getJavaName());
106                memInfo = (MemberInfo)memInfo.clone();
107                memInfo.setJavaDesc(OBJECT_DESC);
108                memInfo.setJavaAccess(ACC_PUBLIC);
109                addGetter(className, memInfo);
110                addSetter(className, memInfo);
111            } else if (memInfo.isConstructorProperty()) {
112                if (memInfo.isStaticFinal()) {
113                    addGetter(scriptClassInfo.getJavaName(), memInfo);
114                } else {
115                    addField(memInfo.getJavaName(), memInfo.getJavaDesc());
116                    memInfo = (MemberInfo)memInfo.clone();
117                    memInfo.setJavaAccess(ACC_PUBLIC);
118                    addGetter(className, memInfo);
119                    addSetter(className, memInfo);
120                }
121            }
122        }
123
124        addMapField();
125    }
126
127    private void emitStaticInitializer() {
128        final MethodGenerator mi = makeStaticInitializer();
129        emitStaticInitPrefix(mi, className, memberCount);
130
131        for (final MemberInfo memInfo : scriptClassInfo.getMembers()) {
132            if (memInfo.isConstructorFunction() || memInfo.isConstructorProperty()) {
133                linkerAddGetterSetter(mi, className, memInfo);
134            } else if (memInfo.isConstructorGetter()) {
135                final MemberInfo setter = scriptClassInfo.findSetter(memInfo);
136                linkerAddGetterSetter(mi, scriptClassInfo.getJavaName(), memInfo, setter);
137            }
138        }
139        emitStaticInitSuffix(mi, className);
140    }
141
142    private void emitConstructor() {
143        final MethodGenerator mi = makeConstructor();
144        mi.visitCode();
145        callSuper(mi);
146
147        if (memberCount > 0) {
148            // initialize Function type fields
149            initFunctionFields(mi);
150            // initialize data fields
151            initDataFields(mi);
152        }
153
154        if (constructor != null) {
155            initPrototype(mi);
156            final int arity = constructor.getArity();
157            if (arity != MemberInfo.DEFAULT_ARITY) {
158                mi.loadThis();
159                mi.push(arity);
160                mi.invokeVirtual(SCRIPTFUNCTION_TYPE, SCRIPTFUNCTION_SETARITY,
161                        SCRIPTFUNCTION_SETARITY_DESC);
162            }
163        }
164        mi.returnVoid();
165        mi.computeMaxs();
166        mi.visitEnd();
167    }
168
169    private void loadMap(final MethodGenerator mi) {
170        if (memberCount > 0) {
171            mi.getStatic(className, PROPERTYMAP_FIELD_NAME, PROPERTYMAP_DESC);
172        }
173    }
174
175    private void callSuper(final MethodGenerator mi) {
176        String superClass, superDesc;
177        mi.loadThis();
178        if (constructor == null) {
179            // call ScriptObject.<init>
180            superClass = SCRIPTOBJECT_TYPE;
181            superDesc = (memberCount > 0) ? SCRIPTOBJECT_INIT_DESC : DEFAULT_INIT_DESC;
182            loadMap(mi);
183        } else {
184            // call Function.<init>
185            superClass = SCRIPTFUNCTIONIMPL_TYPE;
186            superDesc = (memberCount > 0) ? SCRIPTFUNCTIONIMPL_INIT_DESC4 : SCRIPTFUNCTIONIMPL_INIT_DESC3;
187            mi.loadLiteral(constructor.getName());
188            mi.visitLdcInsn(new Handle(H_INVOKESTATIC, scriptClassInfo.getJavaName(), constructor.getJavaName(), constructor.getJavaDesc()));
189            loadMap(mi);
190            mi.memberInfoArray(scriptClassInfo.getJavaName(), specs); //pushes null if specs empty
191        }
192
193        mi.invokeSpecial(superClass, INIT, superDesc);
194    }
195
196    private void initFunctionFields(final MethodGenerator mi) {
197        assert memberCount > 0;
198        for (final MemberInfo memInfo : scriptClassInfo.getMembers()) {
199            if (!memInfo.isConstructorFunction()) {
200                continue;
201            }
202            mi.loadThis();
203            newFunction(mi, scriptClassInfo.getJavaName(), memInfo, scriptClassInfo.findSpecializations(memInfo.getJavaName()));
204            mi.putField(className, memInfo.getJavaName(), OBJECT_DESC);
205        }
206    }
207
208    private void initDataFields(final MethodGenerator mi) {
209        assert memberCount > 0;
210        for (final MemberInfo memInfo : scriptClassInfo.getMembers()) {
211           if (!memInfo.isConstructorProperty() || memInfo.isFinal()) {
212               continue;
213           }
214           final Object value = memInfo.getValue();
215           if (value != null) {
216               mi.loadThis();
217               mi.loadLiteral(value);
218               mi.putField(className, memInfo.getJavaName(), memInfo.getJavaDesc());
219           } else if (!memInfo.getInitClass().isEmpty()) {
220               final String clazz = memInfo.getInitClass();
221               mi.loadThis();
222               mi.newObject(clazz);
223               mi.dup();
224               mi.invokeSpecial(clazz, INIT, DEFAULT_INIT_DESC);
225               mi.putField(className, memInfo.getJavaName(), memInfo.getJavaDesc());
226           }
227        }
228    }
229
230    private void initPrototype(final MethodGenerator mi) {
231        assert constructor != null;
232        mi.loadThis();
233        final String protoName = scriptClassInfo.getPrototypeClassName();
234        mi.newObject(protoName);
235        mi.dup();
236        mi.invokeSpecial(protoName, INIT, DEFAULT_INIT_DESC);
237        mi.dup();
238        mi.loadThis();
239        mi.invokeStatic(PROTOTYPEOBJECT_TYPE, PROTOTYPEOBJECT_SETCONSTRUCTOR,
240                PROTOTYPEOBJECT_SETCONSTRUCTOR_DESC);
241        mi.invokeVirtual(SCRIPTFUNCTION_TYPE, SCRIPTFUNCTION_SETPROTOTYPE, SCRIPTFUNCTION_SETPROTOTYPE_DESC);
242    }
243
244    /**
245     * Entry point for ConstructorGenerator run separately as an application. Will display
246     * usage. Takes one argument, a class name.
247     * @param args args vector
248     * @throws IOException if class can't be read
249     */
250    public static void main(final String[] args) throws IOException {
251        if (args.length != 1) {
252            System.err.println("Usage: " + ConstructorGenerator.class.getName() + " <class>");
253            System.exit(1);
254        }
255
256        final String className = args[0].replace('.', '/');
257        final ScriptClassInfo sci = getScriptClassInfo(className + ".class");
258        if (sci == null) {
259            System.err.println("No @ScriptClass in " + className);
260            System.exit(2);
261            throw new IOException(); // get rid of warning for sci.verify() below - may be null
262        }
263
264        try {
265            sci.verify();
266        } catch (final Exception e) {
267            System.err.println(e.getMessage());
268            System.exit(3);
269        }
270        final ConstructorGenerator gen = new ConstructorGenerator(sci);
271        try (FileOutputStream fos = new FileOutputStream(className + CONSTRUCTOR_SUFFIX + ".class")) {
272            fos.write(gen.getClassBytes());
273        }
274    }
275}
276