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 
  26 package jdk.nashorn.internal.tools.nasgen;
  27 
  28 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_FINAL;
  29 import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
  30 import static jdk.internal.org.objectweb.asm.Opcodes.H_INVOKESTATIC;
  31 import static jdk.internal.org.objectweb.asm.Opcodes.V1_7;
  32 import static jdk.nashorn.internal.tools.nasgen.StringConstants.CONSTRUCTOR_SUFFIX;
  33 import static jdk.nashorn.internal.tools.nasgen.StringConstants.DEFAULT_INIT_DESC;
  34 import static jdk.nashorn.internal.tools.nasgen.StringConstants.INIT;
  35 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_DESC;
  36 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_DUPLICATE;
  37 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_DUPLICATE_DESC;
  38 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_FIELD_NAME;
  39 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_TYPE;
  40 import static jdk.nashorn.internal.tools.nasgen.StringConstants.OBJECT_DESC;
  41 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_SETCONSTRUCTOR;
  42 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_SETCONSTRUCTOR_DESC;
  43 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROTOTYPEOBJECT_TYPE;
  44 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_INIT_DESC3;
  45 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_INIT_DESC4;
  46 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTIONIMPL_TYPE;
  47 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETARITY;
  48 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETARITY_DESC;
  49 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETPROTOTYPE;
  50 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETPROTOTYPE_DESC;
  51 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_TYPE;
  52 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_INIT_DESC;
  53 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_TYPE;
  54 
  55 import java.io.FileOutputStream;
  56 import java.io.IOException;
  57 import java.util.List;
  58 import jdk.internal.org.objectweb.asm.Handle;
  59 
  60 /**
  61  * This class generates constructor class for a @ClassInfo annotated class.
  62  *
  63  */
  64 public 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_FINAL, 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, memberCount);
 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, PROPERTYMAP_FIELD_NAME, PROPERTYMAP_DESC);
 174             // make sure we use duplicated PropertyMap so that original map
 175             // stays intact and so can be used for many globals.
 176             mi.invokeVirtual(PROPERTYMAP_TYPE, PROPERTYMAP_DUPLICATE, PROPERTYMAP_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 }