ConstructorGenerator.java revision 229:c62144b08c65 
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_PUBLIC;
29import static jdk.internal.org.objectweb.asm.Opcodes.ACC_SUPER;
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.MAP_DESC;
36import static jdk.nashorn.internal.tools.nasgen.StringConstants.MAP_DUPLICATE;
37import static jdk.nashorn.internal.tools.nasgen.StringConstants.MAP_DUPLICATE_DESC;
38import static jdk.nashorn.internal.tools.nasgen.StringConstants.MAP_FIELD_NAME;
39import static jdk.nashorn.internal.tools.nasgen.StringConstants.MAP_TYPE;
40import static jdk.nashorn.internal.tools.nasgen.StringConstants.OBJECT_DESC;
41import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_SETCONSTRUCTOR;
42import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_SETCONSTRUCTOR_DESC;
43import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_TYPE;
44import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_INIT_DESC3;
45import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_INIT_DESC4;
46import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_TYPE;
47import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETARITY;
48import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETARITY_DESC;
49import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETPROTOTYPE;
50import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETPROTOTYPE_DESC;
51import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_TYPE;
52import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_INIT_DESC;
53import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_TYPE;
54
55import java.io.FileOutputStream;
56import java.io.IOException;
57import java.util.List;
58import jdk.internal.org.objectweb.asm.Handle;
59
60/**
61 * This class generates constructor class for a @ClassInfo annotated class.
62 *
63 */
64public class ConstructorGenerator extends ClassGenerator {
65    private final ScriptClassInfo scriptClassInfo;
66    private final String className;
67    private final MemberInfo constructor;
68    private final int memberCount;
69    private final List<MemberInfo> specs;
70
71    ConstructorGenerator(final ScriptClassInfo sci) {
72        this.scriptClassInfo = sci;
73
74        this.className = scriptClassInfo.getConstructorClassName();
75        this.constructor = scriptClassInfo.getConstructor();
76        this.memberCount = scriptClassInfo.getConstructorMemberCount();
77        this.specs = scriptClassInfo.getSpecializedConstructors();
78    }
79
80    byte[] getClassBytes() {
81        // new class extensing from ScriptObject
82        final String superClass = (constructor != null)? SCRIPTFUNCTIONIMPL_TYPE : SCRIPTOBJECT_TYPE;
83        cw.visit(V1_7, ACC_PUBLIC | ACC_SUPER, className, null, superClass, null);
84        if (memberCount > 0) {
85            // add fields
86            emitFields();
87            // add <clinit>
88            emitStaticInitializer();
89        }
90        // add <init>
91        emitConstructor();
92
93        if (constructor == null) {
94            emitGetClassName(scriptClassInfo.getName());
95        }
96
97        cw.visitEnd();
98        return cw.toByteArray();
99    }
100
101    // --Internals only below this point
102    private void emitFields() {
103        // Introduce "Function" type instance fields for each
104        // constructor @Function in script class and introduce instance
105        // fields for each constructor @Property in the script class.
106        for (MemberInfo memInfo : scriptClassInfo.getMembers()) {
107            if (memInfo.isConstructorFunction()) {
108                addFunctionField(memInfo.getJavaName());
109                memInfo = (MemberInfo)memInfo.clone();
110                memInfo.setJavaDesc(OBJECT_DESC);
111                memInfo.setJavaAccess(ACC_PUBLIC);
112                addGetter(className, memInfo);
113                addSetter(className, memInfo);
114            } else if (memInfo.isConstructorProperty()) {
115                if (memInfo.isStaticFinal()) {
116                    addGetter(scriptClassInfo.getJavaName(), memInfo);
117                } else {
118                    addField(memInfo.getJavaName(), memInfo.getJavaDesc());
119                    memInfo = (MemberInfo)memInfo.clone();
120                    memInfo.setJavaAccess(ACC_PUBLIC);
121                    addGetter(className, memInfo);
122                    addSetter(className, memInfo);
123                }
124            }
125        }
126
127        addMapField();
128    }
129
130    private void emitStaticInitializer() {
131        final MethodGenerator mi = makeStaticInitializer();
132        emitStaticInitPrefix(mi, className);
133
134        for (final MemberInfo memInfo : scriptClassInfo.getMembers()) {
135            if (memInfo.isConstructorFunction() || memInfo.isConstructorProperty()) {
136                linkerAddGetterSetter(mi, className, memInfo);
137            } else if (memInfo.isConstructorGetter()) {
138                final MemberInfo setter = scriptClassInfo.findSetter(memInfo);
139                linkerAddGetterSetter(mi, scriptClassInfo.getJavaName(), memInfo, setter);
140            }
141        }
142        emitStaticInitSuffix(mi, className);
143    }
144
145    private void emitConstructor() {
146        final MethodGenerator mi = makeConstructor();
147        mi.visitCode();
148        callSuper(mi);
149
150        if (memberCount > 0) {
151            // initialize Function type fields
152            initFunctionFields(mi);
153            // initialize data fields
154            initDataFields(mi);
155        }
156
157        if (constructor != null) {
158            final int arity = constructor.getArity();
159            if (arity != MemberInfo.DEFAULT_ARITY) {
160                mi.loadThis();
161                mi.push(arity);
162                mi.invokeVirtual(SCRIPTFUNCTION_TYPE, SCRIPTFUNCTION_SETARITY,
163                        SCRIPTFUNCTION_SETARITY_DESC);
164            }
165        }
166        mi.returnVoid();
167        mi.computeMaxs();
168        mi.visitEnd();
169    }
170
171    private void loadMap(final MethodGenerator mi) {
172        if (memberCount > 0) {
173            mi.getStatic(className, MAP_FIELD_NAME, MAP_DESC);
174            // make sure we use duplicated PropertyMap so that original map
175            // stays intact and so can be used for many globals in same context
176            mi.invokeVirtual(MAP_TYPE, MAP_DUPLICATE, MAP_DUPLICATE_DESC);
177        }
178    }
179
180    private void callSuper(final MethodGenerator mi) {
181        String superClass, superDesc;
182        mi.loadThis();
183        if (constructor == null) {
184            // call ScriptObject.<init>
185            superClass = SCRIPTOBJECT_TYPE;
186            superDesc = (memberCount > 0) ? SCRIPTOBJECT_INIT_DESC : DEFAULT_INIT_DESC;
187            loadMap(mi);
188        } else {
189            // call Function.<init>
190            superClass = SCRIPTFUNCTIONIMPL_TYPE;
191            superDesc = (memberCount > 0) ? SCRIPTFUNCTIONIMPL_INIT_DESC4 : SCRIPTFUNCTIONIMPL_INIT_DESC3;
192            mi.loadLiteral(constructor.getName());
193            mi.visitLdcInsn(new Handle(H_INVOKESTATIC, scriptClassInfo.getJavaName(), constructor.getJavaName(), constructor.getJavaDesc()));
194            loadMap(mi);
195            mi.memberInfoArray(scriptClassInfo.getJavaName(), specs); //pushes null if specs empty
196        }
197
198        mi.invokeSpecial(superClass, INIT, superDesc);
199    }
200
201    private void initFunctionFields(final MethodGenerator mi) {
202        for (final MemberInfo memInfo : scriptClassInfo.getMembers()) {
203            if (!memInfo.isConstructorFunction()) {
204                continue;
205            }
206            mi.loadThis();
207            newFunction(mi, scriptClassInfo.getJavaName(), memInfo, scriptClassInfo.findSpecializations(memInfo.getJavaName()));
208            mi.putField(className, memInfo.getJavaName(), OBJECT_DESC);
209        }
210    }
211
212    private void initDataFields(final MethodGenerator mi) {
213         for (final MemberInfo memInfo : scriptClassInfo.getMembers()) {
214            if (!memInfo.isConstructorProperty() || memInfo.isFinal()) {
215                continue;
216            }
217            final Object value = memInfo.getValue();
218            if (value != null) {
219                mi.loadThis();
220                mi.loadLiteral(value);
221                mi.putField(className, memInfo.getJavaName(), memInfo.getJavaDesc());
222            } else if (!memInfo.getInitClass().isEmpty()) {
223                final String clazz = memInfo.getInitClass();
224                mi.loadThis();
225                mi.newObject(clazz);
226                mi.dup();
227                mi.invokeSpecial(clazz, INIT, DEFAULT_INIT_DESC);
228                mi.putField(className, memInfo.getJavaName(), memInfo.getJavaDesc());
229            }
230        }
231
232        if (constructor != null) {
233            mi.loadThis();
234            final String protoName = scriptClassInfo.getPrototypeClassName();
235            mi.newObject(protoName);
236            mi.dup();
237            mi.invokeSpecial(protoName, INIT, DEFAULT_INIT_DESC);
238            mi.dup();
239            mi.loadThis();
240            mi.invokeStatic(PROTOTYPEOBJECT_TYPE, PROTOTYPEOBJECT_SETCONSTRUCTOR,
241                    PROTOTYPEOBJECT_SETCONSTRUCTOR_DESC);
242            mi.invokeVirtual(SCRIPTFUNCTION_TYPE, SCRIPTFUNCTION_SETPROTOTYPE, SCRIPTFUNCTION_SETPROTOTYPE_DESC);
243        }
244    }
245
246    /**
247     * Entry point for ConstructorGenerator run separately as an application. Will display
248     * usage. Takes one argument, a class name.
249     * @param args args vector
250     * @throws IOException if class can't be read
251     */
252    public static void main(final String[] args) throws IOException {
253        if (args.length != 1) {
254            System.err.println("Usage: " + ConstructorGenerator.class.getName() + " <class>");
255            System.exit(1);
256        }
257
258        final String className = args[0].replace('.', '/');
259        final ScriptClassInfo sci = getScriptClassInfo(className + ".class");
260        if (sci == null) {
261            System.err.println("No @ScriptClass in " + className);
262            System.exit(2);
263            throw new IOException(); // get rid of warning for sci.verify() below - may be null
264        }
265
266        try {
267            sci.verify();
268        } catch (final Exception e) {
269            System.err.println(e.getMessage());
270            System.exit(3);
271        }
272        final ConstructorGenerator gen = new ConstructorGenerator(sci);
273        try (FileOutputStream fos = new FileOutputStream(className + CONSTRUCTOR_SUFFIX + ".class")) {
274            fos.write(gen.getClassBytes());
275        }
276    }
277}
278