diff options
Diffstat (limited to 'infrastructure/rhino1_7R1/src/org/mozilla')
119 files changed, 64440 insertions, 0 deletions
diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/classfile/ByteCode.java b/infrastructure/rhino1_7R1/src/org/mozilla/classfile/ByteCode.java new file mode 100644 index 0000000..fa4713e --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/classfile/ByteCode.java @@ -0,0 +1,274 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.classfile; + +/** + * This class provides opcode values expected by the JVM in Java class files. + * + * It also provides tables for internal use by the ClassFileWriter. + * + * @author Roger Lawrence + */ +public class ByteCode { + + /** + * The byte opcodes defined by the Java Virtual Machine. + */ + public static final int + NOP = 0x00, + ACONST_NULL = 0x01, + ICONST_M1 = 0x02, + ICONST_0 = 0x03, + ICONST_1 = 0x04, + ICONST_2 = 0x05, + ICONST_3 = 0x06, + ICONST_4 = 0x07, + ICONST_5 = 0x08, + LCONST_0 = 0x09, + LCONST_1 = 0x0A, + FCONST_0 = 0x0B, + FCONST_1 = 0x0C, + FCONST_2 = 0x0D, + DCONST_0 = 0x0E, + DCONST_1 = 0x0F, + BIPUSH = 0x10, + SIPUSH = 0x11, + LDC = 0x12, + LDC_W = 0x13, + LDC2_W = 0x14, + ILOAD = 0x15, + LLOAD = 0x16, + FLOAD = 0x17, + DLOAD = 0x18, + ALOAD = 0x19, + ILOAD_0 = 0x1A, + ILOAD_1 = 0x1B, + ILOAD_2 = 0x1C, + ILOAD_3 = 0x1D, + LLOAD_0 = 0x1E, + LLOAD_1 = 0x1F, + LLOAD_2 = 0x20, + LLOAD_3 = 0x21, + FLOAD_0 = 0x22, + FLOAD_1 = 0x23, + FLOAD_2 = 0x24, + FLOAD_3 = 0x25, + DLOAD_0 = 0x26, + DLOAD_1 = 0x27, + DLOAD_2 = 0x28, + DLOAD_3 = 0x29, + ALOAD_0 = 0x2A, + ALOAD_1 = 0x2B, + ALOAD_2 = 0x2C, + ALOAD_3 = 0x2D, + IALOAD = 0x2E, + LALOAD = 0x2F, + FALOAD = 0x30, + DALOAD = 0x31, + AALOAD = 0x32, + BALOAD = 0x33, + CALOAD = 0x34, + SALOAD = 0x35, + ISTORE = 0x36, + LSTORE = 0x37, + FSTORE = 0x38, + DSTORE = 0x39, + ASTORE = 0x3A, + ISTORE_0 = 0x3B, + ISTORE_1 = 0x3C, + ISTORE_2 = 0x3D, + ISTORE_3 = 0x3E, + LSTORE_0 = 0x3F, + LSTORE_1 = 0x40, + LSTORE_2 = 0x41, + LSTORE_3 = 0x42, + FSTORE_0 = 0x43, + FSTORE_1 = 0x44, + FSTORE_2 = 0x45, + FSTORE_3 = 0x46, + DSTORE_0 = 0x47, + DSTORE_1 = 0x48, + DSTORE_2 = 0x49, + DSTORE_3 = 0x4A, + ASTORE_0 = 0x4B, + ASTORE_1 = 0x4C, + ASTORE_2 = 0x4D, + ASTORE_3 = 0x4E, + IASTORE = 0x4F, + LASTORE = 0x50, + FASTORE = 0x51, + DASTORE = 0x52, + AASTORE = 0x53, + BASTORE = 0x54, + CASTORE = 0x55, + SASTORE = 0x56, + POP = 0x57, + POP2 = 0x58, + DUP = 0x59, + DUP_X1 = 0x5A, + DUP_X2 = 0x5B, + DUP2 = 0x5C, + DUP2_X1 = 0x5D, + DUP2_X2 = 0x5E, + SWAP = 0x5F, + IADD = 0x60, + LADD = 0x61, + FADD = 0x62, + DADD = 0x63, + ISUB = 0x64, + LSUB = 0x65, + FSUB = 0x66, + DSUB = 0x67, + IMUL = 0x68, + LMUL = 0x69, + FMUL = 0x6A, + DMUL = 0x6B, + IDIV = 0x6C, + LDIV = 0x6D, + FDIV = 0x6E, + DDIV = 0x6F, + IREM = 0x70, + LREM = 0x71, + FREM = 0x72, + DREM = 0x73, + INEG = 0x74, + LNEG = 0x75, + FNEG = 0x76, + DNEG = 0x77, + ISHL = 0x78, + LSHL = 0x79, + ISHR = 0x7A, + LSHR = 0x7B, + IUSHR = 0x7C, + LUSHR = 0x7D, + IAND = 0x7E, + LAND = 0x7F, + IOR = 0x80, + LOR = 0x81, + IXOR = 0x82, + LXOR = 0x83, + IINC = 0x84, + I2L = 0x85, + I2F = 0x86, + I2D = 0x87, + L2I = 0x88, + L2F = 0x89, + L2D = 0x8A, + F2I = 0x8B, + F2L = 0x8C, + F2D = 0x8D, + D2I = 0x8E, + D2L = 0x8F, + D2F = 0x90, + I2B = 0x91, + I2C = 0x92, + I2S = 0x93, + LCMP = 0x94, + FCMPL = 0x95, + FCMPG = 0x96, + DCMPL = 0x97, + DCMPG = 0x98, + IFEQ = 0x99, + IFNE = 0x9A, + IFLT = 0x9B, + IFGE = 0x9C, + IFGT = 0x9D, + IFLE = 0x9E, + IF_ICMPEQ = 0x9F, + IF_ICMPNE = 0xA0, + IF_ICMPLT = 0xA1, + IF_ICMPGE = 0xA2, + IF_ICMPGT = 0xA3, + IF_ICMPLE = 0xA4, + IF_ACMPEQ = 0xA5, + IF_ACMPNE = 0xA6, + GOTO = 0xA7, + JSR = 0xA8, + RET = 0xA9, + TABLESWITCH = 0xAA, + LOOKUPSWITCH = 0xAB, + IRETURN = 0xAC, + LRETURN = 0xAD, + FRETURN = 0xAE, + DRETURN = 0xAF, + ARETURN = 0xB0, + RETURN = 0xB1, + GETSTATIC = 0xB2, + PUTSTATIC = 0xB3, + GETFIELD = 0xB4, + PUTFIELD = 0xB5, + INVOKEVIRTUAL = 0xB6, + INVOKESPECIAL = 0xB7, + INVOKESTATIC = 0xB8, + INVOKEINTERFACE = 0xB9, + NEW = 0xBB, + NEWARRAY = 0xBC, + ANEWARRAY = 0xBD, + ARRAYLENGTH = 0xBE, + ATHROW = 0xBF, + CHECKCAST = 0xC0, + INSTANCEOF = 0xC1, + MONITORENTER = 0xC2, + MONITOREXIT = 0xC3, + WIDE = 0xC4, + MULTIANEWARRAY = 0xC5, + IFNULL = 0xC6, + IFNONNULL = 0xC7, + GOTO_W = 0xC8, + JSR_W = 0xC9, + BREAKPOINT = 0xCA, + + IMPDEP1 = 0xFE, + IMPDEP2 = 0xFF; + + /** + * Types for the NEWARRAY opcode. + */ + public static final byte + T_BOOLEAN = 4, + T_CHAR = 5, + T_FLOAT = 6, + T_DOUBLE = 7, + T_BYTE = 8, + T_SHORT = 9, + T_INT = 10, + T_LONG = 11; + + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/classfile/ClassFileWriter.java b/infrastructure/rhino1_7R1/src/org/mozilla/classfile/ClassFileWriter.java new file mode 100644 index 0000000..b9c6c96 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/classfile/ClassFileWriter.java @@ -0,0 +1,3038 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.classfile; + +import org.mozilla.javascript.ObjToIntMap; +import org.mozilla.javascript.ObjArray; +import org.mozilla.javascript.UintMap; + +import java.io.*; + +/** + * ClassFileWriter + * + * A ClassFileWriter is used to write a Java class file. Methods are + * provided to create fields and methods, and within methods to write + * Java bytecodes. + * + * @author Roger Lawrence + */ +public class ClassFileWriter { + + /** + * Thrown for cases where the error in generating the class file is + * due to a program size constraints rather than a likely bug in the + * compiler. + */ + public static class ClassFileFormatException extends RuntimeException { + ClassFileFormatException(String message) { + super(message); + } + } + + /** + * Construct a ClassFileWriter for a class. + * + * @param className the name of the class to write, including + * full package qualification. + * @param superClassName the name of the superclass of the class + * to write, including full package qualification. + * @param sourceFileName the name of the source file to use for + * producing debug information, or null if debug information + * is not desired + */ + public ClassFileWriter(String className, String superClassName, + String sourceFileName) + { + generatedClassName = className; + itsConstantPool = new ConstantPool(this); + itsThisClassIndex = itsConstantPool.addClass(className); + itsSuperClassIndex = itsConstantPool.addClass(superClassName); + if (sourceFileName != null) + itsSourceFileNameIndex = itsConstantPool.addUtf8(sourceFileName); + itsFlags = ACC_PUBLIC; + } + + public final String getClassName() + { + return generatedClassName; + } + + /** + * Add an interface implemented by this class. + * + * This method may be called multiple times for classes that + * implement multiple interfaces. + * + * @param interfaceName a name of an interface implemented + * by the class being written, including full package + * qualification. + */ + public void addInterface(String interfaceName) { + short interfaceIndex = itsConstantPool.addClass(interfaceName); + itsInterfaces.add(new Short(interfaceIndex)); + } + + public static final short + ACC_PUBLIC = 0x0001, + ACC_PRIVATE = 0x0002, + ACC_PROTECTED = 0x0004, + ACC_STATIC = 0x0008, + ACC_FINAL = 0x0010, + ACC_SYNCHRONIZED = 0x0020, + ACC_VOLATILE = 0x0040, + ACC_TRANSIENT = 0x0080, + ACC_NATIVE = 0x0100, + ACC_ABSTRACT = 0x0400; + + /** + * Set the class's flags. + * + * Flags must be a set of the following flags, bitwise or'd + * together: + * ACC_PUBLIC + * ACC_PRIVATE + * ACC_PROTECTED + * ACC_FINAL + * ACC_ABSTRACT + * TODO: check that this is the appropriate set + * @param flags the set of class flags to set + */ + public void setFlags(short flags) { + itsFlags = flags; + } + + static String getSlashedForm(String name) + { + return name.replace('.', '/'); + } + + /** + * Convert Java class name in dot notation into + * "Lname-with-dots-replaced-by-slashes;" form suitable for use as + * JVM type signatures. + */ + public static String classNameToSignature(String name) + { + int nameLength = name.length(); + int colonPos = 1 + nameLength; + char[] buf = new char[colonPos + 1]; + buf[0] = 'L'; + buf[colonPos] = ';'; + name.getChars(0, nameLength, buf, 1); + for (int i = 1; i != colonPos; ++i) { + if (buf[i] == '.') { + buf[i] = '/'; + } + } + return new String(buf, 0, colonPos + 1); + } + + /** + * Add a field to the class. + * + * @param fieldName the name of the field + * @param type the type of the field using ... + * @param flags the attributes of the field, such as ACC_PUBLIC, etc. + * bitwise or'd together + */ + public void addField(String fieldName, String type, short flags) { + short fieldNameIndex = itsConstantPool.addUtf8(fieldName); + short typeIndex = itsConstantPool.addUtf8(type); + itsFields.add(new ClassFileField(fieldNameIndex, typeIndex, flags)); + } + + /** + * Add a field to the class. + * + * @param fieldName the name of the field + * @param type the type of the field using ... + * @param flags the attributes of the field, such as ACC_PUBLIC, etc. + * bitwise or'd together + * @param value an initial integral value + */ + public void addField(String fieldName, String type, short flags, + int value) + { + short fieldNameIndex = itsConstantPool.addUtf8(fieldName); + short typeIndex = itsConstantPool.addUtf8(type); + ClassFileField field = new ClassFileField(fieldNameIndex, typeIndex, + flags); + field.setAttributes(itsConstantPool.addUtf8("ConstantValue"), + (short)0, + (short)0, + itsConstantPool.addConstant(value)); + itsFields.add(field); + } + + /** + * Add a field to the class. + * + * @param fieldName the name of the field + * @param type the type of the field using ... + * @param flags the attributes of the field, such as ACC_PUBLIC, etc. + * bitwise or'd together + * @param value an initial long value + */ + public void addField(String fieldName, String type, short flags, + long value) + { + short fieldNameIndex = itsConstantPool.addUtf8(fieldName); + short typeIndex = itsConstantPool.addUtf8(type); + ClassFileField field = new ClassFileField(fieldNameIndex, typeIndex, + flags); + field.setAttributes(itsConstantPool.addUtf8("ConstantValue"), + (short)0, + (short)2, + itsConstantPool.addConstant(value)); + itsFields.add(field); + } + + /** + * Add a field to the class. + * + * @param fieldName the name of the field + * @param type the type of the field using ... + * @param flags the attributes of the field, such as ACC_PUBLIC, etc. + * bitwise or'd together + * @param value an initial double value + */ + public void addField(String fieldName, String type, short flags, + double value) + { + short fieldNameIndex = itsConstantPool.addUtf8(fieldName); + short typeIndex = itsConstantPool.addUtf8(type); + ClassFileField field = new ClassFileField(fieldNameIndex, typeIndex, + flags); + field.setAttributes(itsConstantPool.addUtf8("ConstantValue"), + (short)0, + (short)2, + itsConstantPool.addConstant(value)); + itsFields.add(field); + } + + /** + * Add Information about java variable to use when generating the local + * variable table. + * + * @param name variable name. + * @param type variable type as bytecode descriptor string. + * @param startPC the starting bytecode PC where this variable is live, + * or -1 if it does not have a Java register. + * @param register the Java register number of variable + * or -1 if it does not have a Java register. + */ + public void addVariableDescriptor(String name, String type, int startPC, int register) + { + int nameIndex = itsConstantPool.addUtf8(name); + int descriptorIndex = itsConstantPool.addUtf8(type); + int [] chunk = { nameIndex, descriptorIndex, startPC, register }; + if (itsVarDescriptors == null) { + itsVarDescriptors = new ObjArray(); + } + itsVarDescriptors.add(chunk); + } + + /** + * Add a method and begin adding code. + * + * This method must be called before other methods for adding code, + * exception tables, etc. can be invoked. + * + * @param methodName the name of the method + * @param type a string representing the type + * @param flags the attributes of the field, such as ACC_PUBLIC, etc. + * bitwise or'd together + */ + public void startMethod(String methodName, String type, short flags) { + short methodNameIndex = itsConstantPool.addUtf8(methodName); + short typeIndex = itsConstantPool.addUtf8(type); + itsCurrentMethod = new ClassFileMethod(methodNameIndex, typeIndex, + flags); + itsMethods.add(itsCurrentMethod); + } + + /** + * Complete generation of the method. + * + * After this method is called, no more code can be added to the + * method begun with <code>startMethod</code>. + * + * @param maxLocals the maximum number of local variable slots + * (a.k.a. Java registers) used by the method + */ + public void stopMethod(short maxLocals) { + if (itsCurrentMethod == null) + throw new IllegalStateException("No method to stop"); + + fixLabelGotos(); + + itsMaxLocals = maxLocals; + + int lineNumberTableLength = 0; + if (itsLineNumberTable != null) { + // 6 bytes for the attribute header + // 2 bytes for the line number count + // 4 bytes for each entry + lineNumberTableLength = 6 + 2 + (itsLineNumberTableTop * 4); + } + + int variableTableLength = 0; + if (itsVarDescriptors != null) { + // 6 bytes for the attribute header + // 2 bytes for the variable count + // 10 bytes for each entry + variableTableLength = 6 + 2 + (itsVarDescriptors.size() * 10); + } + + int attrLength = 2 + // attribute_name_index + 4 + // attribute_length + 2 + // max_stack + 2 + // max_locals + 4 + // code_length + itsCodeBufferTop + + 2 + // exception_table_length + (itsExceptionTableTop * 8) + + 2 + // attributes_count + lineNumberTableLength + + variableTableLength; + + if (attrLength > 65536) { + // See http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html, + // section 4.10, "The amount of code per non-native, non-abstract + // method is limited to 65536 bytes... + throw new ClassFileFormatException( + "generated bytecode for method exceeds 64K limit."); + } + byte[] codeAttribute = new byte[attrLength]; + int index = 0; + int codeAttrIndex = itsConstantPool.addUtf8("Code"); + index = putInt16(codeAttrIndex, codeAttribute, index); + attrLength -= 6; // discount the attribute header + index = putInt32(attrLength, codeAttribute, index); + index = putInt16(itsMaxStack, codeAttribute, index); + index = putInt16(itsMaxLocals, codeAttribute, index); + index = putInt32(itsCodeBufferTop, codeAttribute, index); + System.arraycopy(itsCodeBuffer, 0, codeAttribute, index, + itsCodeBufferTop); + index += itsCodeBufferTop; + + if (itsExceptionTableTop > 0) { + index = putInt16(itsExceptionTableTop, codeAttribute, index); + for (int i = 0; i < itsExceptionTableTop; i++) { + ExceptionTableEntry ete = itsExceptionTable[i]; + short startPC = (short)getLabelPC(ete.itsStartLabel); + short endPC = (short)getLabelPC(ete.itsEndLabel); + short handlerPC = (short)getLabelPC(ete.itsHandlerLabel); + short catchType = ete.itsCatchType; + if (startPC == -1) + throw new IllegalStateException("start label not defined"); + if (endPC == -1) + throw new IllegalStateException("end label not defined"); + if (handlerPC == -1) + throw new IllegalStateException( + "handler label not defined"); + + index = putInt16(startPC, codeAttribute, index); + index = putInt16(endPC, codeAttribute, index); + index = putInt16(handlerPC, codeAttribute, index); + index = putInt16(catchType, codeAttribute, index); + } + } + else { + // write 0 as exception table length + index = putInt16(0, codeAttribute, index); + } + + int attributeCount = 0; + if (itsLineNumberTable != null) + attributeCount++; + if (itsVarDescriptors != null) + attributeCount++; + index = putInt16(attributeCount, codeAttribute, index); + + if (itsLineNumberTable != null) { + int lineNumberTableAttrIndex + = itsConstantPool.addUtf8("LineNumberTable"); + index = putInt16(lineNumberTableAttrIndex, codeAttribute, index); + int tableAttrLength = 2 + (itsLineNumberTableTop * 4); + index = putInt32(tableAttrLength, codeAttribute, index); + index = putInt16(itsLineNumberTableTop, codeAttribute, index); + for (int i = 0; i < itsLineNumberTableTop; i++) { + index = putInt32(itsLineNumberTable[i], codeAttribute, index); + } + } + + if (itsVarDescriptors != null) { + int variableTableAttrIndex + = itsConstantPool.addUtf8("LocalVariableTable"); + index = putInt16(variableTableAttrIndex, codeAttribute, index); + int varCount = itsVarDescriptors.size(); + int tableAttrLength = 2 + (varCount * 10); + index = putInt32(tableAttrLength, codeAttribute, index); + index = putInt16(varCount, codeAttribute, index); + for (int i = 0; i < varCount; i++) { + int[] chunk = (int[])itsVarDescriptors.get(i); + int nameIndex = chunk[0]; + int descriptorIndex = chunk[1]; + int startPC = chunk[2]; + int register = chunk[3]; + int length = itsCodeBufferTop - startPC; + + index = putInt16(startPC, codeAttribute, index); + index = putInt16(length, codeAttribute, index); + index = putInt16(nameIndex, codeAttribute, index); + index = putInt16(descriptorIndex, codeAttribute, index); + index = putInt16(register, codeAttribute, index); + } + } + + itsCurrentMethod.setCodeAttribute(codeAttribute); + + itsExceptionTable = null; + itsExceptionTableTop = 0; + itsLineNumberTableTop = 0; + itsCodeBufferTop = 0; + itsCurrentMethod = null; + itsMaxStack = 0; + itsStackTop = 0; + itsLabelTableTop = 0; + itsFixupTableTop = 0; + itsVarDescriptors = null; + } + + /** + * Add the single-byte opcode to the current method. + * + * @param theOpCode the opcode of the bytecode + */ + public void add(int theOpCode) { + if (opcodeCount(theOpCode) != 0) + throw new IllegalArgumentException("Unexpected operands"); + int newStack = itsStackTop + stackChange(theOpCode); + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + if (DEBUGCODE) + System.out.println("Add " + bytecodeStr(theOpCode)); + addToCodeBuffer(theOpCode); + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(theOpCode) + +" stack = "+itsStackTop); + } + } + + /** + * Add a single-operand opcode to the current method. + * + * @param theOpCode the opcode of the bytecode + * @param theOperand the operand of the bytecode + */ + public void add(int theOpCode, int theOperand) { + if (DEBUGCODE) { + System.out.println("Add "+bytecodeStr(theOpCode) + +", "+Integer.toHexString(theOperand)); + } + int newStack = itsStackTop + stackChange(theOpCode); + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + + switch (theOpCode) { + case ByteCode.GOTO : + // fallthru... + case ByteCode.IFEQ : + case ByteCode.IFNE : + case ByteCode.IFLT : + case ByteCode.IFGE : + case ByteCode.IFGT : + case ByteCode.IFLE : + case ByteCode.IF_ICMPEQ : + case ByteCode.IF_ICMPNE : + case ByteCode.IF_ICMPLT : + case ByteCode.IF_ICMPGE : + case ByteCode.IF_ICMPGT : + case ByteCode.IF_ICMPLE : + case ByteCode.IF_ACMPEQ : + case ByteCode.IF_ACMPNE : + case ByteCode.JSR : + case ByteCode.IFNULL : + case ByteCode.IFNONNULL : { + if ((theOperand & 0x80000000) != 0x80000000) { + if ((theOperand < 0) || (theOperand > 65535)) + throw new IllegalArgumentException( + "Bad label for branch"); + } + int branchPC = itsCodeBufferTop; + addToCodeBuffer(theOpCode); + if ((theOperand & 0x80000000) != 0x80000000) { + // hard displacement + addToCodeInt16(theOperand); + } + else { // a label + int targetPC = getLabelPC(theOperand); + if (DEBUGLABELS) { + int theLabel = theOperand & 0x7FFFFFFF; + System.out.println("Fixing branch to " + + theLabel + " at " + targetPC + + " from " + branchPC); + } + if (targetPC != -1) { + int offset = targetPC - branchPC; + addToCodeInt16(offset); + } + else { + addLabelFixup(theOperand, branchPC + 1); + addToCodeInt16(0); + } + } + } + break; + + case ByteCode.BIPUSH : + if ((byte)theOperand != theOperand) + throw new IllegalArgumentException("out of range byte"); + addToCodeBuffer(theOpCode); + addToCodeBuffer((byte)theOperand); + break; + + case ByteCode.SIPUSH : + if ((short)theOperand != theOperand) + throw new IllegalArgumentException("out of range short"); + addToCodeBuffer(theOpCode); + addToCodeInt16(theOperand); + break; + + case ByteCode.NEWARRAY : + if (!(0 <= theOperand && theOperand < 256)) + throw new IllegalArgumentException("out of range index"); + addToCodeBuffer(theOpCode); + addToCodeBuffer(theOperand); + break; + + case ByteCode.GETFIELD : + case ByteCode.PUTFIELD : + if (!(0 <= theOperand && theOperand < 65536)) + throw new IllegalArgumentException("out of range field"); + addToCodeBuffer(theOpCode); + addToCodeInt16(theOperand); + break; + + case ByteCode.LDC : + case ByteCode.LDC_W : + case ByteCode.LDC2_W : + if (!(0 <= theOperand && theOperand < 65536)) + throw new IllegalArgumentException("out of range index"); + if (theOperand >= 256 + || theOpCode == ByteCode.LDC_W + || theOpCode == ByteCode.LDC2_W) + { + if (theOpCode == ByteCode.LDC) { + addToCodeBuffer(ByteCode.LDC_W); + } else { + addToCodeBuffer(theOpCode); + } + addToCodeInt16(theOperand); + } else { + addToCodeBuffer(theOpCode); + addToCodeBuffer(theOperand); + } + break; + + case ByteCode.RET : + case ByteCode.ILOAD : + case ByteCode.LLOAD : + case ByteCode.FLOAD : + case ByteCode.DLOAD : + case ByteCode.ALOAD : + case ByteCode.ISTORE : + case ByteCode.LSTORE : + case ByteCode.FSTORE : + case ByteCode.DSTORE : + case ByteCode.ASTORE : + if (!(0 <= theOperand && theOperand < 65536)) + throw new ClassFileFormatException("out of range variable"); + if (theOperand >= 256) { + addToCodeBuffer(ByteCode.WIDE); + addToCodeBuffer(theOpCode); + addToCodeInt16(theOperand); + } + else { + addToCodeBuffer(theOpCode); + addToCodeBuffer(theOperand); + } + break; + + default : + throw new IllegalArgumentException( + "Unexpected opcode for 1 operand"); + } + + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(theOpCode) + +" stack = "+itsStackTop); + } + } + + /** + * Generate the load constant bytecode for the given integer. + * + * @param k the constant + */ + public void addLoadConstant(int k) { + switch (k) { + case 0: add(ByteCode.ICONST_0); break; + case 1: add(ByteCode.ICONST_1); break; + case 2: add(ByteCode.ICONST_2); break; + case 3: add(ByteCode.ICONST_3); break; + case 4: add(ByteCode.ICONST_4); break; + case 5: add(ByteCode.ICONST_5); break; + default: + add(ByteCode.LDC, itsConstantPool.addConstant(k)); + break; + } + } + + /** + * Generate the load constant bytecode for the given long. + * + * @param k the constant + */ + public void addLoadConstant(long k) { + add(ByteCode.LDC2_W, itsConstantPool.addConstant(k)); + } + + /** + * Generate the load constant bytecode for the given float. + * + * @param k the constant + */ + public void addLoadConstant(float k) { + add(ByteCode.LDC, itsConstantPool.addConstant(k)); + } + + /** + * Generate the load constant bytecode for the given double. + * + * @param k the constant + */ + public void addLoadConstant(double k) { + add(ByteCode.LDC2_W, itsConstantPool.addConstant(k)); + } + + /** + * Generate the load constant bytecode for the given string. + * + * @param k the constant + */ + public void addLoadConstant(String k) { + add(ByteCode.LDC, itsConstantPool.addConstant(k)); + } + + /** + * Add the given two-operand bytecode to the current method. + * + * @param theOpCode the opcode of the bytecode + * @param theOperand1 the first operand of the bytecode + * @param theOperand2 the second operand of the bytecode + */ + public void add(int theOpCode, int theOperand1, int theOperand2) { + if (DEBUGCODE) { + System.out.println("Add "+bytecodeStr(theOpCode) + +", "+Integer.toHexString(theOperand1) + +", "+Integer.toHexString(theOperand2)); + } + int newStack = itsStackTop + stackChange(theOpCode); + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + + if (theOpCode == ByteCode.IINC) { + if (!(0 <= theOperand1 && theOperand1 < 65536)) + throw new ClassFileFormatException("out of range variable"); + if (!(0 <= theOperand2 && theOperand2 < 65536)) + throw new ClassFileFormatException("out of range increment"); + + if (theOperand1 > 255 || theOperand2 < -128 || theOperand2 > 127) { + addToCodeBuffer(ByteCode.WIDE); + addToCodeBuffer(ByteCode.IINC); + addToCodeInt16(theOperand1); + addToCodeInt16(theOperand2); + } + else { + addToCodeBuffer(ByteCode.WIDE); + addToCodeBuffer(ByteCode.IINC); + addToCodeBuffer(theOperand1); + addToCodeBuffer(theOperand2); + } + } + else if (theOpCode == ByteCode.MULTIANEWARRAY) { + if (!(0 <= theOperand1 && theOperand1 < 65536)) + throw new IllegalArgumentException("out of range index"); + if (!(0 <= theOperand2 && theOperand2 < 256)) + throw new IllegalArgumentException("out of range dimensions"); + + addToCodeBuffer(ByteCode.MULTIANEWARRAY); + addToCodeInt16(theOperand1); + addToCodeBuffer(theOperand2); + } + else { + throw new IllegalArgumentException( + "Unexpected opcode for 2 operands"); + } + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(theOpCode) + +" stack = "+itsStackTop); + } + + } + + public void add(int theOpCode, String className) { + if (DEBUGCODE) { + System.out.println("Add "+bytecodeStr(theOpCode) + +", "+className); + } + int newStack = itsStackTop + stackChange(theOpCode); + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + switch (theOpCode) { + case ByteCode.NEW : + case ByteCode.ANEWARRAY : + case ByteCode.CHECKCAST : + case ByteCode.INSTANCEOF : { + short classIndex = itsConstantPool.addClass(className); + addToCodeBuffer(theOpCode); + addToCodeInt16(classIndex); + } + break; + + default : + throw new IllegalArgumentException( + "bad opcode for class reference"); + } + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(theOpCode) + +" stack = "+itsStackTop); + } + } + + + public void add(int theOpCode, String className, String fieldName, + String fieldType) + { + if (DEBUGCODE) { + System.out.println("Add "+bytecodeStr(theOpCode) + +", "+className+", "+fieldName+", "+fieldType); + } + int newStack = itsStackTop + stackChange(theOpCode); + char fieldTypeChar = fieldType.charAt(0); + int fieldSize = (fieldTypeChar == 'J' || fieldTypeChar == 'D') + ? 2 : 1; + switch (theOpCode) { + case ByteCode.GETFIELD : + case ByteCode.GETSTATIC : + newStack += fieldSize; + break; + case ByteCode.PUTSTATIC : + case ByteCode.PUTFIELD : + newStack -= fieldSize; + break; + default : + throw new IllegalArgumentException( + "bad opcode for field reference"); + } + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + short fieldRefIndex = itsConstantPool.addFieldRef(className, + fieldName, fieldType); + addToCodeBuffer(theOpCode); + addToCodeInt16(fieldRefIndex); + + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(theOpCode) + +" stack = "+itsStackTop); + } + } + + public void addInvoke(int theOpCode, String className, String methodName, + String methodType) + { + if (DEBUGCODE) { + System.out.println("Add "+bytecodeStr(theOpCode) + +", "+className+", "+methodName+", " + +methodType); + } + int parameterInfo = sizeOfParameters(methodType); + int parameterCount = parameterInfo >>> 16; + int stackDiff = (short)parameterInfo; + + int newStack = itsStackTop + stackDiff; + newStack += stackChange(theOpCode); // adjusts for 'this' + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + + switch (theOpCode) { + case ByteCode.INVOKEVIRTUAL : + case ByteCode.INVOKESPECIAL : + case ByteCode.INVOKESTATIC : + case ByteCode.INVOKEINTERFACE : { + addToCodeBuffer(theOpCode); + if (theOpCode == ByteCode.INVOKEINTERFACE) { + short ifMethodRefIndex + = itsConstantPool.addInterfaceMethodRef( + className, methodName, + methodType); + addToCodeInt16(ifMethodRefIndex); + addToCodeBuffer(parameterCount + 1); + addToCodeBuffer(0); + } + else { + short methodRefIndex = itsConstantPool.addMethodRef( + className, methodName, + methodType); + addToCodeInt16(methodRefIndex); + } + } + break; + + default : + throw new IllegalArgumentException( + "bad opcode for method reference"); + } + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(theOpCode) + +" stack = "+itsStackTop); + } + } + + /** + * Generate code to load the given integer on stack. + * + * @param k the constant + */ + public void addPush(int k) + { + if ((byte)k == k) { + if (k == -1) { + add(ByteCode.ICONST_M1); + } else if (0 <= k && k <= 5) { + add((byte)(ByteCode.ICONST_0 + k)); + } else { + add(ByteCode.BIPUSH, (byte)k); + } + } else if ((short)k == k) { + add(ByteCode.SIPUSH, (short)k); + } else { + addLoadConstant(k); + } + } + + public void addPush(boolean k) + { + add(k ? ByteCode.ICONST_1 : ByteCode.ICONST_0); + } + + /** + * Generate code to load the given long on stack. + * + * @param k the constant + */ + public void addPush(long k) + { + int ik = (int)k; + if (ik == k) { + addPush(ik); + add(ByteCode.I2L); + } else { + addLoadConstant(k); + } + } + + /** + * Generate code to load the given double on stack. + * + * @param k the constant + */ + public void addPush(double k) + { + if (k == 0.0) { + // zero + add(ByteCode.DCONST_0); + if (1.0 / k < 0) { + // Negative zero + add(ByteCode.DNEG); + } + } else if (k == 1.0 || k == -1.0) { + add(ByteCode.DCONST_1); + if (k < 0) { + add(ByteCode.DNEG); + } + } else { + addLoadConstant(k); + } + } + + /** + * Generate the code to leave on stack the given string even if the + * string encoding exeeds the class file limit for single string constant + * + * @param k the constant + */ + public void addPush(String k) { + int length = k.length(); + int limit = itsConstantPool.getUtfEncodingLimit(k, 0, length); + if (limit == length) { + addLoadConstant(k); + return; + } + // Split string into picies fitting the UTF limit and generate code for + // StringBuffer sb = new StringBuffer(length); + // sb.append(loadConstant(piece_1)); + // ... + // sb.append(loadConstant(piece_N)); + // sb.toString(); + final String SB = "java/lang/StringBuffer"; + add(ByteCode.NEW, SB); + add(ByteCode.DUP); + addPush(length); + addInvoke(ByteCode.INVOKESPECIAL, SB, "<init>", "(I)V"); + int cursor = 0; + for (;;) { + add(ByteCode.DUP); + String s = k.substring(cursor, limit); + addLoadConstant(s); + addInvoke(ByteCode.INVOKEVIRTUAL, SB, "append", + "(Ljava/lang/String;)Ljava/lang/StringBuffer;"); + add(ByteCode.POP); + if (limit == length) { + break; + } + cursor = limit; + limit = itsConstantPool.getUtfEncodingLimit(k, limit, length); + } + addInvoke(ByteCode.INVOKEVIRTUAL, SB, "toString", + "()Ljava/lang/String;"); + } + + /** + * Check if k fits limit on string constant size imposed by class file + * format. + * + * @param k the string constant + */ + public boolean isUnderStringSizeLimit(String k) + { + return itsConstantPool.isUnderUtfEncodingLimit(k); + } + + /** + * Store integer from stack top into the given local. + * + * @param local number of local register + */ + public void addIStore(int local) + { + xop(ByteCode.ISTORE_0, ByteCode.ISTORE, local); + } + + /** + * Store long from stack top into the given local. + * + * @param local number of local register + */ + public void addLStore(int local) + { + xop(ByteCode.LSTORE_0, ByteCode.LSTORE, local); + } + + /** + * Store float from stack top into the given local. + * + * @param local number of local register + */ + public void addFStore(int local) + { + xop(ByteCode.FSTORE_0, ByteCode.FSTORE, local); + } + + /** + * Store double from stack top into the given local. + * + * @param local number of local register + */ + public void addDStore(int local) + { + xop(ByteCode.DSTORE_0, ByteCode.DSTORE, local); + } + + /** + * Store object from stack top into the given local. + * + * @param local number of local register + */ + public void addAStore(int local) + { + xop(ByteCode.ASTORE_0, ByteCode.ASTORE, local); + } + + /** + * Load integer from the given local into stack. + * + * @param local number of local register + */ + public void addILoad(int local) + { + xop(ByteCode.ILOAD_0, ByteCode.ILOAD, local); + } + + /** + * Load long from the given local into stack. + * + * @param local number of local register + */ + public void addLLoad(int local) + { + xop(ByteCode.LLOAD_0, ByteCode.LLOAD, local); + } + + /** + * Load float from the given local into stack. + * + * @param local number of local register + */ + public void addFLoad(int local) + { + xop(ByteCode.FLOAD_0, ByteCode.FLOAD, local); + } + + /** + * Load double from the given local into stack. + * + * @param local number of local register + */ + public void addDLoad(int local) + { + xop(ByteCode.DLOAD_0, ByteCode.DLOAD, local); + } + + /** + * Load object from the given local into stack. + * + * @param local number of local register + */ + public void addALoad(int local) + { + xop(ByteCode.ALOAD_0, ByteCode.ALOAD, local); + } + + /** + * Load "this" into stack. + */ + public void addLoadThis() + { + add(ByteCode.ALOAD_0); + } + + private void xop(int shortOp, int op, int local) + { + switch (local) { + case 0: + add(shortOp); + break; + case 1: + add(shortOp + 1); + break; + case 2: + add(shortOp + 2); + break; + case 3: + add(shortOp + 3); + break; + default: + add(op, local); + } + } + + public int addTableSwitch(int low, int high) + { + if (DEBUGCODE) { + System.out.println("Add "+bytecodeStr(ByteCode.TABLESWITCH) + +" "+low+" "+high); + } + if (low > high) + throw new ClassFileFormatException("Bad bounds: "+low+' '+ high); + + int newStack = itsStackTop + stackChange(ByteCode.TABLESWITCH); + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + + int entryCount = high - low + 1; + int padSize = 3 & ~itsCodeBufferTop; // == 3 - itsCodeBufferTop % 4 + + int N = addReservedCodeSpace(1 + padSize + 4 * (1 + 2 + entryCount)); + int switchStart = N; + itsCodeBuffer[N++] = (byte)ByteCode.TABLESWITCH; + while (padSize != 0) { + itsCodeBuffer[N++] = 0; + --padSize; + } + N += 4; // skip default offset + N = putInt32(low, itsCodeBuffer, N); + putInt32(high, itsCodeBuffer, N); + + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+bytecodeStr(ByteCode.TABLESWITCH) + +" stack = "+itsStackTop); + } + + return switchStart; + } + + public final void markTableSwitchDefault(int switchStart) + { + setTableSwitchJump(switchStart, -1, itsCodeBufferTop); + } + + public final void markTableSwitchCase(int switchStart, int caseIndex) + { + setTableSwitchJump(switchStart, caseIndex, itsCodeBufferTop); + } + + public final void markTableSwitchCase(int switchStart, int caseIndex, + int stackTop) + { + if (!(0 <= stackTop && stackTop <= itsMaxStack)) + throw new IllegalArgumentException("Bad stack index: "+stackTop); + itsStackTop = (short)stackTop; + setTableSwitchJump(switchStart, caseIndex, itsCodeBufferTop); + } + + public void setTableSwitchJump(int switchStart, int caseIndex, + int jumpTarget) + { + if (!(0 <= jumpTarget && jumpTarget <= itsCodeBufferTop)) + throw new IllegalArgumentException("Bad jump target: "+jumpTarget); + if (!(caseIndex >= -1)) + throw new IllegalArgumentException("Bad case index: "+caseIndex); + + int padSize = 3 & ~switchStart; // == 3 - switchStart % 4 + int caseOffset; + if (caseIndex < 0) { + // default label + caseOffset = switchStart + 1 + padSize; + } else { + caseOffset = switchStart + 1 + padSize + 4 * (3 + caseIndex); + } + if (!(0 <= switchStart + && switchStart <= itsCodeBufferTop - 4 * 4 - padSize - 1)) + { + throw new IllegalArgumentException( + switchStart+" is outside a possible range of tableswitch" + +" in already generated code"); + } + if ((0xFF & itsCodeBuffer[switchStart]) != ByteCode.TABLESWITCH) { + throw new IllegalArgumentException( + switchStart+" is not offset of tableswitch statement"); + } + if (!(0 <= caseOffset && caseOffset + 4 <= itsCodeBufferTop)) { + // caseIndex >= -1 does not guarantee that caseOffset >= 0 due + // to a possible overflow. + throw new ClassFileFormatException( + "Too big case index: "+caseIndex); + } + // ALERT: perhaps check against case bounds? + putInt32(jumpTarget - switchStart, itsCodeBuffer, caseOffset); + } + + public int acquireLabel() + { + int top = itsLabelTableTop; + if (itsLabelTable == null || top == itsLabelTable.length) { + if (itsLabelTable == null) { + itsLabelTable = new int[MIN_LABEL_TABLE_SIZE]; + }else { + int[] tmp = new int[itsLabelTable.length * 2]; + System.arraycopy(itsLabelTable, 0, tmp, 0, top); + itsLabelTable = tmp; + } + } + itsLabelTableTop = top + 1; + itsLabelTable[top] = -1; + return top | 0x80000000; + } + + public void markLabel(int label) + { + if (!(label < 0)) + throw new IllegalArgumentException("Bad label, no biscuit"); + + label &= 0x7FFFFFFF; + if (label > itsLabelTableTop) + throw new IllegalArgumentException("Bad label"); + + if (itsLabelTable[label] != -1) { + throw new IllegalStateException("Can only mark label once"); + } + + itsLabelTable[label] = itsCodeBufferTop; + } + + public void markLabel(int label, short stackTop) + { + markLabel(label); + itsStackTop = stackTop; + } + + public void markHandler(int theLabel) { + itsStackTop = 1; + markLabel(theLabel); + } + + private int getLabelPC(int label) + { + if (!(label < 0)) + throw new IllegalArgumentException("Bad label, no biscuit"); + label &= 0x7FFFFFFF; + if (!(label < itsLabelTableTop)) + throw new IllegalArgumentException("Bad label"); + return itsLabelTable[label]; + } + + private void addLabelFixup(int label, int fixupSite) + { + if (!(label < 0)) + throw new IllegalArgumentException("Bad label, no biscuit"); + label &= 0x7FFFFFFF; + if (!(label < itsLabelTableTop)) + throw new IllegalArgumentException("Bad label"); + int top = itsFixupTableTop; + if (itsFixupTable == null || top == itsFixupTable.length) { + if (itsFixupTable == null) { + itsFixupTable = new long[MIN_FIXUP_TABLE_SIZE]; + }else { + long[] tmp = new long[itsFixupTable.length * 2]; + System.arraycopy(itsFixupTable, 0, tmp, 0, top); + itsFixupTable = tmp; + } + } + itsFixupTableTop = top + 1; + itsFixupTable[top] = ((long)label << 32) | fixupSite; + } + + private void fixLabelGotos() + { + byte[] codeBuffer = itsCodeBuffer; + for (int i = 0; i < itsFixupTableTop; i++) { + long fixup = itsFixupTable[i]; + int label = (int)(fixup >> 32); + int fixupSite = (int)fixup; + int pc = itsLabelTable[label]; + if (pc == -1) { + // Unlocated label + throw new RuntimeException(); + } + // -1 to get delta from instruction start + int offset = pc - (fixupSite - 1); + if ((short)offset != offset) { + throw new ClassFileFormatException + ("Program too complex: too big jump offset"); + } + codeBuffer[fixupSite] = (byte)(offset >> 8); + codeBuffer[fixupSite + 1] = (byte)offset; + } + itsFixupTableTop = 0; + } + + /** + * Get the current offset into the code of the current method. + * + * @return an integer representing the offset + */ + public int getCurrentCodeOffset() { + return itsCodeBufferTop; + } + + public short getStackTop() { + return itsStackTop; + } + + public void setStackTop(short n) { + itsStackTop = n; + } + + public void adjustStackTop(int delta) { + int newStack = itsStackTop + delta; + if (newStack < 0 || Short.MAX_VALUE < newStack) badStack(newStack); + itsStackTop = (short)newStack; + if (newStack > itsMaxStack) itsMaxStack = (short)newStack; + if (DEBUGSTACK) { + System.out.println("After "+"adjustStackTop("+delta+")" + +" stack = "+itsStackTop); + } + } + + private void addToCodeBuffer(int b) + { + int N = addReservedCodeSpace(1); + itsCodeBuffer[N] = (byte)b; + } + + private void addToCodeInt16(int value) + { + int N = addReservedCodeSpace(2); + putInt16(value, itsCodeBuffer, N); + } + + private int addReservedCodeSpace(int size) + { + if (itsCurrentMethod == null) + throw new IllegalArgumentException("No method to add to"); + int oldTop = itsCodeBufferTop; + int newTop = oldTop + size; + if (newTop > itsCodeBuffer.length) { + int newSize = itsCodeBuffer.length * 2; + if (newTop > newSize) { newSize = newTop; } + byte[] tmp = new byte[newSize]; + System.arraycopy(itsCodeBuffer, 0, tmp, 0, oldTop); + itsCodeBuffer = tmp; + } + itsCodeBufferTop = newTop; + return oldTop; + } + + public void addExceptionHandler(int startLabel, int endLabel, + int handlerLabel, String catchClassName) + { + if ((startLabel & 0x80000000) != 0x80000000) + throw new IllegalArgumentException("Bad startLabel"); + if ((endLabel & 0x80000000) != 0x80000000) + throw new IllegalArgumentException("Bad endLabel"); + if ((handlerLabel & 0x80000000) != 0x80000000) + throw new IllegalArgumentException("Bad handlerLabel"); + + /* + * If catchClassName is null, use 0 for the catch_type_index; which + * means catch everything. (Even when the verifier has let you throw + * something other than a Throwable.) + */ + short catch_type_index = (catchClassName == null) + ? 0 + : itsConstantPool.addClass(catchClassName); + ExceptionTableEntry newEntry = new ExceptionTableEntry( + startLabel, + endLabel, + handlerLabel, + catch_type_index); + int N = itsExceptionTableTop; + if (N == 0) { + itsExceptionTable = new ExceptionTableEntry[ExceptionTableSize]; + } else if (N == itsExceptionTable.length) { + ExceptionTableEntry[] tmp = new ExceptionTableEntry[N * 2]; + System.arraycopy(itsExceptionTable, 0, tmp, 0, N); + itsExceptionTable = tmp; + } + itsExceptionTable[N] = newEntry; + itsExceptionTableTop = N + 1; + + } + + public void addLineNumberEntry(short lineNumber) { + if (itsCurrentMethod == null) + throw new IllegalArgumentException("No method to stop"); + int N = itsLineNumberTableTop; + if (N == 0) { + itsLineNumberTable = new int[LineNumberTableSize]; + } else if (N == itsLineNumberTable.length) { + int[] tmp = new int[N * 2]; + System.arraycopy(itsLineNumberTable, 0, tmp, 0, N); + itsLineNumberTable = tmp; + } + itsLineNumberTable[N] = (itsCodeBufferTop << 16) + lineNumber; + itsLineNumberTableTop = N + 1; + } + + /** + * Write the class file to the OutputStream. + * + * @param oStream the stream to write to + * @throws IOException if writing to the stream produces an exception + */ + public void write(OutputStream oStream) + throws IOException + { + byte[] array = toByteArray(); + oStream.write(array); + } + + private int getWriteSize() + { + int size = 0; + + if (itsSourceFileNameIndex != 0) { + itsConstantPool.addUtf8("SourceFile"); + } + + size += 8; //writeLong(FileHeaderConstant); + size += itsConstantPool.getWriteSize(); + size += 2; //writeShort(itsFlags); + size += 2; //writeShort(itsThisClassIndex); + size += 2; //writeShort(itsSuperClassIndex); + size += 2; //writeShort(itsInterfaces.size()); + size += 2 * itsInterfaces.size(); + + size += 2; //writeShort(itsFields.size()); + for (int i = 0; i < itsFields.size(); i++) { + size += ((ClassFileField)(itsFields.get(i))).getWriteSize(); + } + + size += 2; //writeShort(itsMethods.size()); + for (int i = 0; i < itsMethods.size(); i++) { + size += ((ClassFileMethod)(itsMethods.get(i))).getWriteSize(); + } + + if (itsSourceFileNameIndex != 0) { + size += 2; //writeShort(1); attributes count + size += 2; //writeShort(sourceFileAttributeNameIndex); + size += 4; //writeInt(2); + size += 2; //writeShort(itsSourceFileNameIndex); + }else { + size += 2; //out.writeShort(0); no attributes + } + + return size; + } + + /** + * Get the class file as array of bytesto the OutputStream. + */ + public byte[] toByteArray() + { + int dataSize = getWriteSize(); + byte[] data = new byte[dataSize]; + int offset = 0; + + short sourceFileAttributeNameIndex = 0; + if (itsSourceFileNameIndex != 0) { + sourceFileAttributeNameIndex = itsConstantPool.addUtf8( + "SourceFile"); + } + + offset = putInt64(FileHeaderConstant, data, offset); + offset = itsConstantPool.write(data, offset); + offset = putInt16(itsFlags, data, offset); + offset = putInt16(itsThisClassIndex, data, offset); + offset = putInt16(itsSuperClassIndex, data, offset); + offset = putInt16(itsInterfaces.size(), data, offset); + for (int i = 0; i < itsInterfaces.size(); i++) { + int interfaceIndex = ((Short)(itsInterfaces.get(i))).shortValue(); + offset = putInt16(interfaceIndex, data, offset); + } + offset = putInt16(itsFields.size(), data, offset); + for (int i = 0; i < itsFields.size(); i++) { + ClassFileField field = (ClassFileField)itsFields.get(i); + offset = field.write(data, offset); + } + offset = putInt16(itsMethods.size(), data, offset); + for (int i = 0; i < itsMethods.size(); i++) { + ClassFileMethod method = (ClassFileMethod)itsMethods.get(i); + offset = method.write(data, offset); + } + if (itsSourceFileNameIndex != 0) { + offset = putInt16(1, data, offset); // attributes count + offset = putInt16(sourceFileAttributeNameIndex, data, offset); + offset = putInt32(2, data, offset); + offset = putInt16(itsSourceFileNameIndex, data, offset); + } else { + offset = putInt16(0, data, offset); // no attributes + } + + if (offset != dataSize) { + // Check getWriteSize is consistent with write! + throw new RuntimeException(); + } + + return data; + } + + static int putInt64(long value, byte[] array, int offset) + { + offset = putInt32((int)(value >>> 32), array, offset); + return putInt32((int)value, array, offset); + } + + private static void badStack(int value) + { + String s; + if (value < 0) { s = "Stack underflow: "+value; } + else { s = "Too big stack: "+value; } + throw new IllegalStateException(s); + } + + /* + Really weird. Returns an int with # parameters in hi 16 bits, and + stack difference removal of parameters from stack and pushing the + result (it does not take into account removal of this in case of + non-static methods). + If Java really supported references we wouldn't have to be this + perverted. + */ + private static int sizeOfParameters(String pString) + { + int length = pString.length(); + int rightParenthesis = pString.lastIndexOf(')'); + if (3 <= length /* minimal signature takes at least 3 chars: ()V */ + && pString.charAt(0) == '(' + && 1 <= rightParenthesis && rightParenthesis + 1 < length) + { + boolean ok = true; + int index = 1; + int stackDiff = 0; + int count = 0; + stringLoop: + while (index != rightParenthesis) { + switch (pString.charAt(index)) { + default: + ok = false; + break stringLoop; + case 'J' : + case 'D' : + --stackDiff; + // fall thru + case 'B' : + case 'S' : + case 'C' : + case 'I' : + case 'Z' : + case 'F' : + --stackDiff; + ++count; + ++index; + continue; + case '[' : + ++index; + int c = pString.charAt(index); + while (c == '[') { + ++index; + c = pString.charAt(index); + } + switch (c) { + default: + ok = false; + break stringLoop; + case 'J' : + case 'D' : + case 'B' : + case 'S' : + case 'C' : + case 'I' : + case 'Z' : + case 'F' : + --stackDiff; + ++count; + ++index; + continue; + case 'L': + // fall thru + } + // fall thru + case 'L' : { + --stackDiff; + ++count; + ++index; + int semicolon = pString.indexOf(';', index); + if (!(index + 1 <= semicolon + && semicolon < rightParenthesis)) + { + ok = false; + break stringLoop; + } + index = semicolon + 1; + continue; + } + } + } + if (ok) { + switch (pString.charAt(rightParenthesis + 1)) { + default: + ok = false; + break; + case 'J' : + case 'D' : + ++stackDiff; + // fall thru + case 'B' : + case 'S' : + case 'C' : + case 'I' : + case 'Z' : + case 'F' : + case 'L' : + case '[' : + ++stackDiff; + // fall thru + case 'V' : + break; + } + if (ok) { + return ((count << 16) | (0xFFFF & stackDiff)); + } + } + } + throw new IllegalArgumentException( + "Bad parameter signature: "+pString); + } + + static int putInt16(int value, byte[] array, int offset) + { + array[offset + 0] = (byte)(value >>> 8); + array[offset + 1] = (byte)value; + return offset + 2; + } + + static int putInt32(int value, byte[] array, int offset) + { + array[offset + 0] = (byte)(value >>> 24); + array[offset + 1] = (byte)(value >>> 16); + array[offset + 2] = (byte)(value >>> 8); + array[offset + 3] = (byte)value; + return offset + 4; + } + + /** + * Number of operands accompanying the opcode. + */ + static int opcodeCount(int opcode) + { + switch (opcode) { + case ByteCode.AALOAD: + case ByteCode.AASTORE: + case ByteCode.ACONST_NULL: + case ByteCode.ALOAD_0: + case ByteCode.ALOAD_1: + case ByteCode.ALOAD_2: + case ByteCode.ALOAD_3: + case ByteCode.ARETURN: + case ByteCode.ARRAYLENGTH: + case ByteCode.ASTORE_0: + case ByteCode.ASTORE_1: + case ByteCode.ASTORE_2: + case ByteCode.ASTORE_3: + case ByteCode.ATHROW: + case ByteCode.BALOAD: + case ByteCode.BASTORE: + case ByteCode.BREAKPOINT: + case ByteCode.CALOAD: + case ByteCode.CASTORE: + case ByteCode.D2F: + case ByteCode.D2I: + case ByteCode.D2L: + case ByteCode.DADD: + case ByteCode.DALOAD: + case ByteCode.DASTORE: + case ByteCode.DCMPG: + case ByteCode.DCMPL: + case ByteCode.DCONST_0: + case ByteCode.DCONST_1: + case ByteCode.DDIV: + case ByteCode.DLOAD_0: + case ByteCode.DLOAD_1: + case ByteCode.DLOAD_2: + case ByteCode.DLOAD_3: + case ByteCode.DMUL: + case ByteCode.DNEG: + case ByteCode.DREM: + case ByteCode.DRETURN: + case ByteCode.DSTORE_0: + case ByteCode.DSTORE_1: + case ByteCode.DSTORE_2: + case ByteCode.DSTORE_3: + case ByteCode.DSUB: + case ByteCode.DUP: + case ByteCode.DUP2: + case ByteCode.DUP2_X1: + case ByteCode.DUP2_X2: + case ByteCode.DUP_X1: + case ByteCode.DUP_X2: + case ByteCode.F2D: + case ByteCode.F2I: + case ByteCode.F2L: + case ByteCode.FADD: + case ByteCode.FALOAD: + case ByteCode.FASTORE: + case ByteCode.FCMPG: + case ByteCode.FCMPL: + case ByteCode.FCONST_0: + case ByteCode.FCONST_1: + case ByteCode.FCONST_2: + case ByteCode.FDIV: + case ByteCode.FLOAD_0: + case ByteCode.FLOAD_1: + case ByteCode.FLOAD_2: + case ByteCode.FLOAD_3: + case ByteCode.FMUL: + case ByteCode.FNEG: + case ByteCode.FREM: + case ByteCode.FRETURN: + case ByteCode.FSTORE_0: + case ByteCode.FSTORE_1: + case ByteCode.FSTORE_2: + case ByteCode.FSTORE_3: + case ByteCode.FSUB: + case ByteCode.I2B: + case ByteCode.I2C: + case ByteCode.I2D: + case ByteCode.I2F: + case ByteCode.I2L: + case ByteCode.I2S: + case ByteCode.IADD: + case ByteCode.IALOAD: + case ByteCode.IAND: + case ByteCode.IASTORE: + case ByteCode.ICONST_0: + case ByteCode.ICONST_1: + case ByteCode.ICONST_2: + case ByteCode.ICONST_3: + case ByteCode.ICONST_4: + case ByteCode.ICONST_5: + case ByteCode.ICONST_M1: + case ByteCode.IDIV: + case ByteCode.ILOAD_0: + case ByteCode.ILOAD_1: + case ByteCode.ILOAD_2: + case ByteCode.ILOAD_3: + case ByteCode.IMPDEP1: + case ByteCode.IMPDEP2: + case ByteCode.IMUL: + case ByteCode.INEG: + case ByteCode.IOR: + case ByteCode.IREM: + case ByteCode.IRETURN: + case ByteCode.ISHL: + case ByteCode.ISHR: + case ByteCode.ISTORE_0: + case ByteCode.ISTORE_1: + case ByteCode.ISTORE_2: + case ByteCode.ISTORE_3: + case ByteCode.ISUB: + case ByteCode.IUSHR: + case ByteCode.IXOR: + case ByteCode.L2D: + case ByteCode.L2F: + case ByteCode.L2I: + case ByteCode.LADD: + case ByteCode.LALOAD: + case ByteCode.LAND: + case ByteCode.LASTORE: + case ByteCode.LCMP: + case ByteCode.LCONST_0: + case ByteCode.LCONST_1: + case ByteCode.LDIV: + case ByteCode.LLOAD_0: + case ByteCode.LLOAD_1: + case ByteCode.LLOAD_2: + case ByteCode.LLOAD_3: + case ByteCode.LMUL: + case ByteCode.LNEG: + case ByteCode.LOR: + case ByteCode.LREM: + case ByteCode.LRETURN: + case ByteCode.LSHL: + case ByteCode.LSHR: + case ByteCode.LSTORE_0: + case ByteCode.LSTORE_1: + case ByteCode.LSTORE_2: + case ByteCode.LSTORE_3: + case ByteCode.LSUB: + case ByteCode.LUSHR: + case ByteCode.LXOR: + case ByteCode.MONITORENTER: + case ByteCode.MONITOREXIT: + case ByteCode.NOP: + case ByteCode.POP: + case ByteCode.POP2: + case ByteCode.RETURN: + case ByteCode.SALOAD: + case ByteCode.SASTORE: + case ByteCode.SWAP: + case ByteCode.WIDE: + return 0; + case ByteCode.ALOAD: + case ByteCode.ANEWARRAY: + case ByteCode.ASTORE: + case ByteCode.BIPUSH: + case ByteCode.CHECKCAST: + case ByteCode.DLOAD: + case ByteCode.DSTORE: + case ByteCode.FLOAD: + case ByteCode.FSTORE: + case ByteCode.GETFIELD: + case ByteCode.GETSTATIC: + case ByteCode.GOTO: + case ByteCode.GOTO_W: + case ByteCode.IFEQ: + case ByteCode.IFGE: + case ByteCode.IFGT: + case ByteCode.IFLE: + case ByteCode.IFLT: + case ByteCode.IFNE: + case ByteCode.IFNONNULL: + case ByteCode.IFNULL: + case ByteCode.IF_ACMPEQ: + case ByteCode.IF_ACMPNE: + case ByteCode.IF_ICMPEQ: + case ByteCode.IF_ICMPGE: + case ByteCode.IF_ICMPGT: + case ByteCode.IF_ICMPLE: + case ByteCode.IF_ICMPLT: + case ByteCode.IF_ICMPNE: + case ByteCode.ILOAD: + case ByteCode.INSTANCEOF: + case ByteCode.INVOKEINTERFACE: + case ByteCode.INVOKESPECIAL: + case ByteCode.INVOKESTATIC: + case ByteCode.INVOKEVIRTUAL: + case ByteCode.ISTORE: + case ByteCode.JSR: + case ByteCode.JSR_W: + case ByteCode.LDC: + case ByteCode.LDC2_W: + case ByteCode.LDC_W: + case ByteCode.LLOAD: + case ByteCode.LSTORE: + case ByteCode.NEW: + case ByteCode.NEWARRAY: + case ByteCode.PUTFIELD: + case ByteCode.PUTSTATIC: + case ByteCode.RET: + case ByteCode.SIPUSH: + return 1; + + case ByteCode.IINC: + case ByteCode.MULTIANEWARRAY: + return 2; + + case ByteCode.LOOKUPSWITCH: + case ByteCode.TABLESWITCH: + return -1; + } + throw new IllegalArgumentException("Bad opcode: "+opcode); + } + + /** + * The effect on the operand stack of a given opcode. + */ + static int stackChange(int opcode) + { + // For INVOKE... accounts only for popping this (unless static), + // ignoring parameters and return type + switch (opcode) { + case ByteCode.DASTORE: + case ByteCode.LASTORE: + return -4; + + case ByteCode.AASTORE: + case ByteCode.BASTORE: + case ByteCode.CASTORE: + case ByteCode.DCMPG: + case ByteCode.DCMPL: + case ByteCode.FASTORE: + case ByteCode.IASTORE: + case ByteCode.LCMP: + case ByteCode.SASTORE: + return -3; + + case ByteCode.DADD: + case ByteCode.DDIV: + case ByteCode.DMUL: + case ByteCode.DREM: + case ByteCode.DRETURN: + case ByteCode.DSTORE: + case ByteCode.DSTORE_0: + case ByteCode.DSTORE_1: + case ByteCode.DSTORE_2: + case ByteCode.DSTORE_3: + case ByteCode.DSUB: + case ByteCode.IF_ACMPEQ: + case ByteCode.IF_ACMPNE: + case ByteCode.IF_ICMPEQ: + case ByteCode.IF_ICMPGE: + case ByteCode.IF_ICMPGT: + case ByteCode.IF_ICMPLE: + case ByteCode.IF_ICMPLT: + case ByteCode.IF_ICMPNE: + case ByteCode.LADD: + case ByteCode.LAND: + case ByteCode.LDIV: + case ByteCode.LMUL: + case ByteCode.LOR: + case ByteCode.LREM: + case ByteCode.LRETURN: + case ByteCode.LSTORE: + case ByteCode.LSTORE_0: + case ByteCode.LSTORE_1: + case ByteCode.LSTORE_2: + case ByteCode.LSTORE_3: + case ByteCode.LSUB: + case ByteCode.LXOR: + case ByteCode.POP2: + return -2; + + case ByteCode.AALOAD: + case ByteCode.ARETURN: + case ByteCode.ASTORE: + case ByteCode.ASTORE_0: + case ByteCode.ASTORE_1: + case ByteCode.ASTORE_2: + case ByteCode.ASTORE_3: + case ByteCode.ATHROW: + case ByteCode.BALOAD: + case ByteCode.CALOAD: + case ByteCode.D2F: + case ByteCode.D2I: + case ByteCode.FADD: + case ByteCode.FALOAD: + case ByteCode.FCMPG: + case ByteCode.FCMPL: + case ByteCode.FDIV: + case ByteCode.FMUL: + case ByteCode.FREM: + case ByteCode.FRETURN: + case ByteCode.FSTORE: + case ByteCode.FSTORE_0: + case ByteCode.FSTORE_1: + case ByteCode.FSTORE_2: + case ByteCode.FSTORE_3: + case ByteCode.FSUB: + case ByteCode.GETFIELD: + case ByteCode.IADD: + case ByteCode.IALOAD: + case ByteCode.IAND: + case ByteCode.IDIV: + case ByteCode.IFEQ: + case ByteCode.IFGE: + case ByteCode.IFGT: + case ByteCode.IFLE: + case ByteCode.IFLT: + case ByteCode.IFNE: + case ByteCode.IFNONNULL: + case ByteCode.IFNULL: + case ByteCode.IMUL: + case ByteCode.INVOKEINTERFACE: // + case ByteCode.INVOKESPECIAL: // but needs to account for + case ByteCode.INVOKEVIRTUAL: // pops 'this' (unless static) + case ByteCode.IOR: + case ByteCode.IREM: + case ByteCode.IRETURN: + case ByteCode.ISHL: + case ByteCode.ISHR: + case ByteCode.ISTORE: + case ByteCode.ISTORE_0: + case ByteCode.ISTORE_1: + case ByteCode.ISTORE_2: + case ByteCode.ISTORE_3: + case ByteCode.ISUB: + case ByteCode.IUSHR: + case ByteCode.IXOR: + case ByteCode.L2F: + case ByteCode.L2I: + case ByteCode.LOOKUPSWITCH: + case ByteCode.LSHL: + case ByteCode.LSHR: + case ByteCode.LUSHR: + case ByteCode.MONITORENTER: + case ByteCode.MONITOREXIT: + case ByteCode.POP: + case ByteCode.PUTFIELD: + case ByteCode.SALOAD: + case ByteCode.TABLESWITCH: + return -1; + + case ByteCode.ANEWARRAY: + case ByteCode.ARRAYLENGTH: + case ByteCode.BREAKPOINT: + case ByteCode.CHECKCAST: + case ByteCode.D2L: + case ByteCode.DALOAD: + case ByteCode.DNEG: + case ByteCode.F2I: + case ByteCode.FNEG: + case ByteCode.GETSTATIC: + case ByteCode.GOTO: + case ByteCode.GOTO_W: + case ByteCode.I2B: + case ByteCode.I2C: + case ByteCode.I2F: + case ByteCode.I2S: + case ByteCode.IINC: + case ByteCode.IMPDEP1: + case ByteCode.IMPDEP2: + case ByteCode.INEG: + case ByteCode.INSTANCEOF: + case ByteCode.INVOKESTATIC: + case ByteCode.L2D: + case ByteCode.LALOAD: + case ByteCode.LNEG: + case ByteCode.NEWARRAY: + case ByteCode.NOP: + case ByteCode.PUTSTATIC: + case ByteCode.RET: + case ByteCode.RETURN: + case ByteCode.SWAP: + case ByteCode.WIDE: + return 0; + + case ByteCode.ACONST_NULL: + case ByteCode.ALOAD: + case ByteCode.ALOAD_0: + case ByteCode.ALOAD_1: + case ByteCode.ALOAD_2: + case ByteCode.ALOAD_3: + case ByteCode.BIPUSH: + case ByteCode.DUP: + case ByteCode.DUP_X1: + case ByteCode.DUP_X2: + case ByteCode.F2D: + case ByteCode.F2L: + case ByteCode.FCONST_0: + case ByteCode.FCONST_1: + case ByteCode.FCONST_2: + case ByteCode.FLOAD: + case ByteCode.FLOAD_0: + case ByteCode.FLOAD_1: + case ByteCode.FLOAD_2: + case ByteCode.FLOAD_3: + case ByteCode.I2D: + case ByteCode.I2L: + case ByteCode.ICONST_0: + case ByteCode.ICONST_1: + case ByteCode.ICONST_2: + case ByteCode.ICONST_3: + case ByteCode.ICONST_4: + case ByteCode.ICONST_5: + case ByteCode.ICONST_M1: + case ByteCode.ILOAD: + case ByteCode.ILOAD_0: + case ByteCode.ILOAD_1: + case ByteCode.ILOAD_2: + case ByteCode.ILOAD_3: + case ByteCode.JSR: + case ByteCode.JSR_W: + case ByteCode.LDC: + case ByteCode.LDC_W: + case ByteCode.MULTIANEWARRAY: + case ByteCode.NEW: + case ByteCode.SIPUSH: + return 1; + + case ByteCode.DCONST_0: + case ByteCode.DCONST_1: + case ByteCode.DLOAD: + case ByteCode.DLOAD_0: + case ByteCode.DLOAD_1: + case ByteCode.DLOAD_2: + case ByteCode.DLOAD_3: + case ByteCode.DUP2: + case ByteCode.DUP2_X1: + case ByteCode.DUP2_X2: + case ByteCode.LCONST_0: + case ByteCode.LCONST_1: + case ByteCode.LDC2_W: + case ByteCode.LLOAD: + case ByteCode.LLOAD_0: + case ByteCode.LLOAD_1: + case ByteCode.LLOAD_2: + case ByteCode.LLOAD_3: + return 2; + } + throw new IllegalArgumentException("Bad opcode: "+opcode); + } + + /* + * Number of bytes of operands generated after the opcode. + * Not in use currently. + */ +/* + int extra(int opcode) + { + switch (opcode) { + case ByteCode.AALOAD: + case ByteCode.AASTORE: + case ByteCode.ACONST_NULL: + case ByteCode.ALOAD_0: + case ByteCode.ALOAD_1: + case ByteCode.ALOAD_2: + case ByteCode.ALOAD_3: + case ByteCode.ARETURN: + case ByteCode.ARRAYLENGTH: + case ByteCode.ASTORE_0: + case ByteCode.ASTORE_1: + case ByteCode.ASTORE_2: + case ByteCode.ASTORE_3: + case ByteCode.ATHROW: + case ByteCode.BALOAD: + case ByteCode.BASTORE: + case ByteCode.BREAKPOINT: + case ByteCode.CALOAD: + case ByteCode.CASTORE: + case ByteCode.D2F: + case ByteCode.D2I: + case ByteCode.D2L: + case ByteCode.DADD: + case ByteCode.DALOAD: + case ByteCode.DASTORE: + case ByteCode.DCMPG: + case ByteCode.DCMPL: + case ByteCode.DCONST_0: + case ByteCode.DCONST_1: + case ByteCode.DDIV: + case ByteCode.DLOAD_0: + case ByteCode.DLOAD_1: + case ByteCode.DLOAD_2: + case ByteCode.DLOAD_3: + case ByteCode.DMUL: + case ByteCode.DNEG: + case ByteCode.DREM: + case ByteCode.DRETURN: + case ByteCode.DSTORE_0: + case ByteCode.DSTORE_1: + case ByteCode.DSTORE_2: + case ByteCode.DSTORE_3: + case ByteCode.DSUB: + case ByteCode.DUP2: + case ByteCode.DUP2_X1: + case ByteCode.DUP2_X2: + case ByteCode.DUP: + case ByteCode.DUP_X1: + case ByteCode.DUP_X2: + case ByteCode.F2D: + case ByteCode.F2I: + case ByteCode.F2L: + case ByteCode.FADD: + case ByteCode.FALOAD: + case ByteCode.FASTORE: + case ByteCode.FCMPG: + case ByteCode.FCMPL: + case ByteCode.FCONST_0: + case ByteCode.FCONST_1: + case ByteCode.FCONST_2: + case ByteCode.FDIV: + case ByteCode.FLOAD_0: + case ByteCode.FLOAD_1: + case ByteCode.FLOAD_2: + case ByteCode.FLOAD_3: + case ByteCode.FMUL: + case ByteCode.FNEG: + case ByteCode.FREM: + case ByteCode.FRETURN: + case ByteCode.FSTORE_0: + case ByteCode.FSTORE_1: + case ByteCode.FSTORE_2: + case ByteCode.FSTORE_3: + case ByteCode.FSUB: + case ByteCode.I2B: + case ByteCode.I2C: + case ByteCode.I2D: + case ByteCode.I2F: + case ByteCode.I2L: + case ByteCode.I2S: + case ByteCode.IADD: + case ByteCode.IALOAD: + case ByteCode.IAND: + case ByteCode.IASTORE: + case ByteCode.ICONST_0: + case ByteCode.ICONST_1: + case ByteCode.ICONST_2: + case ByteCode.ICONST_3: + case ByteCode.ICONST_4: + case ByteCode.ICONST_5: + case ByteCode.ICONST_M1: + case ByteCode.IDIV: + case ByteCode.ILOAD_0: + case ByteCode.ILOAD_1: + case ByteCode.ILOAD_2: + case ByteCode.ILOAD_3: + case ByteCode.IMPDEP1: + case ByteCode.IMPDEP2: + case ByteCode.IMUL: + case ByteCode.INEG: + case ByteCode.IOR: + case ByteCode.IREM: + case ByteCode.IRETURN: + case ByteCode.ISHL: + case ByteCode.ISHR: + case ByteCode.ISTORE_0: + case ByteCode.ISTORE_1: + case ByteCode.ISTORE_2: + case ByteCode.ISTORE_3: + case ByteCode.ISUB: + case ByteCode.IUSHR: + case ByteCode.IXOR: + case ByteCode.L2D: + case ByteCode.L2F: + case ByteCode.L2I: + case ByteCode.LADD: + case ByteCode.LALOAD: + case ByteCode.LAND: + case ByteCode.LASTORE: + case ByteCode.LCMP: + case ByteCode.LCONST_0: + case ByteCode.LCONST_1: + case ByteCode.LDIV: + case ByteCode.LLOAD_0: + case ByteCode.LLOAD_1: + case ByteCode.LLOAD_2: + case ByteCode.LLOAD_3: + case ByteCode.LMUL: + case ByteCode.LNEG: + case ByteCode.LOR: + case ByteCode.LREM: + case ByteCode.LRETURN: + case ByteCode.LSHL: + case ByteCode.LSHR: + case ByteCode.LSTORE_0: + case ByteCode.LSTORE_1: + case ByteCode.LSTORE_2: + case ByteCode.LSTORE_3: + case ByteCode.LSUB: + case ByteCode.LUSHR: + case ByteCode.LXOR: + case ByteCode.MONITORENTER: + case ByteCode.MONITOREXIT: + case ByteCode.NOP: + case ByteCode.POP2: + case ByteCode.POP: + case ByteCode.RETURN: + case ByteCode.SALOAD: + case ByteCode.SASTORE: + case ByteCode.SWAP: + case ByteCode.WIDE: + return 0; + + case ByteCode.ALOAD: + case ByteCode.ASTORE: + case ByteCode.BIPUSH: + case ByteCode.DLOAD: + case ByteCode.DSTORE: + case ByteCode.FLOAD: + case ByteCode.FSTORE: + case ByteCode.ILOAD: + case ByteCode.ISTORE: + case ByteCode.LDC: + case ByteCode.LLOAD: + case ByteCode.LSTORE: + case ByteCode.NEWARRAY: + case ByteCode.RET: + return 1; + + case ByteCode.ANEWARRAY: + case ByteCode.CHECKCAST: + case ByteCode.GETFIELD: + case ByteCode.GETSTATIC: + case ByteCode.GOTO: + case ByteCode.IFEQ: + case ByteCode.IFGE: + case ByteCode.IFGT: + case ByteCode.IFLE: + case ByteCode.IFLT: + case ByteCode.IFNE: + case ByteCode.IFNONNULL: + case ByteCode.IFNULL: + case ByteCode.IF_ACMPEQ: + case ByteCode.IF_ACMPNE: + case ByteCode.IF_ICMPEQ: + case ByteCode.IF_ICMPGE: + case ByteCode.IF_ICMPGT: + case ByteCode.IF_ICMPLE: + case ByteCode.IF_ICMPLT: + case ByteCode.IF_ICMPNE: + case ByteCode.IINC: + case ByteCode.INSTANCEOF: + case ByteCode.INVOKEINTERFACE: + case ByteCode.INVOKESPECIAL: + case ByteCode.INVOKESTATIC: + case ByteCode.INVOKEVIRTUAL: + case ByteCode.JSR: + case ByteCode.LDC2_W: + case ByteCode.LDC_W: + case ByteCode.NEW: + case ByteCode.PUTFIELD: + case ByteCode.PUTSTATIC: + case ByteCode.SIPUSH: + return 2; + + case ByteCode.MULTIANEWARRAY: + return 3; + + case ByteCode.GOTO_W: + case ByteCode.JSR_W: + return 4; + + case ByteCode.LOOKUPSWITCH: // depends on alignment + case ByteCode.TABLESWITCH: // depends on alignment + return -1; + } + throw new IllegalArgumentException("Bad opcode: "+opcode); + } +*/ + private static String bytecodeStr(int code) + { + if (DEBUGSTACK || DEBUGCODE) { + switch (code) { + case ByteCode.NOP: return "nop"; + case ByteCode.ACONST_NULL: return "aconst_null"; + case ByteCode.ICONST_M1: return "iconst_m1"; + case ByteCode.ICONST_0: return "iconst_0"; + case ByteCode.ICONST_1: return "iconst_1"; + case ByteCode.ICONST_2: return "iconst_2"; + case ByteCode.ICONST_3: return "iconst_3"; + case ByteCode.ICONST_4: return "iconst_4"; + case ByteCode.ICONST_5: return "iconst_5"; + case ByteCode.LCONST_0: return "lconst_0"; + case ByteCode.LCONST_1: return "lconst_1"; + case ByteCode.FCONST_0: return "fconst_0"; + case ByteCode.FCONST_1: return "fconst_1"; + case ByteCode.FCONST_2: return "fconst_2"; + case ByteCode.DCONST_0: return "dconst_0"; + case ByteCode.DCONST_1: return "dconst_1"; + case ByteCode.BIPUSH: return "bipush"; + case ByteCode.SIPUSH: return "sipush"; + case ByteCode.LDC: return "ldc"; + case ByteCode.LDC_W: return "ldc_w"; + case ByteCode.LDC2_W: return "ldc2_w"; + case ByteCode.ILOAD: return "iload"; + case ByteCode.LLOAD: return "lload"; + case ByteCode.FLOAD: return "fload"; + case ByteCode.DLOAD: return "dload"; + case ByteCode.ALOAD: return "aload"; + case ByteCode.ILOAD_0: return "iload_0"; + case ByteCode.ILOAD_1: return "iload_1"; + case ByteCode.ILOAD_2: return "iload_2"; + case ByteCode.ILOAD_3: return "iload_3"; + case ByteCode.LLOAD_0: return "lload_0"; + case ByteCode.LLOAD_1: return "lload_1"; + case ByteCode.LLOAD_2: return "lload_2"; + case ByteCode.LLOAD_3: return "lload_3"; + case ByteCode.FLOAD_0: return "fload_0"; + case ByteCode.FLOAD_1: return "fload_1"; + case ByteCode.FLOAD_2: return "fload_2"; + case ByteCode.FLOAD_3: return "fload_3"; + case ByteCode.DLOAD_0: return "dload_0"; + case ByteCode.DLOAD_1: return "dload_1"; + case ByteCode.DLOAD_2: return "dload_2"; + case ByteCode.DLOAD_3: return "dload_3"; + case ByteCode.ALOAD_0: return "aload_0"; + case ByteCode.ALOAD_1: return "aload_1"; + case ByteCode.ALOAD_2: return "aload_2"; + case ByteCode.ALOAD_3: return "aload_3"; + case ByteCode.IALOAD: return "iaload"; + case ByteCode.LALOAD: return "laload"; + case ByteCode.FALOAD: return "faload"; + case ByteCode.DALOAD: return "daload"; + case ByteCode.AALOAD: return "aaload"; + case ByteCode.BALOAD: return "baload"; + case ByteCode.CALOAD: return "caload"; + case ByteCode.SALOAD: return "saload"; + case ByteCode.ISTORE: return "istore"; + case ByteCode.LSTORE: return "lstore"; + case ByteCode.FSTORE: return "fstore"; + case ByteCode.DSTORE: return "dstore"; + case ByteCode.ASTORE: return "astore"; + case ByteCode.ISTORE_0: return "istore_0"; + case ByteCode.ISTORE_1: return "istore_1"; + case ByteCode.ISTORE_2: return "istore_2"; + case ByteCode.ISTORE_3: return "istore_3"; + case ByteCode.LSTORE_0: return "lstore_0"; + case ByteCode.LSTORE_1: return "lstore_1"; + case ByteCode.LSTORE_2: return "lstore_2"; + case ByteCode.LSTORE_3: return "lstore_3"; + case ByteCode.FSTORE_0: return "fstore_0"; + case ByteCode.FSTORE_1: return "fstore_1"; + case ByteCode.FSTORE_2: return "fstore_2"; + case ByteCode.FSTORE_3: return "fstore_3"; + case ByteCode.DSTORE_0: return "dstore_0"; + case ByteCode.DSTORE_1: return "dstore_1"; + case ByteCode.DSTORE_2: return "dstore_2"; + case ByteCode.DSTORE_3: return "dstore_3"; + case ByteCode.ASTORE_0: return "astore_0"; + case ByteCode.ASTORE_1: return "astore_1"; + case ByteCode.ASTORE_2: return "astore_2"; + case ByteCode.ASTORE_3: return "astore_3"; + case ByteCode.IASTORE: return "iastore"; + case ByteCode.LASTORE: return "lastore"; + case ByteCode.FASTORE: return "fastore"; + case ByteCode.DASTORE: return "dastore"; + case ByteCode.AASTORE: return "aastore"; + case ByteCode.BASTORE: return "bastore"; + case ByteCode.CASTORE: return "castore"; + case ByteCode.SASTORE: return "sastore"; + case ByteCode.POP: return "pop"; + case ByteCode.POP2: return "pop2"; + case ByteCode.DUP: return "dup"; + case ByteCode.DUP_X1: return "dup_x1"; + case ByteCode.DUP_X2: return "dup_x2"; + case ByteCode.DUP2: return "dup2"; + case ByteCode.DUP2_X1: return "dup2_x1"; + case ByteCode.DUP2_X2: return "dup2_x2"; + case ByteCode.SWAP: return "swap"; + case ByteCode.IADD: return "iadd"; + case ByteCode.LADD: return "ladd"; + case ByteCode.FADD: return "fadd"; + case ByteCode.DADD: return "dadd"; + case ByteCode.ISUB: return "isub"; + case ByteCode.LSUB: return "lsub"; + case ByteCode.FSUB: return "fsub"; + case ByteCode.DSUB: return "dsub"; + case ByteCode.IMUL: return "imul"; + case ByteCode.LMUL: return "lmul"; + case ByteCode.FMUL: return "fmul"; + case ByteCode.DMUL: return "dmul"; + case ByteCode.IDIV: return "idiv"; + case ByteCode.LDIV: return "ldiv"; + case ByteCode.FDIV: return "fdiv"; + case ByteCode.DDIV: return "ddiv"; + case ByteCode.IREM: return "irem"; + case ByteCode.LREM: return "lrem"; + case ByteCode.FREM: return "frem"; + case ByteCode.DREM: return "drem"; + case ByteCode.INEG: return "ineg"; + case ByteCode.LNEG: return "lneg"; + case ByteCode.FNEG: return "fneg"; + case ByteCode.DNEG: return "dneg"; + case ByteCode.ISHL: return "ishl"; + case ByteCode.LSHL: return "lshl"; + case ByteCode.ISHR: return "ishr"; + case ByteCode.LSHR: return "lshr"; + case ByteCode.IUSHR: return "iushr"; + case ByteCode.LUSHR: return "lushr"; + case ByteCode.IAND: return "iand"; + case ByteCode.LAND: return "land"; + case ByteCode.IOR: return "ior"; + case ByteCode.LOR: return "lor"; + case ByteCode.IXOR: return "ixor"; + case ByteCode.LXOR: return "lxor"; + case ByteCode.IINC: return "iinc"; + case ByteCode.I2L: return "i2l"; + case ByteCode.I2F: return "i2f"; + case ByteCode.I2D: return "i2d"; + case ByteCode.L2I: return "l2i"; + case ByteCode.L2F: return "l2f"; + case ByteCode.L2D: return "l2d"; + case ByteCode.F2I: return "f2i"; + case ByteCode.F2L: return "f2l"; + case ByteCode.F2D: return "f2d"; + case ByteCode.D2I: return "d2i"; + case ByteCode.D2L: return "d2l"; + case ByteCode.D2F: return "d2f"; + case ByteCode.I2B: return "i2b"; + case ByteCode.I2C: return "i2c"; + case ByteCode.I2S: return "i2s"; + case ByteCode.LCMP: return "lcmp"; + case ByteCode.FCMPL: return "fcmpl"; + case ByteCode.FCMPG: return "fcmpg"; + case ByteCode.DCMPL: return "dcmpl"; + case ByteCode.DCMPG: return "dcmpg"; + case ByteCode.IFEQ: return "ifeq"; + case ByteCode.IFNE: return "ifne"; + case ByteCode.IFLT: return "iflt"; + case ByteCode.IFGE: return "ifge"; + case ByteCode.IFGT: return "ifgt"; + case ByteCode.IFLE: return "ifle"; + case ByteCode.IF_ICMPEQ: return "if_icmpeq"; + case ByteCode.IF_ICMPNE: return "if_icmpne"; + case ByteCode.IF_ICMPLT: return "if_icmplt"; + case ByteCode.IF_ICMPGE: return "if_icmpge"; + case ByteCode.IF_ICMPGT: return "if_icmpgt"; + case ByteCode.IF_ICMPLE: return "if_icmple"; + case ByteCode.IF_ACMPEQ: return "if_acmpeq"; + case ByteCode.IF_ACMPNE: return "if_acmpne"; + case ByteCode.GOTO: return "goto"; + case ByteCode.JSR: return "jsr"; + case ByteCode.RET: return "ret"; + case ByteCode.TABLESWITCH: return "tableswitch"; + case ByteCode.LOOKUPSWITCH: return "lookupswitch"; + case ByteCode.IRETURN: return "ireturn"; + case ByteCode.LRETURN: return "lreturn"; + case ByteCode.FRETURN: return "freturn"; + case ByteCode.DRETURN: return "dreturn"; + case ByteCode.ARETURN: return "areturn"; + case ByteCode.RETURN: return "return"; + case ByteCode.GETSTATIC: return "getstatic"; + case ByteCode.PUTSTATIC: return "putstatic"; + case ByteCode.GETFIELD: return "getfield"; + case ByteCode.PUTFIELD: return "putfield"; + case ByteCode.INVOKEVIRTUAL: return "invokevirtual"; + case ByteCode.INVOKESPECIAL: return "invokespecial"; + case ByteCode.INVOKESTATIC: return "invokestatic"; + case ByteCode.INVOKEINTERFACE: return "invokeinterface"; + case ByteCode.NEW: return "new"; + case ByteCode.NEWARRAY: return "newarray"; + case ByteCode.ANEWARRAY: return "anewarray"; + case ByteCode.ARRAYLENGTH: return "arraylength"; + case ByteCode.ATHROW: return "athrow"; + case ByteCode.CHECKCAST: return "checkcast"; + case ByteCode.INSTANCEOF: return "instanceof"; + case ByteCode.MONITORENTER: return "monitorenter"; + case ByteCode.MONITOREXIT: return "monitorexit"; + case ByteCode.WIDE: return "wide"; + case ByteCode.MULTIANEWARRAY: return "multianewarray"; + case ByteCode.IFNULL: return "ifnull"; + case ByteCode.IFNONNULL: return "ifnonnull"; + case ByteCode.GOTO_W: return "goto_w"; + case ByteCode.JSR_W: return "jsr_w"; + case ByteCode.BREAKPOINT: return "breakpoint"; + + case ByteCode.IMPDEP1: return "impdep1"; + case ByteCode.IMPDEP2: return "impdep2"; + } + } + return ""; + } + + final char[] getCharBuffer(int minimalSize) + { + if (minimalSize > tmpCharBuffer.length) { + int newSize = tmpCharBuffer.length * 2; + if (minimalSize > newSize) { newSize = minimalSize; } + tmpCharBuffer = new char[newSize]; + } + return tmpCharBuffer; + } + + private static final int LineNumberTableSize = 16; + private static final int ExceptionTableSize = 4; + + private final static long FileHeaderConstant = 0xCAFEBABE0003002DL; + // Set DEBUG flags to true to get better checking and progress info. + private static final boolean DEBUGSTACK = false; + private static final boolean DEBUGLABELS = false; + private static final boolean DEBUGCODE = false; + + private String generatedClassName; + + private ExceptionTableEntry itsExceptionTable[]; + private int itsExceptionTableTop; + + private int itsLineNumberTable[]; // pack start_pc & line_number together + private int itsLineNumberTableTop; + + private byte[] itsCodeBuffer = new byte[256]; + private int itsCodeBufferTop; + + private ConstantPool itsConstantPool; + + private ClassFileMethod itsCurrentMethod; + private short itsStackTop; + + private short itsMaxStack; + private short itsMaxLocals; + + private ObjArray itsMethods = new ObjArray(); + private ObjArray itsFields = new ObjArray(); + private ObjArray itsInterfaces = new ObjArray(); + + private short itsFlags; + private short itsThisClassIndex; + private short itsSuperClassIndex; + private short itsSourceFileNameIndex; + + private static final int MIN_LABEL_TABLE_SIZE = 32; + private int[] itsLabelTable; + private int itsLabelTableTop; + +// itsFixupTable[i] = (label_index << 32) | fixup_site + private static final int MIN_FIXUP_TABLE_SIZE = 40; + private long[] itsFixupTable; + private int itsFixupTableTop; + private ObjArray itsVarDescriptors; + + private char[] tmpCharBuffer = new char[64]; +} + +final class ExceptionTableEntry +{ + + ExceptionTableEntry(int startLabel, int endLabel, + int handlerLabel, short catchType) + { + itsStartLabel = startLabel; + itsEndLabel = endLabel; + itsHandlerLabel = handlerLabel; + itsCatchType = catchType; + } + + int itsStartLabel; + int itsEndLabel; + int itsHandlerLabel; + short itsCatchType; +} + +final class ClassFileField +{ + + ClassFileField(short nameIndex, short typeIndex, short flags) + { + itsNameIndex = nameIndex; + itsTypeIndex = typeIndex; + itsFlags = flags; + itsHasAttributes = false; + } + + void setAttributes(short attr1, short attr2, short attr3, int index) + { + itsHasAttributes = true; + itsAttr1 = attr1; + itsAttr2 = attr2; + itsAttr3 = attr3; + itsIndex = index; + } + + int write(byte[] data, int offset) + { + offset = ClassFileWriter.putInt16(itsFlags, data, offset); + offset = ClassFileWriter.putInt16(itsNameIndex, data, offset); + offset = ClassFileWriter.putInt16(itsTypeIndex, data, offset); + if (!itsHasAttributes) { + // write 0 attributes + offset = ClassFileWriter.putInt16(0, data, offset); + } else { + offset = ClassFileWriter.putInt16(1, data, offset); + offset = ClassFileWriter.putInt16(itsAttr1, data, offset); + offset = ClassFileWriter.putInt16(itsAttr2, data, offset); + offset = ClassFileWriter.putInt16(itsAttr3, data, offset); + offset = ClassFileWriter.putInt16(itsIndex, data, offset); + } + return offset; + } + + int getWriteSize() + { + int size = 2 * 3; + if (!itsHasAttributes) { + size += 2; + } else { + size += 2 + 2 * 4; + } + return size; + } + + private short itsNameIndex; + private short itsTypeIndex; + private short itsFlags; + private boolean itsHasAttributes; + private short itsAttr1, itsAttr2, itsAttr3; + private int itsIndex; +} + +final class ClassFileMethod +{ + + ClassFileMethod(short nameIndex, short typeIndex, short flags) + { + itsNameIndex = nameIndex; + itsTypeIndex = typeIndex; + itsFlags = flags; + } + + void setCodeAttribute(byte codeAttribute[]) + { + itsCodeAttribute = codeAttribute; + } + + int write(byte[] data, int offset) + { + offset = ClassFileWriter.putInt16(itsFlags, data, offset); + offset = ClassFileWriter.putInt16(itsNameIndex, data, offset); + offset = ClassFileWriter.putInt16(itsTypeIndex, data, offset); + // Code attribute only + offset = ClassFileWriter.putInt16(1, data, offset); + System.arraycopy(itsCodeAttribute, 0, data, offset, + itsCodeAttribute.length); + offset += itsCodeAttribute.length; + return offset; + } + + int getWriteSize() + { + return 2 * 4 + itsCodeAttribute.length; + } + + private short itsNameIndex; + private short itsTypeIndex; + private short itsFlags; + private byte[] itsCodeAttribute; + +} + +final class ConstantPool +{ + + ConstantPool(ClassFileWriter cfw) + { + this.cfw = cfw; + itsTopIndex = 1; // the zero'th entry is reserved + itsPool = new byte[ConstantPoolSize]; + itsTop = 0; + } + + private static final int ConstantPoolSize = 256; + private static final byte + CONSTANT_Class = 7, + CONSTANT_Fieldref = 9, + CONSTANT_Methodref = 10, + CONSTANT_InterfaceMethodref = 11, + CONSTANT_String = 8, + CONSTANT_Integer = 3, + CONSTANT_Float = 4, + CONSTANT_Long = 5, + CONSTANT_Double = 6, + CONSTANT_NameAndType = 12, + CONSTANT_Utf8 = 1; + + int write(byte[] data, int offset) + { + offset = ClassFileWriter.putInt16((short)itsTopIndex, data, offset); + System.arraycopy(itsPool, 0, data, offset, itsTop); + offset += itsTop; + return offset; + } + + int getWriteSize() + { + return 2 + itsTop; + } + + int addConstant(int k) + { + ensure(5); + itsPool[itsTop++] = CONSTANT_Integer; + itsTop = ClassFileWriter.putInt32(k, itsPool, itsTop); + return (short)(itsTopIndex++); + } + + int addConstant(long k) + { + ensure(9); + itsPool[itsTop++] = CONSTANT_Long; + itsTop = ClassFileWriter.putInt64(k, itsPool, itsTop); + int index = itsTopIndex; + itsTopIndex += 2; + return index; + } + + int addConstant(float k) + { + ensure(5); + itsPool[itsTop++] = CONSTANT_Float; + int bits = Float.floatToIntBits(k); + itsTop = ClassFileWriter.putInt32(bits, itsPool, itsTop); + return itsTopIndex++; + } + + int addConstant(double k) + { + ensure(9); + itsPool[itsTop++] = CONSTANT_Double; + long bits = Double.doubleToLongBits(k); + itsTop = ClassFileWriter.putInt64(bits, itsPool, itsTop); + int index = itsTopIndex; + itsTopIndex += 2; + return index; + } + + int addConstant(String k) + { + int utf8Index = 0xFFFF & addUtf8(k); + int theIndex = itsStringConstHash.getInt(utf8Index, -1); + if (theIndex == -1) { + theIndex = itsTopIndex++; + ensure(3); + itsPool[itsTop++] = CONSTANT_String; + itsTop = ClassFileWriter.putInt16(utf8Index, itsPool, itsTop); + itsStringConstHash.put(utf8Index, theIndex); + } + return theIndex; + } + + boolean isUnderUtfEncodingLimit(String s) + { + int strLen = s.length(); + if (strLen * 3 <= MAX_UTF_ENCODING_SIZE) { + return true; + } else if (strLen > MAX_UTF_ENCODING_SIZE) { + return false; + } + return strLen == getUtfEncodingLimit(s, 0, strLen); + } + + /** + * Get maximum i such that <tt>start <= i <= end</tt> and + * <tt>s.substring(start, i)</tt> fits JVM UTF string encoding limit. + */ + int getUtfEncodingLimit(String s, int start, int end) + { + if ((end - start) * 3 <= MAX_UTF_ENCODING_SIZE) { + return end; + } + int limit = MAX_UTF_ENCODING_SIZE; + for (int i = start; i != end; i++) { + int c = s.charAt(i); + if (0 != c && c <= 0x7F) { + --limit; + } else if (c < 0x7FF) { + limit -= 2; + } else { + limit -= 3; + } + if (limit < 0) { + return i; + } + } + return end; + } + + short addUtf8(String k) + { + int theIndex = itsUtf8Hash.get(k, -1); + if (theIndex == -1) { + int strLen = k.length(); + boolean tooBigString; + if (strLen > MAX_UTF_ENCODING_SIZE) { + tooBigString = true; + } else { + tooBigString = false; + // Ask for worst case scenario buffer when each char takes 3 + // bytes + ensure(1 + 2 + strLen * 3); + int top = itsTop; + + itsPool[top++] = CONSTANT_Utf8; + top += 2; // skip length + + char[] chars = cfw.getCharBuffer(strLen); + k.getChars(0, strLen, chars, 0); + + for (int i = 0; i != strLen; i++) { + int c = chars[i]; + if (c != 0 && c <= 0x7F) { + itsPool[top++] = (byte)c; + } else if (c > 0x7FF) { + itsPool[top++] = (byte)(0xE0 | (c >> 12)); + itsPool[top++] = (byte)(0x80 | ((c >> 6) & 0x3F)); + itsPool[top++] = (byte)(0x80 | (c & 0x3F)); + } else { + itsPool[top++] = (byte)(0xC0 | (c >> 6)); + itsPool[top++] = (byte)(0x80 | (c & 0x3F)); + } + } + + int utfLen = top - (itsTop + 1 + 2); + if (utfLen > MAX_UTF_ENCODING_SIZE) { + tooBigString = true; + } else { + // Write back length + itsPool[itsTop + 1] = (byte)(utfLen >>> 8); + itsPool[itsTop + 2] = (byte)utfLen; + + itsTop = top; + theIndex = itsTopIndex++; + itsUtf8Hash.put(k, theIndex); + } + } + if (tooBigString) { + throw new IllegalArgumentException("Too big string"); + } + } + return (short)theIndex; + } + + private short addNameAndType(String name, String type) + { + short nameIndex = addUtf8(name); + short typeIndex = addUtf8(type); + ensure(5); + itsPool[itsTop++] = CONSTANT_NameAndType; + itsTop = ClassFileWriter.putInt16(nameIndex, itsPool, itsTop); + itsTop = ClassFileWriter.putInt16(typeIndex, itsPool, itsTop); + return (short)(itsTopIndex++); + } + + short addClass(String className) + { + int theIndex = itsClassHash.get(className, -1); + if (theIndex == -1) { + String slashed = className; + if (className.indexOf('.') > 0) { + slashed = ClassFileWriter.getSlashedForm(className); + theIndex = itsClassHash.get(slashed, -1); + if (theIndex != -1) { + itsClassHash.put(className, theIndex); + } + } + if (theIndex == -1) { + int utf8Index = addUtf8(slashed); + ensure(3); + itsPool[itsTop++] = CONSTANT_Class; + itsTop = ClassFileWriter.putInt16(utf8Index, itsPool, itsTop); + theIndex = itsTopIndex++; + itsClassHash.put(slashed, theIndex); + if (className != slashed) { + itsClassHash.put(className, theIndex); + } + } + } + return (short)theIndex; + } + + short addFieldRef(String className, String fieldName, String fieldType) + { + FieldOrMethodRef ref = new FieldOrMethodRef(className, fieldName, + fieldType); + + int theIndex = itsFieldRefHash.get(ref, -1); + if (theIndex == -1) { + short ntIndex = addNameAndType(fieldName, fieldType); + short classIndex = addClass(className); + ensure(5); + itsPool[itsTop++] = CONSTANT_Fieldref; + itsTop = ClassFileWriter.putInt16(classIndex, itsPool, itsTop); + itsTop = ClassFileWriter.putInt16(ntIndex, itsPool, itsTop); + theIndex = itsTopIndex++; + itsFieldRefHash.put(ref, theIndex); + } + return (short)theIndex; + } + + short addMethodRef(String className, String methodName, + String methodType) + { + FieldOrMethodRef ref = new FieldOrMethodRef(className, methodName, + methodType); + + int theIndex = itsMethodRefHash.get(ref, -1); + if (theIndex == -1) { + short ntIndex = addNameAndType(methodName, methodType); + short classIndex = addClass(className); + ensure(5); + itsPool[itsTop++] = CONSTANT_Methodref; + itsTop = ClassFileWriter.putInt16(classIndex, itsPool, itsTop); + itsTop = ClassFileWriter.putInt16(ntIndex, itsPool, itsTop); + theIndex = itsTopIndex++; + itsMethodRefHash.put(ref, theIndex); + } + return (short)theIndex; + } + + short addInterfaceMethodRef(String className, + String methodName, String methodType) + { + short ntIndex = addNameAndType(methodName, methodType); + short classIndex = addClass(className); + ensure(5); + itsPool[itsTop++] = CONSTANT_InterfaceMethodref; + itsTop = ClassFileWriter.putInt16(classIndex, itsPool, itsTop); + itsTop = ClassFileWriter.putInt16(ntIndex, itsPool, itsTop); + return (short)(itsTopIndex++); + } + + void ensure(int howMuch) + { + if (itsTop + howMuch > itsPool.length) { + int newCapacity = itsPool.length * 2; + if (itsTop + howMuch > newCapacity) { + newCapacity = itsTop + howMuch; + } + byte[] tmp = new byte[newCapacity]; + System.arraycopy(itsPool, 0, tmp, 0, itsTop); + itsPool = tmp; + } + } + + private ClassFileWriter cfw; + + private static final int MAX_UTF_ENCODING_SIZE = 65535; + + private UintMap itsStringConstHash = new UintMap(); + private ObjToIntMap itsUtf8Hash = new ObjToIntMap(); + private ObjToIntMap itsFieldRefHash = new ObjToIntMap(); + private ObjToIntMap itsMethodRefHash = new ObjToIntMap(); + private ObjToIntMap itsClassHash = new ObjToIntMap(); + + private int itsTop; + private int itsTopIndex; + private byte itsPool[]; +} + +final class FieldOrMethodRef +{ + FieldOrMethodRef(String className, String name, String type) + { + this.className = className; + this.name = name; + this.type = type; + } + + public boolean equals(Object obj) + { + if (!(obj instanceof FieldOrMethodRef)) { return false; } + FieldOrMethodRef x = (FieldOrMethodRef)obj; + return className.equals(x.className) + && name.equals(x.name) + && type.equals(x.type); + } + + public int hashCode() + { + if (hashCode == -1) { + int h1 = className.hashCode(); + int h2 = name.hashCode(); + int h3 = type.hashCode(); + hashCode = h1 ^ h2 ^ h3; + } + return hashCode; + } + + private String className; + private String name; + private String type; + private int hashCode = -1; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Arguments.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Arguments.java new file mode 100644 index 0000000..954b078 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Arguments.java @@ -0,0 +1,311 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the "arguments" object. + * + * See ECMA 10.1.8 + * + * @see org.mozilla.javascript.NativeCall + * @author Norris Boyd + */ +final class Arguments extends IdScriptableObject +{ + static final long serialVersionUID = 4275508002492040609L; + + public Arguments(NativeCall activation) + { + this.activation = activation; + + Scriptable parent = activation.getParentScope(); + setParentScope(parent); + setPrototype(ScriptableObject.getObjectPrototype(parent)); + + args = activation.originalArgs; + lengthObj = new Integer(args.length); + + NativeFunction f = activation.function; + calleeObj = f; + + int version = f.getLanguageVersion(); + if (version <= Context.VERSION_1_3 + && version != Context.VERSION_DEFAULT) + { + callerObj = null; + } else { + callerObj = NOT_FOUND; + } + } + + public String getClassName() + { + return "Object"; + } + + public boolean has(int index, Scriptable start) + { + if (0 <= index && index < args.length) { + if (args[index] != NOT_FOUND) { + return true; + } + } + return super.has(index, start); + } + + public Object get(int index, Scriptable start) + { + if (0 <= index && index < args.length) { + Object value = args[index]; + if (value != NOT_FOUND) { + if (sharedWithActivation(index)) { + NativeFunction f = activation.function; + String argName = f.getParamOrVarName(index); + value = activation.get(argName, activation); + if (value == NOT_FOUND) Kit.codeBug(); + } + return value; + } + } + return super.get(index, start); + } + + private boolean sharedWithActivation(int index) + { + NativeFunction f = activation.function; + int definedCount = f.getParamCount(); + if (index < definedCount) { + // Check if argument is not hidden by later argument with the same + // name as hidden arguments are not shared with activation + if (index < definedCount - 1) { + String argName = f.getParamOrVarName(index); + for (int i = index + 1; i < definedCount; i++) { + if (argName.equals(f.getParamOrVarName(i))) { + return false; + } + } + } + return true; + } + return false; + } + + public void put(int index, Scriptable start, Object value) + { + if (0 <= index && index < args.length) { + if (args[index] != NOT_FOUND) { + if (sharedWithActivation(index)) { + String argName; + argName = activation.function.getParamOrVarName(index); + activation.put(argName, activation, value); + return; + } + synchronized (this) { + if (args[index] != NOT_FOUND) { + if (args == activation.originalArgs) { + args = args.clone(); + } + args[index] = value; + return; + } + } + } + } + super.put(index, start, value); + } + + public void delete(int index) + { + if (0 <= index && index < args.length) { + synchronized (this) { + if (args[index] != NOT_FOUND) { + if (args == activation.originalArgs) { + args = args.clone(); + } + args[index] = NOT_FOUND; + return; + } + } + } + super.delete(index); + } + +// #string_id_map# + + private static final int + Id_callee = 1, + Id_length = 2, + Id_caller = 3, + + MAX_INSTANCE_ID = 3; + + protected int getMaxInstanceId() + { + return MAX_INSTANCE_ID; + } + + protected int findInstanceIdInfo(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:04 EDT + L0: { id = 0; String X = null; int c; + if (s.length()==6) { + c=s.charAt(5); + if (c=='e') { X="callee";id=Id_callee; } + else if (c=='h') { X="length";id=Id_length; } + else if (c=='r') { X="caller";id=Id_caller; } + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + + if (id == 0) return super.findInstanceIdInfo(s); + + int attr; + switch (id) { + case Id_callee: + case Id_caller: + case Id_length: + attr = DONTENUM; + break; + default: throw new IllegalStateException(); + } + return instanceIdInfo(attr, id); + } + +// #/string_id_map# + + protected String getInstanceIdName(int id) + { + switch (id) { + case Id_callee: return "callee"; + case Id_length: return "length"; + case Id_caller: return "caller"; + } + return null; + } + + protected Object getInstanceIdValue(int id) + { + switch (id) { + case Id_callee: return calleeObj; + case Id_length: return lengthObj; + case Id_caller: { + Object value = callerObj; + if (value == UniqueTag.NULL_VALUE) { value = null; } + else if (value == null) { + NativeCall caller = activation.parentActivationCall; + if (caller != null) { + value = caller.get("arguments", caller); + } + } + return value; + } + } + return super.getInstanceIdValue(id); + } + + protected void setInstanceIdValue(int id, Object value) + { + switch (id) { + case Id_callee: calleeObj = value; return; + case Id_length: lengthObj = value; return; + case Id_caller: + callerObj = (value != null) ? value : UniqueTag.NULL_VALUE; + return; + } + super.setInstanceIdValue(id, value); + } + + Object[] getIds(boolean getAll) + { + Object[] ids = super.getIds(getAll); + if (getAll && args.length != 0) { + boolean[] present = null; + int extraCount = args.length; + for (int i = 0; i != ids.length; ++i) { + Object id = ids[i]; + if (id instanceof Integer) { + int index = ((Integer)id).intValue(); + if (0 <= index && index < args.length) { + if (present == null) { + present = new boolean[args.length]; + } + if (!present[index]) { + present[index] = true; + extraCount--; + } + } + } + } + if (extraCount != 0) { + Object[] tmp = new Object[extraCount + ids.length]; + System.arraycopy(ids, 0, tmp, extraCount, ids.length); + ids = tmp; + int offset = 0; + for (int i = 0; i != args.length; ++i) { + if (present == null || !present[i]) { + ids[offset] = new Integer(i); + ++offset; + } + } + if (offset != extraCount) Kit.codeBug(); + } + } + return ids; + } + +// Fields to hold caller, callee and length properties, +// where NOT_FOUND value tags deleted properties. +// In addition if callerObj == NULL_VALUE, it tags null for scripts, as +// initial callerObj == null means access to caller arguments available +// only in JS <= 1.3 scripts + private Object callerObj; + private Object calleeObj; + private Object lengthObj; + + private NativeCall activation; + +// Initially args holds activation.getOriginalArgs(), but any modification +// of its elements triggers creation of a copy. If its element holds NOT_FOUND, +// it indicates deleted index, in which case super class is queried. + private Object[] args; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/BaseFunction.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/BaseFunction.java new file mode 100644 index 0000000..d7d8992 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/BaseFunction.java @@ -0,0 +1,553 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Roger Lawrence + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * The base class for Function objects + * See ECMA 15.3. + * @author Norris Boyd + */ +public class BaseFunction extends IdScriptableObject implements Function +{ + + static final long serialVersionUID = 5311394446546053859L; + + private static final Object FUNCTION_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + BaseFunction obj = new BaseFunction(); + // Function.prototype attributes: see ECMA 15.3.3.1 + obj.prototypePropertyAttributes = DONTENUM | READONLY | PERMANENT; + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + public BaseFunction() + { + } + + public BaseFunction(Scriptable scope, Scriptable prototype) + { + super(scope, prototype); + } + + public String getClassName() { + return "Function"; + } + + /** + * Implements the instanceof operator for JavaScript Function objects. + * <p> + * <code> + * foo = new Foo();<br> + * foo instanceof Foo; // true<br> + * </code> + * + * @param instance The value that appeared on the LHS of the instanceof + * operator + * @return true if the "prototype" property of "this" appears in + * value's prototype chain + * + */ + public boolean hasInstance(Scriptable instance) + { + Object protoProp = ScriptableObject.getProperty(this, "prototype"); + if (protoProp instanceof Scriptable) { + return ScriptRuntime.jsDelegatesTo(instance, (Scriptable)protoProp); + } + throw ScriptRuntime.typeError1("msg.instanceof.bad.prototype", + getFunctionName()); + } + +// #string_id_map# + + private static final int + Id_length = 1, + Id_arity = 2, + Id_name = 3, + Id_prototype = 4, + Id_arguments = 5, + + MAX_INSTANCE_ID = 5; + + protected int getMaxInstanceId() + { + return MAX_INSTANCE_ID; + } + + protected int findInstanceIdInfo(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:15 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 4: X="name";id=Id_name; break L; + case 5: X="arity";id=Id_arity; break L; + case 6: X="length";id=Id_length; break L; + case 9: c=s.charAt(0); + if (c=='a') { X="arguments";id=Id_arguments; } + else if (c=='p') { X="prototype";id=Id_prototype; } + break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# +// #/string_id_map# + + if (id == 0) return super.findInstanceIdInfo(s); + + int attr; + switch (id) { + case Id_length: + case Id_arity: + case Id_name: + attr = DONTENUM | READONLY | PERMANENT; + break; + case Id_prototype: + attr = prototypePropertyAttributes; + break; + case Id_arguments: + attr = DONTENUM | PERMANENT; + break; + default: throw new IllegalStateException(); + } + return instanceIdInfo(attr, id); + } + + protected String getInstanceIdName(int id) + { + switch (id) { + case Id_length: return "length"; + case Id_arity: return "arity"; + case Id_name: return "name"; + case Id_prototype: return "prototype"; + case Id_arguments: return "arguments"; + } + return super.getInstanceIdName(id); + } + + protected Object getInstanceIdValue(int id) + { + switch (id) { + case Id_length: return ScriptRuntime.wrapInt(getLength()); + case Id_arity: return ScriptRuntime.wrapInt(getArity()); + case Id_name: return getFunctionName(); + case Id_prototype: return getPrototypeProperty(); + case Id_arguments: return getArguments(); + } + return super.getInstanceIdValue(id); + } + + protected void setInstanceIdValue(int id, Object value) + { + if (id == Id_prototype) { + if ((prototypePropertyAttributes & READONLY) == 0) { + prototypeProperty = (value != null) + ? value : UniqueTag.NULL_VALUE; + } + return; + } else if (id == Id_arguments) { + if (value == NOT_FOUND) { + // This should not be called since "arguments" is PERMANENT + Kit.codeBug(); + } + defaultPut("arguments", value); + } + super.setInstanceIdValue(id, value); + } + + protected void fillConstructorProperties(IdFunctionObject ctor) + { + // Fix up bootstrapping problem: getPrototype of the IdFunctionObject + // can not return Function.prototype because Function object is not + // yet defined. + ctor.setPrototype(this); + super.fillConstructorProperties(ctor); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=1; s="toString"; break; + case Id_toSource: arity=1; s="toSource"; break; + case Id_apply: arity=2; s="apply"; break; + case Id_call: arity=1; s="call"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(FUNCTION_TAG, id, s, arity); + } + + static boolean isApply(IdFunctionObject f) { + return f.hasTag(FUNCTION_TAG) && f.methodId() == Id_apply; + } + + static boolean isApplyOrCall(IdFunctionObject f) { + if(f.hasTag(FUNCTION_TAG)) { + switch(f.methodId()) { + case Id_apply: + case Id_call: + return true; + } + } + return false; + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(FUNCTION_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_constructor: + return jsConstructor(cx, scope, args); + + case Id_toString: { + BaseFunction realf = realFunction(thisObj, f); + int indent = ScriptRuntime.toInt32(args, 0); + return realf.decompile(indent, 0); + } + + case Id_toSource: { + BaseFunction realf = realFunction(thisObj, f); + int indent = 0; + int flags = Decompiler.TO_SOURCE_FLAG; + if (args.length != 0) { + indent = ScriptRuntime.toInt32(args[0]); + if (indent >= 0) { + flags = 0; + } else { + indent = 0; + } + } + return realf.decompile(indent, flags); + } + + case Id_apply: + case Id_call: + return ScriptRuntime.applyOrCall(id == Id_apply, + cx, scope, thisObj, args); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + + private BaseFunction realFunction(Scriptable thisObj, IdFunctionObject f) + { + Object x = thisObj.getDefaultValue(ScriptRuntime.FunctionClass); + if (x instanceof BaseFunction) { + return (BaseFunction)x; + } + throw ScriptRuntime.typeError1("msg.incompat.call", + f.getFunctionName()); + } + + /** + * Make value as DontEnum, DontDelete, ReadOnly + * prototype property of this Function object + */ + public void setImmunePrototypeProperty(Object value) + { + if ((prototypePropertyAttributes & READONLY) != 0) { + throw new IllegalStateException(); + } + prototypeProperty = (value != null) ? value : UniqueTag.NULL_VALUE; + prototypePropertyAttributes = DONTENUM | PERMANENT | READONLY; + } + + protected Scriptable getClassPrototype() + { + Object protoVal = getPrototypeProperty(); + if (protoVal instanceof Scriptable) { + return (Scriptable) protoVal; + } + return getClassPrototype(this, "Object"); + } + + /** + * Should be overridden. + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return Undefined.instance; + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + Scriptable result = createObject(cx, scope); + if (result != null) { + Object val = call(cx, scope, result, args); + if (val instanceof Scriptable) { + result = (Scriptable)val; + } + } else { + Object val = call(cx, scope, null, args); + if (!(val instanceof Scriptable)) { + // It is program error not to return Scriptable from + // the call method if createObject returns null. + throw new IllegalStateException( + "Bad implementaion of call as constructor, name=" + +getFunctionName()+" in "+getClass().getName()); + } + result = (Scriptable)val; + if (result.getPrototype() == null) { + result.setPrototype(getClassPrototype()); + } + if (result.getParentScope() == null) { + Scriptable parent = getParentScope(); + if (result != parent) { + result.setParentScope(parent); + } + } + } + return result; + } + + /** + * Creates new script object. + * The default implementation of {@link #construct} uses the method to + * to get the value for <tt>thisObj</tt> argument when invoking + * {@link #call}. + * The methos is allowed to return <tt>null</tt> to indicate that + * {@link #call} will create a new object itself. In this case + * {@link #construct} will set scope and prototype on the result + * {@link #call} unless they are already set. + */ + public Scriptable createObject(Context cx, Scriptable scope) + { + Scriptable newInstance = new NativeObject(); + newInstance.setPrototype(getClassPrototype()); + newInstance.setParentScope(getParentScope()); + return newInstance; + } + + /** + * Decompile the source information associated with this js + * function/script back into a string. + * + * @param indent How much to indent the decompiled result. + * + * @param flags Flags specifying format of decompilation output. + */ + String decompile(int indent, int flags) + { + StringBuffer sb = new StringBuffer(); + boolean justbody = (0 != (flags & Decompiler.ONLY_BODY_FLAG)); + if (!justbody) { + sb.append("function "); + sb.append(getFunctionName()); + sb.append("() {\n\t"); + } + sb.append("[native code, arity="); + sb.append(getArity()); + sb.append("]\n"); + if (!justbody) { + sb.append("}\n"); + } + return sb.toString(); + } + + public int getArity() { return 0; } + + public int getLength() { return 0; } + + public String getFunctionName() + { + return ""; + } + + final Object getPrototypeProperty() { + Object result = prototypeProperty; + if (result == null) { + synchronized (this) { + result = prototypeProperty; + if (result == null) { + setupDefaultPrototype(); + result = prototypeProperty; + } + } + } + else if (result == UniqueTag.NULL_VALUE) { result = null; } + return result; + } + + private void setupDefaultPrototype() + { + NativeObject obj = new NativeObject(); + final int attr = ScriptableObject.DONTENUM; + obj.defineProperty("constructor", this, attr); + // put the prototype property into the object now, then in the + // wacky case of a user defining a function Object(), we don't + // get an infinite loop trying to find the prototype. + prototypeProperty = obj; + Scriptable proto = getObjectPrototype(this); + if (proto != obj) { + // not the one we just made, it must remain grounded + obj.setPrototype(proto); + } + } + + private Object getArguments() + { + // <Function name>.arguments is deprecated, so we use a slow + // way of getting it that doesn't add to the invocation cost. + // TODO: add warning, error based on version + Object value = defaultGet("arguments"); + if (value != NOT_FOUND) { + // Should after changing <Function name>.arguments its + // activation still be available during Function call? + // This code assumes it should not: + // defaultGet("arguments") != NOT_FOUND + // means assigned arguments + return value; + } + Context cx = Context.getContext(); + NativeCall activation = ScriptRuntime.findFunctionActivation(cx, this); + return (activation == null) + ? null + : activation.get("arguments", activation); + } + + private static Object jsConstructor(Context cx, Scriptable scope, + Object[] args) + { + int arglen = args.length; + StringBuffer sourceBuf = new StringBuffer(); + + sourceBuf.append("function "); + /* version != 1.2 Function constructor behavior - + * print 'anonymous' as the function name if the + * version (under which the function was compiled) is + * less than 1.2... or if it's greater than 1.2, because + * we need to be closer to ECMA. + */ + if (cx.getLanguageVersion() != Context.VERSION_1_2) { + sourceBuf.append("anonymous"); + } + sourceBuf.append('('); + + // Append arguments as coma separated strings + for (int i = 0; i < arglen - 1; i++) { + if (i > 0) { + sourceBuf.append(','); + } + sourceBuf.append(ScriptRuntime.toString(args[i])); + } + sourceBuf.append(") {"); + if (arglen != 0) { + // append function body + String funBody = ScriptRuntime.toString(args[arglen - 1]); + sourceBuf.append(funBody); + } + sourceBuf.append('}'); + String source = sourceBuf.toString(); + + int[] linep = new int[1]; + String filename = Context.getSourcePositionFromStack(linep); + if (filename == null) { + filename = "<eval'ed string>"; + linep[0] = 1; + } + + String sourceURI = ScriptRuntime. + makeUrlForGeneratedScript(false, filename, linep[0]); + + Scriptable global = ScriptableObject.getTopLevelScope(scope); + + ErrorReporter reporter; + reporter = DefaultErrorReporter.forEval(cx.getErrorReporter()); + + Evaluator evaluator = Context.createInterpreter(); + if (evaluator == null) { + throw new JavaScriptException("Interpreter not present", + filename, linep[0]); + } + + // Compile with explicit interpreter instance to force interpreter + // mode. + return cx.compileFunction(global, source, evaluator, reporter, + sourceURI, 1, null); + } + + protected int findPrototypeId(String s) + { + int id; +// #string_id_map# +// #generated# Last update: 2007-05-09 08:15:15 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 4: X="call";id=Id_call; break L; + case 5: X="apply";id=Id_apply; break L; + case 8: c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + break L; + case 11: X="constructor";id=Id_constructor; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_toSource = 3, + Id_apply = 4, + Id_call = 5, + + MAX_PROTOTYPE_ID = 5; + +// #/string_id_map# + + private Object prototypeProperty; + // For function object instances, attribute is PERMANENT; see ECMA 15.3.5.2 + private int prototypePropertyAttributes = PERMANENT; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Callable.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Callable.java new file mode 100644 index 0000000..03e0fce --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Callable.java @@ -0,0 +1,59 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * Generic notion of callable object that can execute some script-related code + * upon request with specified values for script scope and this objects. + */ +public interface Callable +{ + /** + * Perform the call. + * + * @param cx the current Context for this thread + * @param scope the scope to use to resolve properties. + * @param thisObj the JavaScript <code>this</code> object + * @param args the array of arguments + * @return the result of the call + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args); +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ClassCache.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ClassCache.java new file mode 100644 index 0000000..9047278 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ClassCache.java @@ -0,0 +1,220 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.Map; +import java.util.HashMap; + +/** + * Cache of generated classes and data structures to access Java runtime + * from JavaScript. + * + * @author Igor Bukanov + * + * @since Rhino 1.5 Release 5 + */ +public class ClassCache +{ + private static final Object AKEY = new Object(); + private volatile boolean cachingIsEnabled = true; + private HashMap<Class<?>,JavaMembers> classTable + = new HashMap<Class<?>,JavaMembers>(); + private HashMap<Class<?>,JavaMembers> javaAdapterGeneratedClasses + = new HashMap<Class<?>,JavaMembers>(); + private HashMap<JavaAdapter.JavaAdapterSignature,Class<?>> classAdapterCache + = new HashMap<JavaAdapter.JavaAdapterSignature,Class<?>>(); + private HashMap<Class<?>,Object> interfaceAdapterCache; + private int generatedClassSerial; + + /** + * Search for ClassCache object in the given scope. + * The method first calls + * {@link ScriptableObject#getTopLevelScope(Scriptable scope)} + * to get the top most scope and then tries to locate associated + * ClassCache object in the prototype chain of the top scope. + * + * @param scope scope to search for ClassCache object. + * @return previously associated ClassCache object or a new instance of + * ClassCache if no ClassCache object was found. + * + * @see #associate(ScriptableObject topScope) + */ + public static ClassCache get(Scriptable scope) + { + ClassCache cache = (ClassCache) + ScriptableObject.getTopScopeValue(scope, AKEY); + if (cache == null) { + throw new RuntimeException("Can't find top level scope for " + + "ClassCache.get"); + } + return cache; + } + + /** + * Associate ClassCache object with the given top-level scope. + * The ClassCache object can only be associated with the given scope once. + * + * @param topScope scope to associate this ClassCache object with. + * @return true if no previous ClassCache objects were embedded into + * the scope and this ClassCache were successfully associated + * or false otherwise. + * + * @see #get(Scriptable scope) + */ + public boolean associate(ScriptableObject topScope) + { + if (topScope.getParentScope() != null) { + // Can only associate cache with top level scope + throw new IllegalArgumentException(); + } + if (this == topScope.associateValue(AKEY, this)) { + return true; + } + return false; + } + + /** + * Empty caches of generated Java classes and Java reflection information. + */ + public synchronized void clearCaches() + { + classTable.clear(); + javaAdapterGeneratedClasses.clear(); + classAdapterCache.clear(); + interfaceAdapterCache = null; + } + + /** + * Check if generated Java classes and Java reflection information + * is cached. + */ + public final boolean isCachingEnabled() + { + return cachingIsEnabled; + } + + /** + * Set whether to cache some values. + * <p> + * By default, the engine will cache the results of + * <tt>Class.getMethods()</tt> and similar calls. + * This can speed execution dramatically, but increases the memory + * footprint. Also, with caching enabled, references may be held to + * objects past the lifetime of any real usage. + * <p> + * If caching is enabled and this method is called with a + * <code>false</code> argument, the caches will be emptied. + * <p> + * Caching is enabled by default. + * + * @param enabled if true, caching is enabled + * + * @see #clearCaches() + */ + public synchronized void setCachingEnabled(boolean enabled) + { + if (enabled == cachingIsEnabled) + return; + if (!enabled) + clearCaches(); + cachingIsEnabled = enabled; + } + + /** + * @return a map from classes to associated JavaMembers objects + */ + Map<Class<?>,JavaMembers> getClassCacheMap() { + return classTable; + } + + Map<JavaAdapter.JavaAdapterSignature,Class<?>> getInterfaceAdapterCacheMap() + { + return classAdapterCache; + } + + /** + * @deprecated + * The method always returns false. + * @see #setInvokerOptimizationEnabled(boolean enabled) + */ + public boolean isInvokerOptimizationEnabled() + { + return false; + } + + /** + * @deprecated + * The method does nothing. + * Invoker optimization is no longer used by Rhino. + * On modern JDK like 1.4 or 1.5 the disadvantages of the optimization + * like increased memory usage or longer initialization time overweight + * small speed increase that can be gained using generated proxy class + * to replace reflection. + */ + public synchronized void setInvokerOptimizationEnabled(boolean enabled) + { + } + + /** + * Internal engine method to return serial number for generated classes + * to ensure name uniqueness. + */ + public final synchronized int newClassSerialNumber() + { + return ++generatedClassSerial; + } + + Object getInterfaceAdapter(Class<?> cl) + { + return interfaceAdapterCache == null + ? null + : interfaceAdapterCache.get(cl); + } + + synchronized void cacheInterfaceAdapter(Class<?> cl, Object iadapter) + { + if (cachingIsEnabled) { + if (interfaceAdapterCache == null) { + interfaceAdapterCache = new HashMap<Class<?>,Object>(); + } + interfaceAdapterCache.put(cl, iadapter); + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ClassShutter.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ClassShutter.java new file mode 100644 index 0000000..d5f4cd6 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ClassShutter.java @@ -0,0 +1,89 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** +Embeddings that wish to filter Java classes that are visible to scripts +through the LiveConnect, should implement this interface. + +@see Context#setClassShutter(ClassShutter) +@since 1.5 Release 4 +@author Norris Boyd +*/ + + public interface ClassShutter { + + /** + * Return true iff the Java class with the given name should be exposed + * to scripts. + * <p> + * An embedding may filter which Java classes are exposed through + * LiveConnect to JavaScript scripts. + * <p> + * Due to the fact that there is no package reflection in Java, + * this method will also be called with package names. There + * is no way for Rhino to tell if "Packages.a.b" is a package name + * or a class that doesn't exist. What Rhino does is attempt + * to load each segment of "Packages.a.b.c": It first attempts to + * load class "a", then attempts to load class "a.b", then + * finally attempts to load class "a.b.c". On a Rhino installation + * without any ClassShutter set, and without any of the + * above classes, the expression "Packages.a.b.c" will result in + * a [JavaPackage a.b.c] and not an error. + * <p> + * With ClassShutter supplied, Rhino will first call + * visibleToScripts before attempting to look up the class name. If + * visibleToScripts returns false, the class name lookup is not + * performed and subsequent Rhino execution assumes the class is + * not present. So for "java.lang.System.out.println" the lookup + * of "java.lang.System" is skipped and thus Rhino assumes that + * "java.lang.System" doesn't exist. So then for "java.lang.System.out", + * Rhino attempts to load the class "java.lang.System.out" because + * it assumes that "java.lang.System" is a package name. + * <p> + * @param fullClassName the full name of the class (including the package + * name, with '.' as a delimiter). For example the + * standard string class is "java.lang.String" + * @return whether or not to reveal this class to scripts + */ + public boolean visibleToScripts(String fullClassName); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/CompilerEnvirons.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/CompilerEnvirons.java new file mode 100644 index 0000000..645d098 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/CompilerEnvirons.java @@ -0,0 +1,233 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * Bob Jervis + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.Hashtable; + +public class CompilerEnvirons +{ + public CompilerEnvirons() + { + errorReporter = DefaultErrorReporter.instance; + languageVersion = Context.VERSION_DEFAULT; + generateDebugInfo = true; + useDynamicScope = false; + reservedKeywordAsIdentifier = false; + allowMemberExprAsFunctionName = false; + xmlAvailable = true; + optimizationLevel = 0; + generatingSource = true; + strictMode = false; + warningAsError = false; + generateObserverCount = false; + } + + public void initFromContext(Context cx) + { + setErrorReporter(cx.getErrorReporter()); + this.languageVersion = cx.getLanguageVersion(); + useDynamicScope = cx.compileFunctionsWithDynamicScopeFlag; + generateDebugInfo = (!cx.isGeneratingDebugChanged() + || cx.isGeneratingDebug()); + reservedKeywordAsIdentifier + = cx.hasFeature(Context.FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER); + allowMemberExprAsFunctionName + = cx.hasFeature(Context.FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME); + strictMode + = cx.hasFeature(Context.FEATURE_STRICT_MODE); + warningAsError = cx.hasFeature(Context.FEATURE_WARNING_AS_ERROR); + xmlAvailable + = cx.hasFeature(Context.FEATURE_E4X); + + optimizationLevel = cx.getOptimizationLevel(); + + generatingSource = cx.isGeneratingSource(); + activationNames = cx.activationNames; + + // Observer code generation in compiled code : + generateObserverCount = cx.generateObserverCount; + } + + public final ErrorReporter getErrorReporter() + { + return errorReporter; + } + + public void setErrorReporter(ErrorReporter errorReporter) + { + if (errorReporter == null) throw new IllegalArgumentException(); + this.errorReporter = errorReporter; + } + + public final int getLanguageVersion() + { + return languageVersion; + } + + public void setLanguageVersion(int languageVersion) + { + Context.checkLanguageVersion(languageVersion); + this.languageVersion = languageVersion; + } + + public final boolean isGenerateDebugInfo() + { + return generateDebugInfo; + } + + public void setGenerateDebugInfo(boolean flag) + { + this.generateDebugInfo = flag; + } + + public final boolean isUseDynamicScope() + { + return useDynamicScope; + } + + public final boolean isReservedKeywordAsIdentifier() + { + return reservedKeywordAsIdentifier; + } + + public void setReservedKeywordAsIdentifier(boolean flag) + { + reservedKeywordAsIdentifier = flag; + } + + public final boolean isAllowMemberExprAsFunctionName() + { + return allowMemberExprAsFunctionName; + } + + public void setAllowMemberExprAsFunctionName(boolean flag) + { + allowMemberExprAsFunctionName = flag; + } + + public final boolean isXmlAvailable() + { + return xmlAvailable; + } + + public void setXmlAvailable(boolean flag) + { + xmlAvailable = flag; + } + + public final int getOptimizationLevel() + { + return optimizationLevel; + } + + public void setOptimizationLevel(int level) + { + Context.checkOptimizationLevel(level); + this.optimizationLevel = level; + } + + public final boolean isGeneratingSource() + { + return generatingSource; + } + + public final boolean isStrictMode() + { + return strictMode; + } + + public final boolean reportWarningAsError() + { + return warningAsError; + } + + /** + * Specify whether or not source information should be generated. + * <p> + * Without source information, evaluating the "toString" method + * on JavaScript functions produces only "[native code]" for + * the body of the function. + * Note that code generated without source is not fully ECMA + * conformant. + */ + public void setGeneratingSource(boolean generatingSource) + { + this.generatingSource = generatingSource; + } + + /** + * @return true iff code will be generated with callbacks to enable + * instruction thresholds + */ + public boolean isGenerateObserverCount() { + return generateObserverCount; + } + + /** + * Turn on or off generation of code with callbacks to + * track the count of executed instructions. + * Currently only affects JVM byte code generation: this slows down the + * generated code, but code generated without the callbacks will not + * be counted toward instruction thresholds. Rhino's interpretive + * mode does instruction counting without inserting callbacks, so + * there is no requirement to compile code differently. + * @param generateObserverCount if true, generated code will contain + * calls to accumulate an estimate of the instructions executed. + */ + public void setGenerateObserverCount(boolean generateObserverCount) { + this.generateObserverCount = generateObserverCount; + } + + private ErrorReporter errorReporter; + + private int languageVersion; + private boolean generateDebugInfo; + private boolean useDynamicScope; + private boolean reservedKeywordAsIdentifier; + private boolean allowMemberExprAsFunctionName; + private boolean xmlAvailable; + private int optimizationLevel; + private boolean generatingSource; + private boolean strictMode; + private boolean warningAsError; + private boolean generateObserverCount; + Hashtable activationNames; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ConstProperties.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ConstProperties.java new file mode 100644 index 0000000..860db79 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ConstProperties.java @@ -0,0 +1,109 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Bob Jervis + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +public interface ConstProperties { + /** + * Sets a named const property in this object. + * <p> + * The property is specified by a string name + * as defined for <code>Scriptable.get</code>. + * <p> + * The possible values that may be passed in are as defined for + * <code>Scriptable.get</code>. A class that implements this method may choose + * to ignore calls to set certain properties, in which case those + * properties are effectively read-only.<p> + * For properties defined in a prototype chain, + * use <code>putProperty</code> in ScriptableObject. <p> + * Note that if a property <i>a</i> is defined in the prototype <i>p</i> + * of an object <i>o</i>, then evaluating <code>o.a = 23</code> will cause + * <code>set</code> to be called on the prototype <i>p</i> with + * <i>o</i> as the <i>start</i> parameter. + * To preserve JavaScript semantics, it is the Scriptable + * object's responsibility to modify <i>o</i>. <p> + * This design allows properties to be defined in prototypes and implemented + * in terms of getters and setters of Java values without consuming slots + * in each instance.<p> + * <p> + * The values that may be set are limited to the following: + * <UL> + * <LI>java.lang.Boolean objects</LI> + * <LI>java.lang.String objects</LI> + * <LI>java.lang.Number objects</LI> + * <LI>org.mozilla.javascript.Scriptable objects</LI> + * <LI>null</LI> + * <LI>The value returned by Context.getUndefinedValue()</LI> + * </UL><p> + * Arbitrary Java objects may be wrapped in a Scriptable by first calling + * <code>Context.toObject</code>. This allows the property of a JavaScript + * object to contain an arbitrary Java object as a value.<p> + * Note that <code>has</code> will be called by the runtime first before + * <code>set</code> is called to determine in which object the + * property is defined. + * Note that this method is not expected to traverse the prototype chain, + * which is different from the ECMA [[Put]] operation. + * @param name the name of the property + * @param start the object whose property is being set + * @param value value to set the property to + * @see org.mozilla.javascript.Scriptable#has(String, Scriptable) + * @see org.mozilla.javascript.Scriptable#get(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#putProperty(Scriptable, String, Object) + * @see org.mozilla.javascript.Context#toObject(Object, Scriptable) + */ + public void putConst(String name, Scriptable start, Object value); + + /** + * Reserves a definition spot for a const. This will set up a definition + * of the const property, but set its value to undefined. The semantics of + * the start parameter is the same as for putConst. + * @param name The name of the property. + * @param start The object whose property is being reserved. + */ + public void defineConst(String name, Scriptable start); + + /** + * Returns true if the named property is defined as a const on this object. + * @param name + * @return true if the named property is defined as a const, false + * otherwise. + */ + public boolean isConst(String name); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Context.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Context.java new file mode 100644 index 0000000..0833883 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Context.java @@ -0,0 +1,2526 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Bob Jervis + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; +import java.io.CharArrayWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.io.Reader; +import java.io.StringWriter; +import java.io.Writer; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Hashtable; +import java.util.Locale; + +import org.mozilla.javascript.debug.DebuggableScript; +import org.mozilla.javascript.debug.Debugger; +import org.mozilla.javascript.xml.XMLLib; + +/** + * This class represents the runtime context of an executing script. + * + * Before executing a script, an instance of Context must be created + * and associated with the thread that will be executing the script. + * The Context will be used to store information about the executing + * of the script such as the call stack. Contexts are associated with + * the current thread using the {@link #call(ContextAction)} + * or {@link #enter()} methods.<p> + * + * Different forms of script execution are supported. Scripts may be + * evaluated from the source directly, or first compiled and then later + * executed. Interactive execution is also supported.<p> + * + * Some aspects of script execution, such as type conversions and + * object creation, may be accessed directly through methods of + * Context. + * + * @see Scriptable + * @author Norris Boyd + * @author Brendan Eich + */ + +public class Context +{ + /** + * Language versions. + * + * All integral values are reserved for future version numbers. + */ + + /** + * The unknown version. + */ + public static final int VERSION_UNKNOWN = -1; + + /** + * The default version. + */ + public static final int VERSION_DEFAULT = 0; + + /** + * JavaScript 1.0 + */ + public static final int VERSION_1_0 = 100; + + /** + * JavaScript 1.1 + */ + public static final int VERSION_1_1 = 110; + + /** + * JavaScript 1.2 + */ + public static final int VERSION_1_2 = 120; + + /** + * JavaScript 1.3 + */ + public static final int VERSION_1_3 = 130; + + /** + * JavaScript 1.4 + */ + public static final int VERSION_1_4 = 140; + + /** + * JavaScript 1.5 + */ + public static final int VERSION_1_5 = 150; + + /** + * JavaScript 1.6 + */ + public static final int VERSION_1_6 = 160; + + /** + * JavaScript 1.7 + */ + public static final int VERSION_1_7 = 170; + + /** + * Controls behaviour of <tt>Date.prototype.getYear()</tt>. + * If <tt>hasFeature(FEATURE_NON_ECMA_GET_YEAR)</tt> returns true, + * Date.prototype.getYear subtructs 1900 only if 1900 <= date < 2000. + * The default behavior of {@link #hasFeature(int)} is always to subtruct + * 1900 as rquired by ECMAScript B.2.4. + */ + public static final int FEATURE_NON_ECMA_GET_YEAR = 1; + + /** + * Control if member expression as function name extension is available. + * If <tt>hasFeature(FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME)</tt> returns + * true, allow <tt>function memberExpression(args) { body }</tt> to be + * syntax sugar for <tt>memberExpression = function(args) { body }</tt>, + * when memberExpression is not a simple identifier. + * See ECMAScript-262, section 11.2 for definition of memberExpression. + * By default {@link #hasFeature(int)} returns false. + */ + public static final int FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME = 2; + + /** + * Control if reserved keywords are treated as identifiers. + * If <tt>hasFeature(RESERVED_KEYWORD_AS_IDENTIFIER)</tt> returns true, + * treat future reserved keyword (see Ecma-262, section 7.5.3) as ordinary + * identifiers but warn about this usage. + * + * By default {@link #hasFeature(int)} returns false. + */ + public static final int FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER = 3; + + /** + * Control if <tt>toString()</tt> should returns the same result + * as <tt>toSource()</tt> when applied to objects and arrays. + * If <tt>hasFeature(FEATURE_TO_STRING_AS_SOURCE)</tt> returns true, + * calling <tt>toString()</tt> on JS objects gives the same result as + * calling <tt>toSource()</tt>. That is it returns JS source with code + * to create an object with all enumeratable fields of the original object + * instead of printing <tt>[object <i>result of + * {@link Scriptable#getClassName()}</i>]</tt>. + * <p> + * By default {@link #hasFeature(int)} returns true only if + * the current JS version is set to {@link #VERSION_1_2}. + */ + public static final int FEATURE_TO_STRING_AS_SOURCE = 4; + + /** + * Control if properties <tt>__proto__</tt> and <tt>__parent__</tt> + * are treated specially. + * If <tt>hasFeature(FEATURE_PARENT_PROTO_PROPERTIES)</tt> returns true, + * treat <tt>__parent__</tt> and <tt>__proto__</tt> as special properties. + * <p> + * The properties allow to query and set scope and prototype chains for the + * objects. The special meaning of the properties is available + * only when they are used as the right hand side of the dot operator. + * For example, while <tt>x.__proto__ = y</tt> changes the prototype + * chain of the object <tt>x</tt> to point to <tt>y</tt>, + * <tt>x["__proto__"] = y</tt> simply assigns a new value to the property + * <tt>__proto__</tt> in <tt>x</tt> even when the feature is on. + * + * By default {@link #hasFeature(int)} returns true. + */ + public static final int FEATURE_PARENT_PROTO_PROPERTIES = 5; + + /** + * @deprecated In previous releases, this name was given to + * FEATURE_PARENT_PROTO_PROPERTIES. + */ + public static final int FEATURE_PARENT_PROTO_PROPRTIES = 5; + + /** + * Control if support for E4X(ECMAScript for XML) extension is available. + * If hasFeature(FEATURE_E4X) returns true, the XML syntax is available. + * <p> + * By default {@link #hasFeature(int)} returns true if + * the current JS version is set to {@link #VERSION_DEFAULT} + * or is at least {@link #VERSION_1_6}. + * @since 1.6 Release 1 + */ + public static final int FEATURE_E4X = 6; + + /** + * Control if dynamic scope should be used for name access. + * If hasFeature(FEATURE_DYNAMIC_SCOPE) returns true, then the name lookup + * during name resolution will use the top scope of the script or function + * which is at the top of JS execution stack instead of the top scope of the + * script or function from the current stack frame if the top scope of + * the top stack frame contains the top scope of the current stack frame + * on its prototype chain. + * <p> + * This is useful to define shared scope containing functions that can + * be called from scripts and functions using private scopes. + * <p> + * By default {@link #hasFeature(int)} returns false. + * @since 1.6 Release 1 + */ + public static final int FEATURE_DYNAMIC_SCOPE = 7; + + /** + * Control if strict variable mode is enabled. + * When the feature is on Rhino reports runtime errors if assignment + * to a global variable that does not exist is executed. When the feature + * is off such assignments creates new variable in the global scope as + * required by ECMA 262. + * <p> + * By default {@link #hasFeature(int)} returns false. + * @since 1.6 Release 1 + */ + public static final int FEATURE_STRICT_VARS = 8; + + /** + * Control if strict eval mode is enabled. + * When the feature is on Rhino reports runtime errors if non-string + * argument is passed to the eval function. When the feature is off + * eval simply return non-string argument as is without performing any + * evaluation as required by ECMA 262. + * <p> + * By default {@link #hasFeature(int)} returns false. + * @since 1.6 Release 1 + */ + public static final int FEATURE_STRICT_EVAL = 9; + + /** + * When the feature is on Rhino will add a "fileName" and "lineNumber" + * properties to Error objects automatically. When the feature is off, you + * have to explicitly pass them as the second and third argument to the + * Error constructor. Note that neither behaviour is fully ECMA 262 + * compliant (as 262 doesn't specify a three-arg constructor), but keeping + * the feature off results in Error objects that don't have + * additional non-ECMA properties when constructed using the ECMA-defined + * single-arg constructor and is thus desirable if a stricter ECMA + * compliance is desired, specifically adherence to the point 15.11.5. of + * the standard. + * <p> + * By default {@link #hasFeature(int)} returns false. + * @since 1.6 Release 6 + */ + public static final int FEATURE_LOCATION_INFORMATION_IN_ERROR = 10; + + /** + * Controls whether JS 1.5 'strict mode' is enabled. + * When the feature is on, Rhino reports more than a dozen different + * warnings. When the feature is off, these warnings are not generated. + * FEATURE_STRICT_MODE implies FEATURE_STRICT_VARS and FEATURE_STRICT_EVAL. + * <p> + * By default {@link #hasFeature(int)} returns false. + * @since 1.6 Release 6 + */ + public static final int FEATURE_STRICT_MODE = 11; + + /** + * Controls whether a warning should be treated as an error. + * @since 1.6 Release 6 + */ + public static final int FEATURE_WARNING_AS_ERROR = 12; + + /** + * Enables enhanced access to Java. + * Specifically, controls whether private and protected members can be + * accessed, and whether scripts can catch all Java exceptions. + * <p> + * Note that this feature should only be enabled for trusted scripts. + * <p> + * By default {@link #hasFeature(int)} returns false. + * @since 1.7 Release 1 + */ + public static final int FEATURE_ENHANCED_JAVA_ACCESS = 13; + + + public static final String languageVersionProperty = "language version"; + public static final String errorReporterProperty = "error reporter"; + + /** + * Convenient value to use as zero-length array of objects. + */ + public static final Object[] emptyArgs = ScriptRuntime.emptyArgs; + + /** + * Create a new Context. + * + * Note that the Context must be associated with a thread before + * it can be used to execute a script. + * @deprecated use {@link ContextFactory#enter()} or + * {@link ContextFactory#call(ContextAction)} instead. + */ + public Context() + { + this(ContextFactory.getGlobal()); + } + + Context(ContextFactory factory) + { + assert factory != null; + this.factory = factory; + setLanguageVersion(VERSION_DEFAULT); + optimizationLevel = codegenClass != null ? 0 : -1; + maximumInterpreterStackDepth = Integer.MAX_VALUE; + } + + /** + * Get the current Context. + * + * The current Context is per-thread; this method looks up + * the Context associated with the current thread. <p> + * + * @return the Context associated with the current thread, or + * null if no context is associated with the current + * thread. + * @see ContextFactory#enterContext() + * @see ContextFactory#call(ContextAction) + */ + public static Context getCurrentContext() + { + Object helper = VMBridge.instance.getThreadContextHelper(); + return VMBridge.instance.getContext(helper); + } + + /** + * Same as calling {@link ContextFactory#enterContext()} on the global + * ContextFactory instance. + * @deprecated use {@link ContextFactory#enter()} or + * {@link ContextFactory#call(ContextAction)} instead as this method relies + * on usage of a static singleton "global" ContextFactory. + * @return a Context associated with the current thread + * @see #getCurrentContext() + * @see #exit() + * @see #call(ContextAction) + */ + public static Context enter() + { + return enter(null); + } + + /** + * Get a Context associated with the current thread, using + * the given Context if need be. + * <p> + * The same as <code>enter()</code> except that <code>cx</code> + * is associated with the current thread and returned if + * the current thread has no associated context and <code>cx</code> + * is not associated with any other thread. + * @param cx a Context to associate with the thread if possible + * @return a Context associated with the current thread + * @deprecated use {@link ContextFactory#enterContext(Context)} instead as + * this method relies on usage of a static singleton "global" ContextFactory. + * @see ContextFactory#enterContext(Context) + * @see ContextFactory#call(ContextAction) + */ + public static Context enter(Context cx) + { + return enter(cx, ContextFactory.getGlobal()); + } + + static final Context enter(Context cx, ContextFactory factory) + { + Object helper = VMBridge.instance.getThreadContextHelper(); + Context old = VMBridge.instance.getContext(helper); + if (old != null) { + cx = old; + } else { + if (cx == null) { + cx = factory.makeContext(); + if (cx.enterCount != 0) { + throw new IllegalStateException("factory.makeContext() returned Context instance already associated with some thread"); + } + factory.onContextCreated(cx); + if (factory.isSealed() && !cx.isSealed()) { + cx.seal(null); + } + } else { + if (cx.enterCount != 0) { + throw new IllegalStateException("can not use Context instance already associated with some thread"); + } + } + VMBridge.instance.setContext(helper, cx); + } + ++cx.enterCount; + return cx; + } + + /** + * Exit a block of code requiring a Context. + * + * Calling <code>exit()</code> will remove the association between + * the current thread and a Context if the prior call to + * {@link ContextFactory#enterContext()} on this thread newly associated a + * Context with this thread. Once the current thread no longer has an + * associated Context, it cannot be used to execute JavaScript until it is + * again associated with a Context. + * @see ContextFactory#enterContext() + */ + public static void exit() + { + Object helper = VMBridge.instance.getThreadContextHelper(); + Context cx = VMBridge.instance.getContext(helper); + if (cx == null) { + throw new IllegalStateException( + "Calling Context.exit without previous Context.enter"); + } + if (cx.enterCount < 1) Kit.codeBug(); + if (--cx.enterCount == 0) { + VMBridge.instance.setContext(helper, null); + cx.factory.onContextReleased(cx); + } + } + + /** + * Call {@link ContextAction#run(Context cx)} + * using the Context instance associated with the current thread. + * If no Context is associated with the thread, then + * <tt>ContextFactory.getGlobal().makeContext()</tt> will be called to + * construct new Context instance. The instance will be temporary + * associated with the thread during call to + * {@link ContextAction#run(Context)}. + * @deprecated use {@link ContextFactory#call(ContextAction)} instead as + * this method relies on usage of a static singleton "global" + * ContextFactory. + * @return The result of {@link ContextAction#run(Context)}. + */ + public static Object call(ContextAction action) + { + return call(ContextFactory.getGlobal(), action); + } + + /** + * Call {@link + * Callable#call(Context cx, Scriptable scope, Scriptable thisObj, + * Object[] args)} + * using the Context instance associated with the current thread. + * If no Context is associated with the thread, then + * {@link ContextFactory#makeContext()} will be called to construct + * new Context instance. The instance will be temporary associated + * with the thread during call to {@link ContextAction#run(Context)}. + * <p> + * It is allowed but not advisable to use null for <tt>factory</tt> + * argument in which case the global static singleton ContextFactory + * instance will be used to create new context instances. + * @see ContextFactory#call(ContextAction) + */ + public static Object call(ContextFactory factory, final Callable callable, + final Scriptable scope, final Scriptable thisObj, + final Object[] args) + { + if(factory == null) { + factory = ContextFactory.getGlobal(); + } + return call(factory, new ContextAction() { + public Object run(Context cx) { + return callable.call(cx, scope, thisObj, args); + } + }); + } + + /** + * The method implements {@links ContextFactory#call(ContextAction)} logic. + */ + static Object call(ContextFactory factory, ContextAction action) { + Context cx = enter(null, factory); + try { + return action.run(cx); + } + finally { + exit(); + } + } + + /** + * @deprecated + * @see ContextFactory#addListener(ContextFactory.Listener) + * @see ContextFactory#getGlobal() + */ + public static void addContextListener(ContextListener listener) + { + // Special workaround for the debugger + String DBG = "org.mozilla.javascript.tools.debugger.Main"; + if (DBG.equals(listener.getClass().getName())) { + Class cl = listener.getClass(); + Class factoryClass = Kit.classOrNull( + "org.mozilla.javascript.ContextFactory"); + Class[] sig = { factoryClass }; + Object[] args = { ContextFactory.getGlobal() }; + try { + Method m = cl.getMethod("attachTo", sig); + m.invoke(listener, args); + } catch (Exception ex) { + RuntimeException rex = new RuntimeException(); + Kit.initCause(rex, ex); + throw rex; + } + return; + } + + ContextFactory.getGlobal().addListener(listener); + } + + /** + * @deprecated + * @see ContextFactory#removeListener(ContextFactory.Listener) + * @see ContextFactory#getGlobal() + */ + public static void removeContextListener(ContextListener listener) + { + ContextFactory.getGlobal().addListener(listener); + } + + /** + * Return {@link ContextFactory} instance used to create this Context. + */ + public final ContextFactory getFactory() + { + return factory; + } + + /** + * Checks if this is a sealed Context. A sealed Context instance does not + * allow to modify any of its properties and will throw an exception + * on any such attempt. + * @see #seal(Object sealKey) + */ + public final boolean isSealed() + { + return sealed; + } + + /** + * Seal this Context object so any attempt to modify any of its properties + * including calling {@link #enter()} and {@link #exit()} methods will + * throw an exception. + * <p> + * If <tt>sealKey</tt> is not null, calling + * {@link #unseal(Object sealKey)} with the same key unseals + * the object. If <tt>sealKey</tt> is null, unsealing is no longer possible. + * + * @see #isSealed() + * @see #unseal(Object) + */ + public final void seal(Object sealKey) + { + if (sealed) onSealedMutation(); + sealed = true; + this.sealKey = sealKey; + } + + /** + * Unseal previously sealed Context object. + * The <tt>sealKey</tt> argument should not be null and should match + * <tt>sealKey</tt> suplied with the last call to + * {@link #seal(Object)} or an exception will be thrown. + * + * @see #isSealed() + * @see #seal(Object sealKey) + */ + public final void unseal(Object sealKey) + { + if (sealKey == null) throw new IllegalArgumentException(); + if (this.sealKey != sealKey) throw new IllegalArgumentException(); + if (!sealed) throw new IllegalStateException(); + sealed = false; + this.sealKey = null; + } + + static void onSealedMutation() + { + throw new IllegalStateException(); + } + + /** + * Get the current language version. + * <p> + * The language version number affects JavaScript semantics as detailed + * in the overview documentation. + * + * @return an integer that is one of VERSION_1_0, VERSION_1_1, etc. + */ + public final int getLanguageVersion() + { + return version; + } + + /** + * Set the language version. + * + * <p> + * Setting the language version will affect functions and scripts compiled + * subsequently. See the overview documentation for version-specific + * behavior. + * + * @param version the version as specified by VERSION_1_0, VERSION_1_1, etc. + */ + public void setLanguageVersion(int version) + { + if (sealed) onSealedMutation(); + checkLanguageVersion(version); + Object listeners = propertyListeners; + if (listeners != null && version != this.version) { + firePropertyChangeImpl(listeners, languageVersionProperty, + new Integer(this.version), + new Integer(version)); + } + this.version = version; + } + + public static boolean isValidLanguageVersion(int version) + { + switch (version) { + case VERSION_DEFAULT: + case VERSION_1_0: + case VERSION_1_1: + case VERSION_1_2: + case VERSION_1_3: + case VERSION_1_4: + case VERSION_1_5: + case VERSION_1_6: + case VERSION_1_7: + return true; + } + return false; + } + + public static void checkLanguageVersion(int version) + { + if (isValidLanguageVersion(version)) { + return; + } + throw new IllegalArgumentException("Bad language version: "+version); + } + + /** + * Get the implementation version. + * + * <p> + * The implementation version is of the form + * <pre> + * "<i>name langVer</i> <code>release</code> <i>relNum date</i>" + * </pre> + * where <i>name</i> is the name of the product, <i>langVer</i> is + * the language version, <i>relNum</i> is the release number, and + * <i>date</i> is the release date for that specific + * release in the form "yyyy mm dd". + * + * @return a string that encodes the product, language version, release + * number, and date. + */ + public final String getImplementationVersion() + { + // XXX Probably it would be better to embed this directly into source + // with special build preprocessing but that would require some ant + // tweaking and then replacing token in resource files was simpler + if (implementationVersion == null) { + implementationVersion + = ScriptRuntime.getMessage0("implementation.version"); + } + return implementationVersion; + } + + /** + * Get the current error reporter. + * + * @see org.mozilla.javascript.ErrorReporter + */ + public final ErrorReporter getErrorReporter() + { + if (errorReporter == null) { + return DefaultErrorReporter.instance; + } + return errorReporter; + } + + /** + * Change the current error reporter. + * + * @return the previous error reporter + * @see org.mozilla.javascript.ErrorReporter + */ + public final ErrorReporter setErrorReporter(ErrorReporter reporter) + { + if (sealed) onSealedMutation(); + if (reporter == null) throw new IllegalArgumentException(); + ErrorReporter old = getErrorReporter(); + if (reporter == old) { + return old; + } + Object listeners = propertyListeners; + if (listeners != null) { + firePropertyChangeImpl(listeners, errorReporterProperty, + old, reporter); + } + this.errorReporter = reporter; + return old; + } + + /** + * Get the current locale. Returns the default locale if none has + * been set. + * + * @see java.util.Locale + */ + + public final Locale getLocale() + { + if (locale == null) + locale = Locale.getDefault(); + return locale; + } + + /** + * Set the current locale. + * + * @see java.util.Locale + */ + public final Locale setLocale(Locale loc) + { + if (sealed) onSealedMutation(); + Locale result = locale; + locale = loc; + return result; + } + + /** + * Register an object to receive notifications when a bound property + * has changed + * @see java.beans.PropertyChangeEvent + * @see #removePropertyChangeListener(java.beans.PropertyChangeListener) + * @param l the listener + */ + public final void addPropertyChangeListener(PropertyChangeListener l) + { + if (sealed) onSealedMutation(); + propertyListeners = Kit.addListener(propertyListeners, l); + } + + /** + * Remove an object from the list of objects registered to receive + * notification of changes to a bounded property + * @see java.beans.PropertyChangeEvent + * @see #addPropertyChangeListener(java.beans.PropertyChangeListener) + * @param l the listener + */ + public final void removePropertyChangeListener(PropertyChangeListener l) + { + if (sealed) onSealedMutation(); + propertyListeners = Kit.removeListener(propertyListeners, l); + } + + /** + * Notify any registered listeners that a bounded property has changed + * @see #addPropertyChangeListener(java.beans.PropertyChangeListener) + * @see #removePropertyChangeListener(java.beans.PropertyChangeListener) + * @see java.beans.PropertyChangeListener + * @see java.beans.PropertyChangeEvent + * @param property the bound property + * @param oldValue the old value + * @param newValue the new value + */ + final void firePropertyChange(String property, Object oldValue, + Object newValue) + { + Object listeners = propertyListeners; + if (listeners != null) { + firePropertyChangeImpl(listeners, property, oldValue, newValue); + } + } + + private void firePropertyChangeImpl(Object listeners, String property, + Object oldValue, Object newValue) + { + for (int i = 0; ; ++i) { + Object l = Kit.getListener(listeners, i); + if (l == null) + break; + if (l instanceof PropertyChangeListener) { + PropertyChangeListener pcl = (PropertyChangeListener)l; + pcl.propertyChange(new PropertyChangeEvent( + this, property, oldValue, newValue)); + } + } + } + + /** + * Report a warning using the error reporter for the current thread. + * + * @param message the warning message to report + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number + * @param lineSource the text of the line (may be null) + * @param lineOffset the offset into lineSource where problem was detected + * @see org.mozilla.javascript.ErrorReporter + */ + public static void reportWarning(String message, String sourceName, + int lineno, String lineSource, + int lineOffset) + { + Context cx = Context.getContext(); + if (cx.hasFeature(FEATURE_WARNING_AS_ERROR)) + reportError(message, sourceName, lineno, lineSource, lineOffset); + else + cx.getErrorReporter().warning(message, sourceName, lineno, + lineSource, lineOffset); + } + + /** + * Report a warning using the error reporter for the current thread. + * + * @param message the warning message to report + * @see org.mozilla.javascript.ErrorReporter + */ + public static void reportWarning(String message) + { + int[] linep = { 0 }; + String filename = getSourcePositionFromStack(linep); + Context.reportWarning(message, filename, linep[0], null, 0); + } + + public static void reportWarning(String message, Throwable t) + { + int[] linep = { 0 }; + String filename = getSourcePositionFromStack(linep); + Writer sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + pw.println(message); + t.printStackTrace(pw); + pw.flush(); + Context.reportWarning(sw.toString(), filename, linep[0], null, 0); + } + + /** + * Report an error using the error reporter for the current thread. + * + * @param message the error message to report + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number + * @param lineSource the text of the line (may be null) + * @param lineOffset the offset into lineSource where problem was detected + * @see org.mozilla.javascript.ErrorReporter + */ + public static void reportError(String message, String sourceName, + int lineno, String lineSource, + int lineOffset) + { + Context cx = getCurrentContext(); + if (cx != null) { + cx.getErrorReporter().error(message, sourceName, lineno, + lineSource, lineOffset); + } else { + throw new EvaluatorException(message, sourceName, lineno, + lineSource, lineOffset); + } + } + + /** + * Report an error using the error reporter for the current thread. + * + * @param message the error message to report + * @see org.mozilla.javascript.ErrorReporter + */ + public static void reportError(String message) + { + int[] linep = { 0 }; + String filename = getSourcePositionFromStack(linep); + Context.reportError(message, filename, linep[0], null, 0); + } + + /** + * Report a runtime error using the error reporter for the current thread. + * + * @param message the error message to report + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number + * @param lineSource the text of the line (may be null) + * @param lineOffset the offset into lineSource where problem was detected + * @return a runtime exception that will be thrown to terminate the + * execution of the script + * @see org.mozilla.javascript.ErrorReporter + */ + public static EvaluatorException reportRuntimeError(String message, + String sourceName, + int lineno, + String lineSource, + int lineOffset) + { + Context cx = getCurrentContext(); + if (cx != null) { + return cx.getErrorReporter(). + runtimeError(message, sourceName, lineno, + lineSource, lineOffset); + } else { + throw new EvaluatorException(message, sourceName, lineno, + lineSource, lineOffset); + } + } + + static EvaluatorException reportRuntimeError0(String messageId) + { + String msg = ScriptRuntime.getMessage0(messageId); + return reportRuntimeError(msg); + } + + static EvaluatorException reportRuntimeError1(String messageId, + Object arg1) + { + String msg = ScriptRuntime.getMessage1(messageId, arg1); + return reportRuntimeError(msg); + } + + static EvaluatorException reportRuntimeError2(String messageId, + Object arg1, Object arg2) + { + String msg = ScriptRuntime.getMessage2(messageId, arg1, arg2); + return reportRuntimeError(msg); + } + + static EvaluatorException reportRuntimeError3(String messageId, + Object arg1, Object arg2, + Object arg3) + { + String msg = ScriptRuntime.getMessage3(messageId, arg1, arg2, arg3); + return reportRuntimeError(msg); + } + + static EvaluatorException reportRuntimeError4(String messageId, + Object arg1, Object arg2, + Object arg3, Object arg4) + { + String msg + = ScriptRuntime.getMessage4(messageId, arg1, arg2, arg3, arg4); + return reportRuntimeError(msg); + } + + /** + * Report a runtime error using the error reporter for the current thread. + * + * @param message the error message to report + * @see org.mozilla.javascript.ErrorReporter + */ + public static EvaluatorException reportRuntimeError(String message) + { + int[] linep = { 0 }; + String filename = getSourcePositionFromStack(linep); + return Context.reportRuntimeError(message, filename, linep[0], null, 0); + } + + /** + * Initialize the standard objects. + * + * Creates instances of the standard objects and their constructors + * (Object, String, Number, Date, etc.), setting up 'scope' to act + * as a global object as in ECMA 15.1.<p> + * + * This method must be called to initialize a scope before scripts + * can be evaluated in that scope.<p> + * + * This method does not affect the Context it is called upon. + * + * @return the initialized scope + */ + public final ScriptableObject initStandardObjects() + { + return initStandardObjects(null, false); + } + + /** + * Initialize the standard objects. + * + * Creates instances of the standard objects and their constructors + * (Object, String, Number, Date, etc.), setting up 'scope' to act + * as a global object as in ECMA 15.1.<p> + * + * This method must be called to initialize a scope before scripts + * can be evaluated in that scope.<p> + * + * This method does not affect the Context it is called upon. + * + * @param scope the scope to initialize, or null, in which case a new + * object will be created to serve as the scope + * @return the initialized scope. The method returns the value of the scope + * argument if it is not null or newly allocated scope object which + * is an instance {@link ScriptableObject}. + */ + public final Scriptable initStandardObjects(ScriptableObject scope) + { + return initStandardObjects(scope, false); + } + + /** + * Initialize the standard objects. + * + * Creates instances of the standard objects and their constructors + * (Object, String, Number, Date, etc.), setting up 'scope' to act + * as a global object as in ECMA 15.1.<p> + * + * This method must be called to initialize a scope before scripts + * can be evaluated in that scope.<p> + * + * This method does not affect the Context it is called upon.<p> + * + * This form of the method also allows for creating "sealed" standard + * objects. An object that is sealed cannot have properties added, changed, + * or removed. This is useful to create a "superglobal" that can be shared + * among several top-level objects. Note that sealing is not allowed in + * the current ECMA/ISO language specification, but is likely for + * the next version. + * + * @param scope the scope to initialize, or null, in which case a new + * object will be created to serve as the scope + * @param sealed whether or not to create sealed standard objects that + * cannot be modified. + * @return the initialized scope. The method returns the value of the scope + * argument if it is not null or newly allocated scope object. + * @since 1.4R3 + */ + public ScriptableObject initStandardObjects(ScriptableObject scope, + boolean sealed) + { + return ScriptRuntime.initStandardObjects(this, scope, sealed); + } + + /** + * Get the singleton object that represents the JavaScript Undefined value. + */ + public static Object getUndefinedValue() + { + return Undefined.instance; + } + + /** + * Evaluate a JavaScript source string. + * + * The provided source name and line number are used for error messages + * and for producing debug information. + * + * @param scope the scope to execute in + * @param source the JavaScript source + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number + * @param securityDomain an arbitrary object that specifies security + * information about the origin or owner of the script. For + * implementations that don't care about security, this value + * may be null. + * @return the result of evaluating the string + * @see org.mozilla.javascript.SecurityController + */ + public final Object evaluateString(Scriptable scope, String source, + String sourceName, int lineno, + Object securityDomain) + { + Script script = compileString(source, sourceName, lineno, + securityDomain); + if (script != null) { + return script.exec(this, scope); + } else { + return null; + } + } + + /** + * Evaluate a reader as JavaScript source. + * + * All characters of the reader are consumed. + * + * @param scope the scope to execute in + * @param in the Reader to get JavaScript source from + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number + * @param securityDomain an arbitrary object that specifies security + * information about the origin or owner of the script. For + * implementations that don't care about security, this value + * may be null. + * @return the result of evaluating the source + * + * @exception IOException if an IOException was generated by the Reader + */ + public final Object evaluateReader(Scriptable scope, Reader in, + String sourceName, int lineno, + Object securityDomain) + throws IOException + { + Script script = compileReader(scope, in, sourceName, lineno, + securityDomain); + if (script != null) { + return script.exec(this, scope); + } else { + return null; + } + } + + /** + * Check whether a string is ready to be compiled. + * <p> + * stringIsCompilableUnit is intended to support interactive compilation of + * javascript. If compiling the string would result in an error + * that might be fixed by appending more source, this method + * returns false. In every other case, it returns true. + * <p> + * Interactive shells may accumulate source lines, using this + * method after each new line is appended to check whether the + * statement being entered is complete. + * + * @param source the source buffer to check + * @return whether the source is ready for compilation + * @since 1.4 Release 2 + */ + public final boolean stringIsCompilableUnit(String source) + { + boolean errorseen = false; + CompilerEnvirons compilerEnv = new CompilerEnvirons(); + compilerEnv.initFromContext(this); + // no source name or source text manager, because we're just + // going to throw away the result. + compilerEnv.setGeneratingSource(false); + /*APPJET*/ + Parser p = InformativeParser.makeParser(compilerEnv, + DefaultErrorReporter.instance); + try { + p.parse(source, null, 1); + } catch (EvaluatorException ee) { + errorseen = true; + } + // Return false only if an error occurred as a result of reading past + // the end of the file, i.e. if the source could be fixed by + // appending more source. + if (errorseen && p.eof()) + return false; + else + return true; + } + + /** + * @deprecated + * @see #compileReader(Reader in, String sourceName, int lineno, + * Object securityDomain) + */ + public final Script compileReader(Scriptable scope, Reader in, + String sourceName, int lineno, + Object securityDomain) + throws IOException + { + return compileReader(in, sourceName, lineno, securityDomain); + } + + /** + * Compiles the source in the given reader. + * <p> + * Returns a script that may later be executed. + * Will consume all the source in the reader. + * + * @param in the input reader + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number for reporting errors + * @param securityDomain an arbitrary object that specifies security + * information about the origin or owner of the script. For + * implementations that don't care about security, this value + * may be null. + * @return a script that may later be executed + * @exception IOException if an IOException was generated by the Reader + * @see org.mozilla.javascript.Script + */ + public final Script compileReader(Reader in, String sourceName, + int lineno, Object securityDomain) + throws IOException + { + if (lineno < 0) { + // For compatibility IllegalArgumentException can not be thrown here + lineno = 0; + } + return (Script) compileImpl(null, in, null, sourceName, lineno, + securityDomain, false, null, null); + } + + /** + * Compiles the source in the given string. + * <p> + * Returns a script that may later be executed. + * + * @param source the source string + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number for reporting errors + * @param securityDomain an arbitrary object that specifies security + * information about the origin or owner of the script. For + * implementations that don't care about security, this value + * may be null. + * @return a script that may later be executed + * @see org.mozilla.javascript.Script + */ + public final Script compileString(String source, + String sourceName, int lineno, + Object securityDomain) + { + if (lineno < 0) { + // For compatibility IllegalArgumentException can not be thrown here + lineno = 0; + } + return compileString(source, null, null, sourceName, lineno, + securityDomain); + } + + final Script compileString(String source, + Evaluator compiler, + ErrorReporter compilationErrorReporter, + String sourceName, int lineno, + Object securityDomain) + { + try { + return (Script) compileImpl(null, null, source, sourceName, lineno, + securityDomain, false, + compiler, compilationErrorReporter); + } catch (IOException ex) { + // Should not happen when dealing with source as string + throw new RuntimeException(); + } + } + + /** + * Compile a JavaScript function. + * <p> + * The function source must be a function definition as defined by + * ECMA (e.g., "function f(a) { return a; }"). + * + * @param scope the scope to compile relative to + * @param source the function definition source + * @param sourceName a string describing the source, such as a filename + * @param lineno the starting line number + * @param securityDomain an arbitrary object that specifies security + * information about the origin or owner of the script. For + * implementations that don't care about security, this value + * may be null. + * @return a Function that may later be called + * @see org.mozilla.javascript.Function + */ + public final Function compileFunction(Scriptable scope, String source, + String sourceName, int lineno, + Object securityDomain) + { + return compileFunction(scope, source, null, null, sourceName, lineno, + securityDomain); + } + + final Function compileFunction(Scriptable scope, String source, + Evaluator compiler, + ErrorReporter compilationErrorReporter, + String sourceName, int lineno, + Object securityDomain) + { + try { + return (Function) compileImpl(scope, null, source, sourceName, + lineno, securityDomain, true, + compiler, compilationErrorReporter); + } + catch (IOException ioe) { + // Should never happen because we just made the reader + // from a String + throw new RuntimeException(); + } + } + + /** + * Decompile the script. + * <p> + * The canonical source of the script is returned. + * + * @param script the script to decompile + * @param indent the number of spaces to indent the result + * @return a string representing the script source + */ + public final String decompileScript(Script script, int indent) + { + NativeFunction scriptImpl = (NativeFunction) script; + return scriptImpl.decompile(indent, 0); + } + + /** + * Decompile a JavaScript Function. + * <p> + * Decompiles a previously compiled JavaScript function object to + * canonical source. + * <p> + * Returns function body of '[native code]' if no decompilation + * information is available. + * + * @param fun the JavaScript function to decompile + * @param indent the number of spaces to indent the result + * @return a string representing the function source + */ + public final String decompileFunction(Function fun, int indent) + { + if (fun instanceof BaseFunction) + return ((BaseFunction)fun).decompile(indent, 0); + else + return "function " + fun.getClassName() + + "() {\n\t[native code]\n}\n"; + } + + /** + * Decompile the body of a JavaScript Function. + * <p> + * Decompiles the body a previously compiled JavaScript Function + * object to canonical source, omitting the function header and + * trailing brace. + * + * Returns '[native code]' if no decompilation information is available. + * + * @param fun the JavaScript function to decompile + * @param indent the number of spaces to indent the result + * @return a string representing the function body source. + */ + public final String decompileFunctionBody(Function fun, int indent) + { + if (fun instanceof BaseFunction) { + BaseFunction bf = (BaseFunction)fun; + return bf.decompile(indent, Decompiler.ONLY_BODY_FLAG); + } + // ALERT: not sure what the right response here is. + return "[native code]\n"; + } + + /** + * Create a new JavaScript object. + * + * Equivalent to evaluating "new Object()". + * @param scope the scope to search for the constructor and to evaluate + * against + * @return the new object + */ + public final Scriptable newObject(Scriptable scope) + { + return newObject(scope, "Object", ScriptRuntime.emptyArgs); + } + + /** + * Create a new JavaScript object by executing the named constructor. + * + * The call <code>newObject(scope, "Foo")</code> is equivalent to + * evaluating "new Foo()". + * + * @param scope the scope to search for the constructor and to evaluate against + * @param constructorName the name of the constructor to call + * @return the new object + */ + public final Scriptable newObject(Scriptable scope, String constructorName) + { + return newObject(scope, constructorName, ScriptRuntime.emptyArgs); + } + + /** + * Creates a new JavaScript object by executing the named constructor. + * + * Searches <code>scope</code> for the named constructor, calls it with + * the given arguments, and returns the result.<p> + * + * The code + * <pre> + * Object[] args = { "a", "b" }; + * newObject(scope, "Foo", args)</pre> + * is equivalent to evaluating "new Foo('a', 'b')", assuming that the Foo + * constructor has been defined in <code>scope</code>. + * + * @param scope The scope to search for the constructor and to evaluate + * against + * @param constructorName the name of the constructor to call + * @param args the array of arguments for the constructor + * @return the new object + */ + public final Scriptable newObject(Scriptable scope, String constructorName, + Object[] args) + { + scope = ScriptableObject.getTopLevelScope(scope); + Function ctor = ScriptRuntime.getExistingCtor(this, scope, + constructorName); + if (args == null) { args = ScriptRuntime.emptyArgs; } + return ctor.construct(this, scope, args); + } + + /** + * Create an array with a specified initial length. + * <p> + * @param scope the scope to create the object in + * @param length the initial length (JavaScript arrays may have + * additional properties added dynamically). + * @return the new array object + */ + public final Scriptable newArray(Scriptable scope, int length) + { + NativeArray result = new NativeArray(length); + ScriptRuntime.setObjectProtoAndParent(result, scope); + return result; + } + + /** + * Create an array with a set of initial elements. + * + * @param scope the scope to create the object in. + * @param elements the initial elements. Each object in this array + * must be an acceptable JavaScript type and type + * of array should be exactly Object[], not + * SomeObjectSubclass[]. + * @return the new array object. + */ + public final Scriptable newArray(Scriptable scope, Object[] elements) + { + if (elements.getClass().getComponentType() != ScriptRuntime.ObjectClass) + throw new IllegalArgumentException(); + NativeArray result = new NativeArray(elements); + ScriptRuntime.setObjectProtoAndParent(result, scope); + return result; + } + + /** + * Get the elements of a JavaScript array. + * <p> + * If the object defines a length property convertible to double number, + * then the number is converted Uint32 value as defined in Ecma 9.6 + * and Java array of that size is allocated. + * The array is initialized with the values obtained by + * calling get() on object for each value of i in [0,length-1]. If + * there is not a defined value for a property the Undefined value + * is used to initialize the corresponding element in the array. The + * Java array is then returned. + * If the object doesn't define a length property or it is not a number, + * empty array is returned. + * @param object the JavaScript array or array-like object + * @return a Java array of objects + * @since 1.4 release 2 + */ + public final Object[] getElements(Scriptable object) + { + return ScriptRuntime.getArrayElements(object); + } + + /** + * Convert the value to a JavaScript boolean value. + * <p> + * See ECMA 9.2. + * + * @param value a JavaScript value + * @return the corresponding boolean value converted using + * the ECMA rules + */ + public static boolean toBoolean(Object value) + { + return ScriptRuntime.toBoolean(value); + } + + /** + * Convert the value to a JavaScript Number value. + * <p> + * Returns a Java double for the JavaScript Number. + * <p> + * See ECMA 9.3. + * + * @param value a JavaScript value + * @return the corresponding double value converted using + * the ECMA rules + */ + public static double toNumber(Object value) + { + return ScriptRuntime.toNumber(value); + } + + /** + * Convert the value to a JavaScript String value. + * <p> + * See ECMA 9.8. + * <p> + * @param value a JavaScript value + * @return the corresponding String value converted using + * the ECMA rules + */ + public static String toString(Object value) + { + return ScriptRuntime.toString(value); + } + + /** + * Convert the value to an JavaScript object value. + * <p> + * Note that a scope must be provided to look up the constructors + * for Number, Boolean, and String. + * <p> + * See ECMA 9.9. + * <p> + * Additionally, arbitrary Java objects and classes will be + * wrapped in a Scriptable object with its Java fields and methods + * reflected as JavaScript properties of the object. + * + * @param value any Java object + * @param scope global scope containing constructors for Number, + * Boolean, and String + * @return new JavaScript object + */ + public static Scriptable toObject(Object value, Scriptable scope) + { + return ScriptRuntime.toObject(scope, value); + } + + /** + * @deprecated + * @see #toObject(Object, Scriptable) + */ + public static Scriptable toObject(Object value, Scriptable scope, + Class staticType) + { + return ScriptRuntime.toObject(scope, value); + } + + /** + * Convenient method to convert java value to its closest representation + * in JavaScript. + * <p> + * If value is an instance of String, Number, Boolean, Function or + * Scriptable, it is returned as it and will be treated as the corresponding + * JavaScript type of string, number, boolean, function and object. + * <p> + * Note that for Number instances during any arithmetic operation in + * JavaScript the engine will always use the result of + * <tt>Number.doubleValue()</tt> resulting in a precision loss if + * the number can not fit into double. + * <p> + * If value is an instance of Character, it will be converted to string of + * length 1 and its JavaScript type will be string. + * <p> + * The rest of values will be wrapped as LiveConnect objects + * by calling {@link WrapFactory#wrap(Context cx, Scriptable scope, + * Object obj, Class staticType)} as in: + * <pre> + * Context cx = Context.getCurrentContext(); + * return cx.getWrapFactory().wrap(cx, scope, value, null); + * </pre> + * + * @param value any Java object + * @param scope top scope object + * @return value suitable to pass to any API that takes JavaScript values. + */ + public static Object javaToJS(Object value, Scriptable scope) + { + if (value instanceof String || value instanceof Number + || value instanceof Boolean || value instanceof Scriptable) + { + return value; + } else if (value instanceof Character) { + return String.valueOf(((Character)value).charValue()); + } else { + Context cx = Context.getContext(); + return cx.getWrapFactory().wrap(cx, scope, value, null); + } + } + + /** + * Convert a JavaScript value into the desired type. + * Uses the semantics defined with LiveConnect3 and throws an + * Illegal argument exception if the conversion cannot be performed. + * @param value the JavaScript value to convert + * @param desiredType the Java type to convert to. Primitive Java + * types are represented using the TYPE fields in the corresponding + * wrapper class in java.lang. + * @return the converted value + * @throws EvaluatorException if the conversion cannot be performed + */ + public static Object jsToJava(Object value, Class desiredType) + throws EvaluatorException + { + return NativeJavaObject.coerceTypeImpl(desiredType, value); + } + + /** + * @deprecated + * @see #jsToJava(Object, Class) + * @throws IllegalArgumentException if the conversion cannot be performed. + * Note that {@link #jsToJava(Object, Class)} throws + * {@link EvaluatorException} instead. + */ + public static Object toType(Object value, Class desiredType) + throws IllegalArgumentException + { + try { + return jsToJava(value, desiredType); + } catch (EvaluatorException ex) { + IllegalArgumentException + ex2 = new IllegalArgumentException(ex.getMessage()); + Kit.initCause(ex2, ex); + throw ex2; + } + } + + /** + * Rethrow the exception wrapping it as the script runtime exception. + * Unless the exception is instance of {@link EcmaError} or + * {@link EvaluatorException} it will be wrapped as + * {@link WrappedException}, a subclass of {@link EvaluatorException}. + * The resulting exception object always contains + * source name and line number of script that triggered exception. + * <p> + * This method always throws an exception, its return value is provided + * only for convenience to allow a usage like: + * <pre> + * throw Context.throwAsScriptRuntimeEx(ex); + * </pre> + * to indicate that code after the method is unreachable. + * @throws EvaluatorException + * @throws EcmaError + */ + public static RuntimeException throwAsScriptRuntimeEx(Throwable e) + { + while ((e instanceof InvocationTargetException)) { + e = ((InvocationTargetException) e).getTargetException(); + } + // special handling of Error so scripts would not catch them + if (e instanceof Error) { + Context cx = getContext(); + if (cx == null || + !cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS)) + { + throw (Error)e; + } + } + if (e instanceof RhinoException) { + throw (RhinoException)e; + } + throw new WrappedException(e); + } + + /** + * Tell whether debug information is being generated. + * @since 1.3 + */ + public final boolean isGeneratingDebug() + { + return generatingDebug; + } + + /** + * Specify whether or not debug information should be generated. + * <p> + * Setting the generation of debug information on will set the + * optimization level to zero. + * @since 1.3 + */ + public final void setGeneratingDebug(boolean generatingDebug) + { + if (sealed) onSealedMutation(); + generatingDebugChanged = true; + if (generatingDebug && getOptimizationLevel() > 0) + setOptimizationLevel(0); + this.generatingDebug = generatingDebug; + } + + /** + * Tell whether source information is being generated. + * @since 1.3 + */ + public final boolean isGeneratingSource() + { + return generatingSource; + } + + /** + * Specify whether or not source information should be generated. + * <p> + * Without source information, evaluating the "toString" method + * on JavaScript functions produces only "[native code]" for + * the body of the function. + * Note that code generated without source is not fully ECMA + * conformant. + * @since 1.3 + */ + public final void setGeneratingSource(boolean generatingSource) + { + if (sealed) onSealedMutation(); + this.generatingSource = generatingSource; + } + + /** + * Get the current optimization level. + * <p> + * The optimization level is expressed as an integer between -1 and + * 9. + * @since 1.3 + * + */ + public final int getOptimizationLevel() + { + return optimizationLevel; + } + + /** + * Set the current optimization level. + * <p> + * The optimization level is expected to be an integer between -1 and + * 9. Any negative values will be interpreted as -1, and any values + * greater than 9 will be interpreted as 9. + * An optimization level of -1 indicates that interpretive mode will + * always be used. Levels 0 through 9 indicate that class files may + * be generated. Higher optimization levels trade off compile time + * performance for runtime performance. + * The optimizer level can't be set greater than -1 if the optimizer + * package doesn't exist at run time. + * @param optimizationLevel an integer indicating the level of + * optimization to perform + * @since 1.3 + * + */ + public final void setOptimizationLevel(int optimizationLevel) + { + if (sealed) onSealedMutation(); + if (optimizationLevel == -2) { + // To be compatible with Cocoon fork + optimizationLevel = -1; + } + checkOptimizationLevel(optimizationLevel); + if (codegenClass == null) + optimizationLevel = -1; + this.optimizationLevel = optimizationLevel; + } + + public static boolean isValidOptimizationLevel(int optimizationLevel) + { + return -1 <= optimizationLevel && optimizationLevel <= 9; + } + + public static void checkOptimizationLevel(int optimizationLevel) + { + if (isValidOptimizationLevel(optimizationLevel)) { + return; + } + throw new IllegalArgumentException( + "Optimization level outside [-1..9]: "+optimizationLevel); + } + + /** + * Returns the maximum stack depth (in terms of number of call frames) + * allowed in a single invocation of interpreter. If the set depth would be + * exceeded, the interpreter will throw an EvaluatorException in the script. + * Defaults to Integer.MAX_VALUE. The setting only has effect for + * interpreted functions (those compiled with optimization level set to -1). + * As the interpreter doesn't use the Java stack but rather manages its own + * stack in the heap memory, a runaway recursion in interpreted code would + * eventually consume all available memory and cause OutOfMemoryError + * instead of a StackOverflowError limited to only a single thread. This + * setting helps prevent such situations. + * + * @return The current maximum interpreter stack depth. + */ + public final int getMaximumInterpreterStackDepth() + { + return maximumInterpreterStackDepth; + } + + /** + * Sets the maximum stack depth (in terms of number of call frames) + * allowed in a single invocation of interpreter. If the set depth would be + * exceeded, the interpreter will throw an EvaluatorException in the script. + * Defaults to Integer.MAX_VALUE. The setting only has effect for + * interpreted functions (those compiled with optimization level set to -1). + * As the interpreter doesn't use the Java stack but rather manages its own + * stack in the heap memory, a runaway recursion in interpreted code would + * eventually consume all available memory and cause OutOfMemoryError + * instead of a StackOverflowError limited to only a single thread. This + * setting helps prevent such situations. + * + * @param max the new maximum interpreter stack depth + * @throws IllegalStateException if this context's optimization level is not + * -1 + * @throws IllegalArgumentException if the new depth is not at least 1 + */ + public final void setMaximumInterpreterStackDepth(int max) + { + if(sealed) onSealedMutation(); + if(optimizationLevel != -1) { + throw new IllegalStateException("Cannot set maximumInterpreterStackDepth when optimizationLevel != -1"); + } + if(max < 1) { + throw new IllegalArgumentException("Cannot set maximumInterpreterStackDepth to less than 1"); + } + maximumInterpreterStackDepth = max; + } + + /** + * Set the security controller for this context. + * <p> SecurityController may only be set if it is currently null + * and {@link SecurityController#hasGlobal()} is <tt>false</tt>. + * Otherwise a SecurityException is thrown. + * @param controller a SecurityController object + * @throws SecurityException if there is already a SecurityController + * object for this Context or globally installed. + * @see SecurityController#initGlobal(SecurityController controller) + * @see SecurityController#hasGlobal() + */ + public final void setSecurityController(SecurityController controller) + { + if (sealed) onSealedMutation(); + if (controller == null) throw new IllegalArgumentException(); + if (securityController != null) { + throw new SecurityException("Can not overwrite existing SecurityController object"); + } + if (SecurityController.hasGlobal()) { + throw new SecurityException("Can not overwrite existing global SecurityController object"); + } + securityController = controller; + } + + /** + * Set the LiveConnect access filter for this context. + * <p> {@link ClassShutter} may only be set if it is currently null. + * Otherwise a SecurityException is thrown. + * @param shutter a ClassShutter object + * @throws SecurityException if there is already a ClassShutter + * object for this Context + */ + public final void setClassShutter(ClassShutter shutter) + { + if (sealed) onSealedMutation(); + if (shutter == null) throw new IllegalArgumentException(); + if (classShutter != null) { + throw new SecurityException("Cannot overwrite existing " + + "ClassShutter object"); + } + classShutter = shutter; + } + + final ClassShutter getClassShutter() + { + return classShutter; + } + + /** + * Get a value corresponding to a key. + * <p> + * Since the Context is associated with a thread it can be + * used to maintain values that can be later retrieved using + * the current thread. + * <p> + * Note that the values are maintained with the Context, so + * if the Context is disassociated from the thread the values + * cannot be retrieved. Also, if private data is to be maintained + * in this manner the key should be a java.lang.Object + * whose reference is not divulged to untrusted code. + * @param key the key used to lookup the value + * @return a value previously stored using putThreadLocal. + */ + public final Object getThreadLocal(Object key) + { + if (hashtable == null) + return null; + return hashtable.get(key); + } + + /** + * Put a value that can later be retrieved using a given key. + * <p> + * @param key the key used to index the value + * @param value the value to save + */ + public final void putThreadLocal(Object key, Object value) + { + if (sealed) onSealedMutation(); + if (hashtable == null) + hashtable = new Hashtable(); + hashtable.put(key, value); + } + + /** + * Remove values from thread-local storage. + * @param key the key for the entry to remove. + * @since 1.5 release 2 + */ + public final void removeThreadLocal(Object key) + { + if (sealed) onSealedMutation(); + if (hashtable == null) + return; + hashtable.remove(key); + } + + /** + * @deprecated + * @see #FEATURE_DYNAMIC_SCOPE + * @see #hasFeature(int) + */ + public final boolean hasCompileFunctionsWithDynamicScope() + { + return compileFunctionsWithDynamicScopeFlag; + } + + /** + * @deprecated + * @see #FEATURE_DYNAMIC_SCOPE + * @see #hasFeature(int) + */ + public final void setCompileFunctionsWithDynamicScope(boolean flag) + { + if (sealed) onSealedMutation(); + compileFunctionsWithDynamicScopeFlag = flag; + } + + /** + * @deprecated + * @see ClassCache#get(Scriptable) + * @see ClassCache#setCachingEnabled(boolean) + */ + public static void setCachingEnabled(boolean cachingEnabled) + { + } + + /** + * Set a WrapFactory for this Context. + * <p> + * The WrapFactory allows custom object wrapping behavior for + * Java object manipulated with JavaScript. + * @see WrapFactory + * @since 1.5 Release 4 + */ + public final void setWrapFactory(WrapFactory wrapFactory) + { + if (sealed) onSealedMutation(); + if (wrapFactory == null) throw new IllegalArgumentException(); + this.wrapFactory = wrapFactory; + } + + /** + * Return the current WrapFactory, or null if none is defined. + * @see WrapFactory + * @since 1.5 Release 4 + */ + public final WrapFactory getWrapFactory() + { + if (wrapFactory == null) { + wrapFactory = new WrapFactory(); + } + return wrapFactory; + } + + /** + * Return the current debugger. + * @return the debugger, or null if none is attached. + */ + public final Debugger getDebugger() + { + return debugger; + } + + /** + * Return the debugger context data associated with current context. + * @return the debugger data, or null if debugger is not attached + */ + public final Object getDebuggerContextData() + { + return debuggerData; + } + + /** + * Set the associated debugger. + * @param debugger the debugger to be used on callbacks from + * the engine. + * @param contextData arbitrary object that debugger can use to store + * per Context data. + */ + public final void setDebugger(Debugger debugger, Object contextData) + { + if (sealed) onSealedMutation(); + this.debugger = debugger; + debuggerData = contextData; + } + + /** + * Return DebuggableScript instance if any associated with the script. + * If callable supports DebuggableScript implementation, the method + * returns it. Otherwise null is returned. + */ + public static DebuggableScript getDebuggableView(Script script) + { + if (script instanceof NativeFunction) { + return ((NativeFunction)script).getDebuggableView(); + } + return null; + } + + /** + * Controls certain aspects of script semantics. + * Should be overwritten to alter default behavior. + * <p> + * The default implementation calls + * {@link ContextFactory#hasFeature(Context cx, int featureIndex)} + * that allows to customize Context behavior without introducing + * Context subclasses. {@link ContextFactory} documentation gives + * an example of hasFeature implementation. + * + * @param featureIndex feature index to check + * @return true if the <code>featureIndex</code> feature is turned on + * @see #FEATURE_NON_ECMA_GET_YEAR + * @see #FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME + * @see #FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER + * @see #FEATURE_TO_STRING_AS_SOURCE + * @see #FEATURE_PARENT_PROTO_PROPRTIES + * @see #FEATURE_E4X + * @see #FEATURE_DYNAMIC_SCOPE + * @see #FEATURE_STRICT_VARS + * @see #FEATURE_STRICT_EVAL + * @see #FEATURE_LOCATION_INFORMATION_IN_ERROR + * @see #FEATURE_STRICT_MODE + * @see #FEATURE_WARNING_AS_ERROR + * @see #FEATURE_ENHANCED_JAVA_ACCESS + */ + public boolean hasFeature(int featureIndex) + { + ContextFactory f = getFactory(); + return f.hasFeature(this, featureIndex); + } + + /** + Returns an object which specifies an E4X implementation to use within + this <code>Context</code>. Note + that the XMLLib.Factory interface should be considered experimental. + + The default implementation uses the implementation provided by this + <code>Context</code>'s {@link ContextFactory}. + + @return An XMLLib.Factory. Should not return <code>null</code> if + {@link #FEATURE_E4X} is enabled. See {@link #hasFeature}. + */ + public XMLLib.Factory getE4xImplementationFactory() { + return getFactory().getE4xImplementationFactory(); + } + + /** + * Get threshold of executed instructions counter that triggers call to + * <code>observeInstructionCount()</code>. + * When the threshold is zero, instruction counting is disabled, + * otherwise each time the run-time executes at least the threshold value + * of script instructions, <code>observeInstructionCount()</code> will + * be called. + */ + public final int getInstructionObserverThreshold() + { + return instructionThreshold; + } + + /** + * Set threshold of executed instructions counter that triggers call to + * <code>observeInstructionCount()</code>. + * When the threshold is zero, instruction counting is disabled, + * otherwise each time the run-time executes at least the threshold value + * of script instructions, <code>observeInstructionCount()</code> will + * be called.<p/> + * Note that the meaning of "instruction" is not guaranteed to be + * consistent between compiled and interpretive modes: executing a given + * script or function in the different modes will result in different + * instruction counts against the threshold. + * {@link #setGenerateObserverCount} is called with true if + * <code>threshold</code> is greater than zero, false otherwise. + * @param threshold The instruction threshold + */ + public final void setInstructionObserverThreshold(int threshold) + { + if (sealed) onSealedMutation(); + if (threshold < 0) throw new IllegalArgumentException(); + instructionThreshold = threshold; + setGenerateObserverCount(threshold > 0); + } + + /** + * Turn on or off generation of code with callbacks to + * track the count of executed instructions. + * Currently only affects JVM byte code generation: this slows down the + * generated code, but code generated without the callbacks will not + * be counted toward instruction thresholds. Rhino's interpretive + * mode does instruction counting without inserting callbacks, so + * there is no requirement to compile code differently. + * @param generateObserverCount if true, generated code will contain + * calls to accumulate an estimate of the instructions executed. + */ + public void setGenerateObserverCount(boolean generateObserverCount) { + this.generateObserverCount = generateObserverCount; + } + + /** + * Allow application to monitor counter of executed script instructions + * in Context subclasses. + * Run-time calls this when instruction counting is enabled and the counter + * reaches limit set by <code>setInstructionObserverThreshold()</code>. + * The method is useful to observe long running scripts and if necessary + * to terminate them. + * <p> + * The instruction counting support is available only for interpreted + * scripts generated when the optimization level is set to -1. + * <p> + * The default implementation calls + * {@link ContextFactory#observeInstructionCount(Context cx, + * int instructionCount)} + * that allows to customize Context behavior without introducing + * Context subclasses. + * + * @param instructionCount amount of script instruction executed since + * last call to <code>observeInstructionCount</code> + * @throws Error to terminate the script + * @see #setOptimizationLevel(int) + */ + protected void observeInstructionCount(int instructionCount) + { + ContextFactory f = getFactory(); + f.observeInstructionCount(this, instructionCount); + } + + /** + * Create class loader for generated classes. + * The method calls {@link ContextFactory#createClassLoader(ClassLoader)} + * using the result of {@link #getFactory()}. + */ + public GeneratedClassLoader createClassLoader(ClassLoader parent) + { + ContextFactory f = getFactory(); + return f.createClassLoader(parent); + } + + public final ClassLoader getApplicationClassLoader() + { + if (applicationClassLoader == null) { + ContextFactory f = getFactory(); + ClassLoader loader = f.getApplicationClassLoader(); + if (loader == null) { + ClassLoader threadLoader + = VMBridge.instance.getCurrentThreadClassLoader(); + if (threadLoader != null + && Kit.testIfCanLoadRhinoClasses(threadLoader)) + { + // Thread.getContextClassLoader is not cached since + // its caching prevents it from GC which may lead to + // a memory leak and hides updates to + // Thread.getContextClassLoader + return threadLoader; + } + // Thread.getContextClassLoader can not load Rhino classes, + // try to use the loader of ContextFactory or Context + // subclasses. + Class fClass = f.getClass(); + if (fClass != ScriptRuntime.ContextFactoryClass) { + loader = fClass.getClassLoader(); + } else { + loader = getClass().getClassLoader(); + } + } + applicationClassLoader = loader; + } + return applicationClassLoader; + } + + public final void setApplicationClassLoader(ClassLoader loader) + { + if (sealed) onSealedMutation(); + if (loader == null) { + // restore default behaviour + applicationClassLoader = null; + return; + } + if (!Kit.testIfCanLoadRhinoClasses(loader)) { + throw new IllegalArgumentException( + "Loader can not resolve Rhino classes"); + } + applicationClassLoader = loader; + } + + /********** end of API **********/ + + /** + * Internal method that reports an error for missing calls to + * enter(). + */ + static Context getContext() + { + Context cx = getCurrentContext(); + if (cx == null) { + throw new RuntimeException( + "No Context associated with current Thread"); + } + return cx; + } + + private Object compileImpl(Scriptable scope, + Reader sourceReader, String sourceString, + String sourceName, int lineno, + Object securityDomain, boolean returnFunction, + Evaluator compiler, + ErrorReporter compilationErrorReporter) + throws IOException + { + if(sourceName == null) { + sourceName = "unnamed script"; + } + if (securityDomain != null && getSecurityController() == null) { + throw new IllegalArgumentException( + "securityDomain should be null if setSecurityController() was never called"); + } + + // One of sourceReader or sourceString has to be null + if (!(sourceReader == null ^ sourceString == null)) Kit.codeBug(); + // scope should be given if and only if compiling function + if (!(scope == null ^ returnFunction)) Kit.codeBug(); + + CompilerEnvirons compilerEnv = new CompilerEnvirons(); + compilerEnv.initFromContext(this); + if (compilationErrorReporter == null) { + compilationErrorReporter = compilerEnv.getErrorReporter(); + } + + if (debugger != null) { + if (sourceReader != null) { + sourceString = Kit.readReader(sourceReader); + sourceReader = null; + } + } + + /*APPJET*/ + Parser p = InformativeParser.makeParser(compilerEnv, + compilationErrorReporter); + if (returnFunction) { + p.calledByCompileFunction = true; + } + ScriptOrFnNode tree; + if (sourceString != null) { + tree = p.parse(sourceString, sourceName, lineno); + } else { + tree = p.parse(sourceReader, sourceName, lineno); + } + if (returnFunction) { + if (!(tree.getFunctionCount() == 1 + && tree.getFirstChild() != null + && tree.getFirstChild().getType() == Token.FUNCTION)) + { + // XXX: the check just look for the first child + // and allows for more nodes after it for compatibility + // with sources like function() {};;; + throw new IllegalArgumentException( + "compileFunction only accepts source with single JS function: "+sourceString); + } + } + + if (compiler == null) { + compiler = createCompiler(); + } + + String encodedSource = p.getEncodedSource(); + + Object bytecode = compiler.compile(compilerEnv, + tree, encodedSource, + returnFunction); + + if (debugger != null) { + if (sourceString == null) Kit.codeBug(); + if (bytecode instanceof DebuggableScript) { + DebuggableScript dscript = (DebuggableScript)bytecode; + notifyDebugger_r(this, dscript, sourceString); + } else { + throw new RuntimeException("NOT SUPPORTED"); + } + } + + Object result; + if (returnFunction) { + result = compiler.createFunctionObject(this, scope, bytecode, securityDomain); + } else { + result = compiler.createScriptObject(bytecode, securityDomain); + } + + return result; + } + + private static void notifyDebugger_r(Context cx, DebuggableScript dscript, + String debugSource) + { + cx.debugger.handleCompilationDone(cx, dscript, debugSource); + for (int i = 0; i != dscript.getFunctionCount(); ++i) { + notifyDebugger_r(cx, dscript.getFunction(i), debugSource); + } + } + + private static Class codegenClass = Kit.classOrNull( + "org.mozilla.javascript.optimizer.Codegen"); + private static Class interpreterClass = Kit.classOrNull( + "org.mozilla.javascript.Interpreter"); + + private Evaluator createCompiler() + { + Evaluator result = null; + if (optimizationLevel >= 0 && codegenClass != null) { + result = (Evaluator)Kit.newInstanceOrNull(codegenClass); + } + if (result == null) { + result = createInterpreter(); + } + return result; + } + + static Evaluator createInterpreter() + { + return (Evaluator)Kit.newInstanceOrNull(interpreterClass); + } + + static String getSourcePositionFromStack(int[] linep) + { + Context cx = getCurrentContext(); + if (cx == null) + return null; + if (cx.lastInterpreterFrame != null) { + Evaluator evaluator = createInterpreter(); + if (evaluator != null) + return evaluator.getSourcePositionFromStack(cx, linep); + } + /** + * A bit of a hack, but the only way to get filename and line + * number from an enclosing frame. + */ + CharArrayWriter writer = new CharArrayWriter(); + RuntimeException re = new RuntimeException(); + re.printStackTrace(new PrintWriter(writer)); + String s = writer.toString(); + int open = -1; + int close = -1; + int colon = -1; + for (int i=0; i < s.length(); i++) { + char c = s.charAt(i); + if (c == ':') + colon = i; + else if (c == '(') + open = i; + else if (c == ')') + close = i; + else if (c == '\n' && open != -1 && close != -1 && colon != -1 && + open < colon && colon < close) + { + String fileStr = s.substring(open + 1, colon); + if (!fileStr.endsWith(".java")) { + String lineStr = s.substring(colon + 1, close); + try { + linep[0] = Integer.parseInt(lineStr); + if (linep[0] < 0) { + linep[0] = 0; + } + return fileStr; + } + catch (NumberFormatException e) { + // fall through + } + } + open = close = colon = -1; + } + } + + return null; + } + + RegExpProxy getRegExpProxy() + { + if (regExpProxy == null) { + Class cl = Kit.classOrNull( + "org.mozilla.javascript.regexp.RegExpImpl"); + if (cl != null) { + regExpProxy = (RegExpProxy)Kit.newInstanceOrNull(cl); + } + } + return regExpProxy; + } + + final boolean isVersionECMA1() + { + return version == VERSION_DEFAULT || version >= VERSION_1_3; + } + +// The method must NOT be public or protected + SecurityController getSecurityController() + { + SecurityController global = SecurityController.global(); + if (global != null) { + return global; + } + return securityController; + } + + public final boolean isGeneratingDebugChanged() + { + return generatingDebugChanged; + } + + /** + * Add a name to the list of names forcing the creation of real + * activation objects for functions. + * + * @param name the name of the object to add to the list + */ + public void addActivationName(String name) + { + if (sealed) onSealedMutation(); + if (activationNames == null) + activationNames = new Hashtable(5); + activationNames.put(name, name); + } + + /** + * Check whether the name is in the list of names of objects + * forcing the creation of activation objects. + * + * @param name the name of the object to test + * + * @return true if an function activation object is needed. + */ + public final boolean isActivationNeeded(String name) + { + return activationNames != null && activationNames.containsKey(name); + } + + /** + * Remove a name from the list of names forcing the creation of real + * activation objects for functions. + * + * @param name the name of the object to remove from the list + */ + public void removeActivationName(String name) + { + if (sealed) onSealedMutation(); + if (activationNames != null) + activationNames.remove(name); + } + + private static String implementationVersion; + + private final ContextFactory factory; + private boolean sealed; + private Object sealKey; + + Scriptable topCallScope; + NativeCall currentActivationCall; + XMLLib cachedXMLLib; + + // for Objects, Arrays to tag themselves as being printed out, + // so they don't print themselves out recursively. + // Use ObjToIntMap instead of java.util.HashSet for JDK 1.1 compatibility + ObjToIntMap iterating; + + Object interpreterSecurityDomain; + + int version; + + private SecurityController securityController; + private ClassShutter classShutter; + private ErrorReporter errorReporter; + RegExpProxy regExpProxy; + private Locale locale; + private boolean generatingDebug; + private boolean generatingDebugChanged; + private boolean generatingSource=true; + boolean compileFunctionsWithDynamicScopeFlag; + boolean useDynamicScope; + private int optimizationLevel; + private int maximumInterpreterStackDepth; + private WrapFactory wrapFactory; + Debugger debugger; + private Object debuggerData; + private int enterCount; + private Object propertyListeners; + private Hashtable hashtable; + private ClassLoader applicationClassLoader; + + /** + * This is the list of names of objects forcing the creation of + * function activation records. + */ + Hashtable activationNames; + + // For the interpreter to store the last frame for error reports etc. + Object lastInterpreterFrame; + + // For the interpreter to store information about previous invocations + // interpreter invocations + ObjArray previousInterpreterInvocations; + + // For instruction counting (interpreter only) + int instructionCount; + int instructionThreshold; + + // It can be used to return the second index-like result from function + int scratchIndex; + + // It can be used to return the second uint32 result from function + long scratchUint32; + + // It can be used to return the second Scriptable result from function + Scriptable scratchScriptable; + + // Generate an observer count on compiled code + public boolean generateObserverCount = false; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextAction.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextAction.java new file mode 100644 index 0000000..1c584a9 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextAction.java @@ -0,0 +1,59 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Interface to represent arbitrary action that requires to have Context + * object associated with the current thread for its execution. + */ +public interface ContextAction +{ + /** + * Execute action using the supplied Context instance. + * When Rhino runtime calls the method, <tt>cx</tt> will be associated + * with the current thread as active context. + * + * @see Context#call(ContextAction) + * @see ContextFactory#call(ContextAction) + */ + public Object run(Context cx); +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextFactory.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextFactory.java new file mode 100644 index 0000000..4f9fde2 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextFactory.java @@ -0,0 +1,594 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Factory class that Rhino runtime uses to create new {@link Context} + * instances. A <code>ContextFactory</code> can also notify listeners + * about context creation and release. + * <p> + * When the Rhino runtime needs to create new {@link Context} instance during + * execution of {@link Context#enter()} or {@link Context}, it will call + * {@link #makeContext()} of the current global ContextFactory. + * See {@link #getGlobal()} and {@link #initGlobal(ContextFactory)}. + * <p> + * It is also possible to use explicit ContextFactory instances for Context + * creation. This is useful to have a set of independent Rhino runtime + * instances under single JVM. See {@link #call(ContextAction)}. + * <p> + * The following example demonstrates Context customization to terminate + * scripts running more then 10 seconds and to provide better compatibility + * with JavaScript code using MSIE-specific features. + * <pre> + * import org.mozilla.javascript.*; + * + * class MyFactory extends ContextFactory + * { + * + * // Custom {@link Context} to store execution time. + * private static class MyContext extends Context + * { + * long startTime; + * } + * + * static { + * // Initialize GlobalFactory with custom factory + * ContextFactory.initGlobal(new MyFactory()); + * } + * + * // Override {@link #makeContext()} + * protected Context makeContext() + * { + * MyContext cx = new MyContext(); + * // Use pure interpreter mode to allow for + * // {@link #observeInstructionCount(Context, int)} to work + * cx.setOptimizationLevel(-1); + * // Make Rhino runtime to call observeInstructionCount + * // each 10000 bytecode instructions + * cx.setInstructionObserverThreshold(10000); + * return cx; + * } + * + * // Override {@link #hasFeature(Context, int)} + * public boolean hasFeature(Context cx, int featureIndex) + * { + * // Turn on maximum compatibility with MSIE scripts + * switch (featureIndex) { + * case {@link Context#FEATURE_NON_ECMA_GET_YEAR}: + * return true; + * + * case {@link Context#FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME}: + * return true; + * + * case {@link Context#FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER}: + * return true; + * + * case {@link Context#FEATURE_PARENT_PROTO_PROPERTIES}: + * return false; + * } + * return super.hasFeature(cx, featureIndex); + * } + * + * // Override {@link #observeInstructionCount(Context, int)} + * protected void observeInstructionCount(Context cx, int instructionCount) + * { + * MyContext mcx = (MyContext)cx; + * long currentTime = System.currentTimeMillis(); + * if (currentTime - mcx.startTime > 10*1000) { + * // More then 10 seconds from Context creation time: + * // it is time to stop the script. + * // Throw Error instance to ensure that script will never + * // get control back through catch or finally. + * throw new Error(); + * } + * } + * + * // Override {@link #doTopCall(Callable, + Context, Scriptable, + Scriptable, Object[])} + * protected Object doTopCall(Callable callable, + * Context cx, Scriptable scope, + * Scriptable thisObj, Object[] args) + * { + * MyContext mcx = (MyContext)cx; + * mcx.startTime = System.currentTimeMillis(); + * + * return super.doTopCall(callable, cx, scope, thisObj, args); + * } + * + * } + * + * </pre> + */ + +public class ContextFactory +{ + private static volatile boolean hasCustomGlobal; + private static ContextFactory global = new ContextFactory(); + + private volatile boolean sealed; + + private final Object listenersLock = new Object(); + private volatile Object listeners; + private boolean disabledListening; + private ClassLoader applicationClassLoader; + + /** + * Listener of {@link Context} creation and release events. + */ + public interface Listener + { + /** + * Notify about newly created {@link Context} object. + */ + public void contextCreated(Context cx); + + /** + * Notify that the specified {@link Context} instance is no longer + * associated with the current thread. + */ + public void contextReleased(Context cx); + } + + /** + * Get global ContextFactory. + * + * @see #hasExplicitGlobal() + * @see #initGlobal(ContextFactory) + */ + public static ContextFactory getGlobal() + { + return global; + } + + /** + * Check if global factory was set. + * Return true to indicate that {@link #initGlobal(ContextFactory)} was + * already called and false to indicate that the global factory was not + * explicitly set. + * + * @see #getGlobal() + * @see #initGlobal(ContextFactory) + */ + public static boolean hasExplicitGlobal() + { + return hasCustomGlobal; + } + + /** + * Set global ContextFactory. + * The method can only be called once. + * + * @see #getGlobal() + * @see #hasExplicitGlobal() + */ + public synchronized static void initGlobal(ContextFactory factory) + { + if (factory == null) { + throw new IllegalArgumentException(); + } + if (hasCustomGlobal) { + throw new IllegalStateException(); + } + hasCustomGlobal = true; + global = factory; + } + + /** + * Create new {@link Context} instance to be associated with the current + * thread. + * This is a callback method used by Rhino to create {@link Context} + * instance when it is necessary to associate one with the current + * execution thread. <tt>makeContext()</tt> is allowed to call + * {@link Context#seal(Object)} on the result to prevent + * {@link Context} changes by hostile scripts or applets. + */ + protected Context makeContext() + { + return new Context(this); + } + + /** + * Implementation of {@link Context#hasFeature(int featureIndex)}. + * This can be used to customize {@link Context} without introducing + * additional subclasses. + */ + protected boolean hasFeature(Context cx, int featureIndex) + { + int version; + switch (featureIndex) { + case Context.FEATURE_NON_ECMA_GET_YEAR: + /* + * During the great date rewrite of 1.3, we tried to track the + * evolving ECMA standard, which then had a definition of + * getYear which always subtracted 1900. Which we + * implemented, not realizing that it was incompatible with + * the old behavior... now, rather than thrash the behavior + * yet again, we've decided to leave it with the - 1900 + * behavior and point people to the getFullYear method. But + * we try to protect existing scripts that have specified a + * version... + */ + version = cx.getLanguageVersion(); + return (version == Context.VERSION_1_0 + || version == Context.VERSION_1_1 + || version == Context.VERSION_1_2); + + case Context.FEATURE_MEMBER_EXPR_AS_FUNCTION_NAME: + return false; + + case Context.FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER: + return false; + + case Context.FEATURE_TO_STRING_AS_SOURCE: + version = cx.getLanguageVersion(); + return version == Context.VERSION_1_2; + + case Context.FEATURE_PARENT_PROTO_PROPERTIES: + return true; + + case Context.FEATURE_E4X: + version = cx.getLanguageVersion(); + return (version == Context.VERSION_DEFAULT + || version >= Context.VERSION_1_6); + + case Context.FEATURE_DYNAMIC_SCOPE: + return false; + + case Context.FEATURE_STRICT_VARS: + return false; + + case Context.FEATURE_STRICT_EVAL: + return false; + + case Context.FEATURE_LOCATION_INFORMATION_IN_ERROR: + return false; + + case Context.FEATURE_STRICT_MODE: + return false; + + case Context.FEATURE_WARNING_AS_ERROR: + return false; + + case Context.FEATURE_ENHANCED_JAVA_ACCESS: + return false; + } + // It is a bug to call the method with unknown featureIndex + throw new IllegalArgumentException(String.valueOf(featureIndex)); + } + + private boolean isDom3Present() { + Class nodeClass = Kit.classOrNull("org.w3c.dom.Node"); + if (nodeClass == null) return false; + // Check to see whether DOM3 is present; use a new method defined in + // DOM3 that is vital to our implementation + try { + nodeClass.getMethod("getUserData", new Class[] { String.class }); + return true; + } catch (NoSuchMethodException e) { + return false; + } + } + + /** + * Provides a default + * {@link org.mozilla.javascript.xml.XMLLib.Factory XMLLib.Factory} + * to be used by the <code>Context</code> instances produced by this + * factory. See {@link Context#getE4xImplementationFactory} for details. + * + * May return null, in which case E4X functionality is not supported in + * Rhino. + * + * The default implementation now prefers the DOM3 E4X implementation. + */ + protected org.mozilla.javascript.xml.XMLLib.Factory + getE4xImplementationFactory() + { + // Must provide default implementation, rather than abstract method, + // so that past implementors of ContextFactory do not fail at runtime + // upon invocation of this method. + // Note that the default implementation returns null if we + // neither have XMLBeans nor a DOM3 implementation present. + + if (isDom3Present()) { + return org.mozilla.javascript.xml.XMLLib.Factory.create( + "org.mozilla.javascript.xmlimpl.XMLLibImpl" + ); + } else if (Kit.classOrNull("org.apache.xmlbeans.XmlCursor") != null) { + return org.mozilla.javascript.xml.XMLLib.Factory.create( + "org.mozilla.javascript.xml.impl.xmlbeans.XMLLibImpl" + ); + } else { + return null; + } + } + + + /** + * Create class loader for generated classes. + * This method creates an instance of the default implementation + * of {@link GeneratedClassLoader}. Rhino uses this interface to load + * generated JVM classes when no {@link SecurityController} + * is installed. + * Application can override the method to provide custom class loading. + */ + protected GeneratedClassLoader createClassLoader(ClassLoader parent) + { + return new DefiningClassLoader(parent); + } + + /** + * Get ClassLoader to use when searching for Java classes. + * Unless it was explicitly initialized with + * {@link #initApplicationClassLoader(ClassLoader)} the method returns + * null to indicate that Thread.getContextClassLoader() should be used. + */ + public final ClassLoader getApplicationClassLoader() + { + return applicationClassLoader; + } + + /** + * Set explicit class loader to use when searching for Java classes. + * + * @see #getApplicationClassLoader() + */ + public final void initApplicationClassLoader(ClassLoader loader) + { + if (loader == null) + throw new IllegalArgumentException("loader is null"); + if (!Kit.testIfCanLoadRhinoClasses(loader)) + throw new IllegalArgumentException( + "Loader can not resolve Rhino classes"); + + if (this.applicationClassLoader != null) + throw new IllegalStateException( + "applicationClassLoader can only be set once"); + checkNotSealed(); + + this.applicationClassLoader = loader; + } + + /** + * Execute top call to script or function. + * When the runtime is about to execute a script or function that will + * create the first stack frame with scriptable code, it calls this method + * to perform the real call. In this way execution of any script + * happens inside this function. + */ + protected Object doTopCall(Callable callable, + Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + return callable.call(cx, scope, thisObj, args); + } + + /** + * Implementation of + * {@link Context#observeInstructionCount(int instructionCount)}. + * This can be used to customize {@link Context} without introducing + * additional subclasses. + */ + protected void observeInstructionCount(Context cx, int instructionCount) + { + } + + protected void onContextCreated(Context cx) + { + Object listeners = this.listeners; + for (int i = 0; ; ++i) { + Listener l = (Listener)Kit.getListener(listeners, i); + if (l == null) + break; + l.contextCreated(cx); + } + } + + protected void onContextReleased(Context cx) + { + Object listeners = this.listeners; + for (int i = 0; ; ++i) { + Listener l = (Listener)Kit.getListener(listeners, i); + if (l == null) + break; + l.contextReleased(cx); + } + } + + public final void addListener(Listener listener) + { + checkNotSealed(); + synchronized (listenersLock) { + if (disabledListening) { + throw new IllegalStateException(); + } + listeners = Kit.addListener(listeners, listener); + } + } + + public final void removeListener(Listener listener) + { + checkNotSealed(); + synchronized (listenersLock) { + if (disabledListening) { + throw new IllegalStateException(); + } + listeners = Kit.removeListener(listeners, listener); + } + } + + /** + * The method is used only to implement + * Context.disableStaticContextListening() + */ + final void disableContextListening() + { + checkNotSealed(); + synchronized (listenersLock) { + disabledListening = true; + listeners = null; + } + } + + /** + * Checks if this is a sealed ContextFactory. + * @see #seal() + */ + public final boolean isSealed() + { + return sealed; + } + + /** + * Seal this ContextFactory so any attempt to modify it like to add or + * remove its listeners will throw an exception. + * @see #isSealed() + */ + public final void seal() + { + checkNotSealed(); + sealed = true; + } + + protected final void checkNotSealed() + { + if (sealed) throw new IllegalStateException(); + } + + /** + * Call {@link ContextAction#run(Context cx)} + * using the {@link Context} instance associated with the current thread. + * If no Context is associated with the thread, then + * {@link #makeContext()} will be called to construct + * new Context instance. The instance will be temporary associated + * with the thread during call to {@link ContextAction#run(Context)}. + * + * @see ContextFactory#call(ContextAction) + * @see Context#call(ContextFactory factory, Callable callable, + * Scriptable scope, Scriptable thisObj, + * Object[] args) + */ + public final Object call(ContextAction action) + { + return Context.call(this, action); + } + + /** + * Get a context associated with the current thread, creating one if need + * be. The Context stores the execution state of the JavaScript engine, so + * it is required that the context be entered before execution may begin. + * Once a thread has entered a Context, then getCurrentContext() may be + * called to find the context that is associated with the current thread. + * <p> + * Calling <code>enterContext()</code> will return either the Context + * currently associated with the thread, or will create a new context and + * associate it with the current thread. Each call to + * <code>enterContext()</code> must have a matching call to + * {@link Context#exit()}. + * <pre> + * Context cx = contextFactory.enterContext(); + * try { + * ... + * cx.evaluateString(...); + * } finally { + * Context.exit(); + * } + * </pre> + * Instead of using <tt>enterContext()</tt>, <tt>exit()</tt> pair consider + * using {@link #call(ContextAction)} which guarantees proper association + * of Context instances with the current thread. + * With this method the above example becomes: + * <pre> + * ContextFactory.call(new ContextAction() { + * public Object run(Context cx) { + * ... + * cx.evaluateString(...); + * return null; + * } + * }); + * </pre> + * @return a Context associated with the current thread + * @see Context#getCurrentContext() + * @see Context#exit() + * @see #call(ContextAction) + */ + public Context enterContext() + { + return enterContext(null); + } + + /** + * @deprecated use {@link #enterContext()} instead + * @return a Context associated with the current thread + */ + public final Context enter() + { + return enterContext(null); + } + + /** + * @deprecated Use {@link Context#exit()} instead. + */ + public final void exit() + { + Context.exit(); + } + + /** + * Get a Context associated with the current thread, using the given + * Context if need be. + * <p> + * The same as <code>enterContext()</code> except that <code>cx</code> + * is associated with the current thread and returned if the current thread + * has no associated context and <code>cx</code> is not associated with any + * other thread. + * @param cx a Context to associate with the thread if possible + * @return a Context associated with the current thread + * @see #enterContext() + * @see #call(ContextAction) + * @throws IllegalStateException if <code>cx</code> is already associated + * with a different thread + */ + public final Context enterContext(Context cx) + { + return Context.enter(cx, this); + } +}
\ No newline at end of file diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextListener.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextListener.java new file mode 100644 index 0000000..5e17145 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ContextListener.java @@ -0,0 +1,60 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * @deprecated Embeddings that wish to customize newly created + * {@link Context} instances should implement + * {@link ContextFactory.Listener}. + */ +public interface ContextListener extends ContextFactory.Listener +{ + + /** + * @deprecated Rhino runtime never calls the method. + */ + public void contextEntered(Context cx); + + /** + * @deprecated Rhino runtime never calls the method. + */ + public void contextExited(Context cx); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DToA.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DToA.java new file mode 100644 index 0000000..ad2a68a --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DToA.java @@ -0,0 +1,1271 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Waldemar Horwat + * Roger Lawrence + * Attila Szegedi + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +/**************************************************************** + * + * The author of this software is David M. Gay. + * + * Copyright (c) 1991, 2000, 2001 by Lucent Technologies. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software and in all copies of the supporting + * documentation for such software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY + * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + ***************************************************************/ + +package org.mozilla.javascript; + +import java.math.BigInteger; + +class DToA { + + +/* "-0.0000...(1073 zeros after decimal point)...0001\0" is the longest string that we could produce, + * which occurs when printing -5e-324 in binary. We could compute a better estimate of the size of + * the output string and malloc fewer bytes depending on d and base, but why bother? */ + + private static final int DTOBASESTR_BUFFER_SIZE = 1078; + + private static char BASEDIGIT(int digit) { + return (char)((digit >= 10) ? 'a' - 10 + digit : '0' + digit); + } + + static final int + DTOSTR_STANDARD = 0, /* Either fixed or exponential format; round-trip */ + DTOSTR_STANDARD_EXPONENTIAL = 1, /* Always exponential format; round-trip */ + DTOSTR_FIXED = 2, /* Round to <precision> digits after the decimal point; exponential if number is large */ + DTOSTR_EXPONENTIAL = 3, /* Always exponential format; <precision> significant digits */ + DTOSTR_PRECISION = 4; /* Either fixed or exponential format; <precision> significant digits */ + + + private static final int Frac_mask = 0xfffff; + private static final int Exp_shift = 20; + private static final int Exp_msk1 = 0x100000; + + private static final long Frac_maskL = 0xfffffffffffffL; + private static final int Exp_shiftL = 52; + private static final long Exp_msk1L = 0x10000000000000L; + + private static final int Bias = 1023; + private static final int P = 53; + + private static final int Exp_shift1 = 20; + private static final int Exp_mask = 0x7ff00000; + private static final int Exp_mask_shifted = 0x7ff; + private static final int Bndry_mask = 0xfffff; + private static final int Log2P = 1; + + private static final int Sign_bit = 0x80000000; + private static final int Exp_11 = 0x3ff00000; + private static final int Ten_pmax = 22; + private static final int Quick_max = 14; + private static final int Bletch = 0x10; + private static final int Frac_mask1 = 0xfffff; + private static final int Int_max = 14; + private static final int n_bigtens = 5; + + + private static final double tens[] = { + 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, + 1e20, 1e21, 1e22 + }; + + private static final double bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 }; + + private static int lo0bits(int y) + { + int k; + int x = y; + + if ((x & 7) != 0) { + if ((x & 1) != 0) + return 0; + if ((x & 2) != 0) { + return 1; + } + return 2; + } + k = 0; + if ((x & 0xffff) == 0) { + k = 16; + x >>>= 16; + } + if ((x & 0xff) == 0) { + k += 8; + x >>>= 8; + } + if ((x & 0xf) == 0) { + k += 4; + x >>>= 4; + } + if ((x & 0x3) == 0) { + k += 2; + x >>>= 2; + } + if ((x & 1) == 0) { + k++; + x >>>= 1; + if ((x & 1) == 0) + return 32; + } + return k; + } + + /* Return the number (0 through 32) of most significant zero bits in x. */ + private static int hi0bits(int x) + { + int k = 0; + + if ((x & 0xffff0000) == 0) { + k = 16; + x <<= 16; + } + if ((x & 0xff000000) == 0) { + k += 8; + x <<= 8; + } + if ((x & 0xf0000000) == 0) { + k += 4; + x <<= 4; + } + if ((x & 0xc0000000) == 0) { + k += 2; + x <<= 2; + } + if ((x & 0x80000000) == 0) { + k++; + if ((x & 0x40000000) == 0) + return 32; + } + return k; + } + + private static void stuffBits(byte bits[], int offset, int val) + { + bits[offset] = (byte)(val >> 24); + bits[offset + 1] = (byte)(val >> 16); + bits[offset + 2] = (byte)(val >> 8); + bits[offset + 3] = (byte)(val); + } + + /* Convert d into the form b*2^e, where b is an odd integer. b is the returned + * Bigint and e is the returned binary exponent. Return the number of significant + * bits in b in bits. d must be finite and nonzero. */ + private static BigInteger d2b(double d, int[] e, int[] bits) + { + byte dbl_bits[]; + int i, k, y, z, de; + long dBits = Double.doubleToLongBits(d); + int d0 = (int)(dBits >>> 32); + int d1 = (int)(dBits); + + z = d0 & Frac_mask; + d0 &= 0x7fffffff; /* clear sign bit, which we ignore */ + + if ((de = (d0 >>> Exp_shift)) != 0) + z |= Exp_msk1; + + if ((y = d1) != 0) { + dbl_bits = new byte[8]; + k = lo0bits(y); + y >>>= k; + if (k != 0) { + stuffBits(dbl_bits, 4, y | z << (32 - k)); + z >>= k; + } + else + stuffBits(dbl_bits, 4, y); + stuffBits(dbl_bits, 0, z); + i = (z != 0) ? 2 : 1; + } + else { + // JS_ASSERT(z); + dbl_bits = new byte[4]; + k = lo0bits(z); + z >>>= k; + stuffBits(dbl_bits, 0, z); + k += 32; + i = 1; + } + if (de != 0) { + e[0] = de - Bias - (P-1) + k; + bits[0] = P - k; + } + else { + e[0] = de - Bias - (P-1) + 1 + k; + bits[0] = 32*i - hi0bits(z); + } + return new BigInteger(dbl_bits); + } + + static String JS_dtobasestr(int base, double d) + { + if (!(2 <= base && base <= 36)) + throw new IllegalArgumentException("Bad base: "+base); + + /* Check for Infinity and NaN */ + if (Double.isNaN(d)) { + return "NaN"; + } else if (Double.isInfinite(d)) { + return (d > 0.0) ? "Infinity" : "-Infinity"; + } else if (d == 0) { + // ALERT: should it distinguish -0.0 from +0.0 ? + return "0"; + } + + boolean negative; + if (d >= 0.0) { + negative = false; + } else { + negative = true; + d = -d; + } + + /* Get the integer part of d including '-' sign. */ + String intDigits; + + double dfloor = Math.floor(d); + long lfloor = (long)dfloor; + if (lfloor == dfloor) { + // int part fits long + intDigits = Long.toString((negative) ? -lfloor : lfloor, base); + } else { + // BigInteger should be used + long floorBits = Double.doubleToLongBits(dfloor); + int exp = (int)(floorBits >> Exp_shiftL) & Exp_mask_shifted; + long mantissa; + if (exp == 0) { + mantissa = (floorBits & Frac_maskL) << 1; + } else { + mantissa = (floorBits & Frac_maskL) | Exp_msk1L; + } + if (negative) { + mantissa = -mantissa; + } + exp -= 1075; + BigInteger x = BigInteger.valueOf(mantissa); + if (exp > 0) { + x = x.shiftLeft(exp); + } else if (exp < 0) { + x = x.shiftRight(-exp); + } + intDigits = x.toString(base); + } + + if (d == dfloor) { + // No fraction part + return intDigits; + } else { + /* We have a fraction. */ + + char[] buffer; /* The output string */ + int p; /* index to current position in the buffer */ + int digit; + double df; /* The fractional part of d */ + BigInteger b; + + buffer = new char[DTOBASESTR_BUFFER_SIZE]; + p = 0; + df = d - dfloor; + + long dBits = Double.doubleToLongBits(d); + int word0 = (int)(dBits >> 32); + int word1 = (int)(dBits); + + int[] e = new int[1]; + int[] bbits = new int[1]; + + b = d2b(df, e, bbits); +// JS_ASSERT(e < 0); + /* At this point df = b * 2^e. e must be less than zero because 0 < df < 1. */ + + int s2 = -(word0 >>> Exp_shift1 & Exp_mask >> Exp_shift1); + if (s2 == 0) + s2 = -1; + s2 += Bias + P; + /* 1/2^s2 = (nextDouble(d) - d)/2 */ +// JS_ASSERT(-s2 < e); + BigInteger mlo = BigInteger.valueOf(1); + BigInteger mhi = mlo; + if ((word1 == 0) && ((word0 & Bndry_mask) == 0) + && ((word0 & (Exp_mask & Exp_mask << 1)) != 0)) { + /* The special case. Here we want to be within a quarter of the last input + significant digit instead of one half of it when the output string's value is less than d. */ + s2 += Log2P; + mhi = BigInteger.valueOf(1<<Log2P); + } + + b = b.shiftLeft(e[0] + s2); + BigInteger s = BigInteger.valueOf(1); + s = s.shiftLeft(s2); + /* At this point we have the following: + * s = 2^s2; + * 1 > df = b/2^s2 > 0; + * (d - prevDouble(d))/2 = mlo/2^s2; + * (nextDouble(d) - d)/2 = mhi/2^s2. */ + BigInteger bigBase = BigInteger.valueOf(base); + + boolean done = false; + do { + b = b.multiply(bigBase); + BigInteger[] divResult = b.divideAndRemainder(s); + b = divResult[1]; + digit = (char)(divResult[0].intValue()); + if (mlo == mhi) + mlo = mhi = mlo.multiply(bigBase); + else { + mlo = mlo.multiply(bigBase); + mhi = mhi.multiply(bigBase); + } + + /* Do we yet have the shortest string that will round to d? */ + int j = b.compareTo(mlo); + /* j is b/2^s2 compared with mlo/2^s2. */ + BigInteger delta = s.subtract(mhi); + int j1 = (delta.signum() <= 0) ? 1 : b.compareTo(delta); + /* j1 is b/2^s2 compared with 1 - mhi/2^s2. */ + if (j1 == 0 && ((word1 & 1) == 0)) { + if (j > 0) + digit++; + done = true; + } else + if (j < 0 || (j == 0 && ((word1 & 1) == 0))) { + if (j1 > 0) { + /* Either dig or dig+1 would work here as the least significant digit. + Use whichever would produce an output value closer to d. */ + b = b.shiftLeft(1); + j1 = b.compareTo(s); + if (j1 > 0) /* The even test (|| (j1 == 0 && (digit & 1))) is not here because it messes up odd base output + * such as 3.5 in base 3. */ + digit++; + } + done = true; + } else if (j1 > 0) { + digit++; + done = true; + } +// JS_ASSERT(digit < (uint32)base); + buffer[p++] = BASEDIGIT(digit); + } while (!done); + + StringBuffer sb = new StringBuffer(intDigits.length() + 1 + p); + sb.append(intDigits); + sb.append('.'); + sb.append(buffer, 0, p); + return sb.toString(); + } + + } + + /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string. + * + * Inspired by "How to Print Floating-Point Numbers Accurately" by + * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101]. + * + * Modifications: + * 1. Rather than iterating, we use a simple numeric overestimate + * to determine k = floor(log10(d)). We scale relevant + * quantities using O(log2(k)) rather than O(k) multiplications. + * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't + * try to generate digits strictly left to right. Instead, we + * compute with fewer bits and propagate the carry if necessary + * when rounding the final digit up. This is often faster. + * 3. Under the assumption that input will be rounded nearest, + * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22. + * That is, we allow equality in stopping tests when the + * round-nearest rule will give the same floating-point value + * as would satisfaction of the stopping test with strict + * inequality. + * 4. We remove common factors of powers of 2 from relevant + * quantities. + * 5. When converting floating-point integers less than 1e16, + * we use floating-point arithmetic rather than resorting + * to multiple-precision integers. + * 6. When asked to produce fewer than 15 digits, we first try + * to get by with floating-point arithmetic; we resort to + * multiple-precision integer arithmetic only if we cannot + * guarantee that the floating-point calculation has given + * the correctly rounded result. For k requested digits and + * "uniformly" distributed input, the probability is + * something like 10^(k-15) that we must resort to the Long + * calculation. + */ + + static int word0(double d) + { + long dBits = Double.doubleToLongBits(d); + return (int)(dBits >> 32); + } + + static double setWord0(double d, int i) + { + long dBits = Double.doubleToLongBits(d); + dBits = ((long)i << 32) | (dBits & 0x0FFFFFFFFL); + return Double.longBitsToDouble(dBits); + } + + static int word1(double d) + { + long dBits = Double.doubleToLongBits(d); + return (int)(dBits); + } + + /* Return b * 5^k. k must be nonnegative. */ + // XXXX the C version built a cache of these + static BigInteger pow5mult(BigInteger b, int k) + { + return b.multiply(BigInteger.valueOf(5).pow(k)); + } + + static boolean roundOff(StringBuffer buf) + { + int i = buf.length(); + while (i != 0) { + --i; + char c = buf.charAt(i); + if (c != '9') { + buf.setCharAt(i, (char)(c + 1)); + buf.setLength(i + 1); + return false; + } + } + buf.setLength(0); + return true; + } + + /* Always emits at least one digit. */ + /* If biasUp is set, then rounding in modes 2 and 3 will round away from zero + * when the number is exactly halfway between two representable values. For example, + * rounding 2.5 to zero digits after the decimal point will return 3 and not 2. + * 2.49 will still round to 2, and 2.51 will still round to 3. */ + /* bufsize should be at least 20 for modes 0 and 1. For the other modes, + * bufsize should be two greater than the maximum number of output characters expected. */ + static int + JS_dtoa(double d, int mode, boolean biasUp, int ndigits, + boolean[] sign, StringBuffer buf) + { + /* Arguments ndigits, decpt, sign are similar to those + of ecvt and fcvt; trailing zeros are suppressed from + the returned string. If not null, *rve is set to point + to the end of the return value. If d is +-Infinity or NaN, + then *decpt is set to 9999. + + mode: + 0 ==> shortest string that yields d when read in + and rounded to nearest. + 1 ==> like 0, but with Steele & White stopping rule; + e.g. with IEEE P754 arithmetic , mode 0 gives + 1e23 whereas mode 1 gives 9.999999999999999e22. + 2 ==> max(1,ndigits) significant digits. This gives a + return value similar to that of ecvt, except + that trailing zeros are suppressed. + 3 ==> through ndigits past the decimal point. This + gives a return value similar to that from fcvt, + except that trailing zeros are suppressed, and + ndigits can be negative. + 4-9 should give the same return values as 2-3, i.e., + 4 <= mode <= 9 ==> same return as mode + 2 + (mode & 1). These modes are mainly for + debugging; often they run slower but sometimes + faster than modes 2-3. + 4,5,8,9 ==> left-to-right digit generation. + 6-9 ==> don't try fast floating-point estimate + (if applicable). + + Values of mode other than 0-9 are treated as mode 0. + + Sufficient space is allocated to the return value + to hold the suppressed trailing zeros. + */ + + int b2, b5, i, ieps, ilim, ilim0, ilim1, + j, j1, k, k0, m2, m5, s2, s5; + char dig; + long L; + long x; + BigInteger b, b1, delta, mlo, mhi, S; + int[] be = new int[1]; + int[] bbits = new int[1]; + double d2, ds, eps; + boolean spec_case, denorm, k_check, try_quick, leftright; + + if ((word0(d) & Sign_bit) != 0) { + /* set sign for everything, including 0's and NaNs */ + sign[0] = true; + // word0(d) &= ~Sign_bit; /* clear sign bit */ + d = setWord0(d, word0(d) & ~Sign_bit); + } + else + sign[0] = false; + + if ((word0(d) & Exp_mask) == Exp_mask) { + /* Infinity or NaN */ + buf.append(((word1(d) == 0) && ((word0(d) & Frac_mask) == 0)) ? "Infinity" : "NaN"); + return 9999; + } + if (d == 0) { +// no_digits: + buf.setLength(0); + buf.append('0'); /* copy "0" to buffer */ + return 1; + } + + b = d2b(d, be, bbits); + if ((i = (word0(d) >>> Exp_shift1 & (Exp_mask>>Exp_shift1))) != 0) { + d2 = setWord0(d, (word0(d) & Frac_mask1) | Exp_11); + /* log(x) ~=~ log(1.5) + (x-1.5)/1.5 + * log10(x) = log(x) / log(10) + * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10)) + * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2) + * + * This suggests computing an approximation k to log10(d) by + * + * k = (i - Bias)*0.301029995663981 + * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 ); + * + * We want k to be too large rather than too small. + * The error in the first-order Taylor series approximation + * is in our favor, so we just round up the constant enough + * to compensate for any error in the multiplication of + * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077, + * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14, + * adding 1e-13 to the constant term more than suffices. + * Hence we adjust the constant term to 0.1760912590558. + * (We could get a more accurate k by invoking log10, + * but this is probably not worthwhile.) + */ + i -= Bias; + denorm = false; + } + else { + /* d is denormalized */ + i = bbits[0] + be[0] + (Bias + (P-1) - 1); + x = (i > 32) ? word0(d) << (64 - i) | word1(d) >>> (i - 32) : word1(d) << (32 - i); +// d2 = x; +// word0(d2) -= 31*Exp_msk1; /* adjust exponent */ + d2 = setWord0(x, word0(x) - 31*Exp_msk1); + i -= (Bias + (P-1) - 1) + 1; + denorm = true; + } + /* At this point d = f*2^i, where 1 <= f < 2. d2 is an approximation of f. */ + ds = (d2-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981; + k = (int)ds; + if (ds < 0.0 && ds != k) + k--; /* want k = floor(ds) */ + k_check = true; + if (k >= 0 && k <= Ten_pmax) { + if (d < tens[k]) + k--; + k_check = false; + } + /* At this point floor(log10(d)) <= k <= floor(log10(d))+1. + If k_check is zero, we're guaranteed that k = floor(log10(d)). */ + j = bbits[0] - i - 1; + /* At this point d = b/2^j, where b is an odd integer. */ + if (j >= 0) { + b2 = 0; + s2 = j; + } + else { + b2 = -j; + s2 = 0; + } + if (k >= 0) { + b5 = 0; + s5 = k; + s2 += k; + } + else { + b2 -= k; + b5 = -k; + s5 = 0; + } + /* At this point d/10^k = (b * 2^b2 * 5^b5) / (2^s2 * 5^s5), where b is an odd integer, + b2 >= 0, b5 >= 0, s2 >= 0, and s5 >= 0. */ + if (mode < 0 || mode > 9) + mode = 0; + try_quick = true; + if (mode > 5) { + mode -= 4; + try_quick = false; + } + leftright = true; + ilim = ilim1 = 0; + switch(mode) { + case 0: + case 1: + ilim = ilim1 = -1; + i = 18; + ndigits = 0; + break; + case 2: + leftright = false; + /* no break */ + case 4: + if (ndigits <= 0) + ndigits = 1; + ilim = ilim1 = i = ndigits; + break; + case 3: + leftright = false; + /* no break */ + case 5: + i = ndigits + k + 1; + ilim = i; + ilim1 = i - 1; + if (i <= 0) + i = 1; + } + /* ilim is the maximum number of significant digits we want, based on k and ndigits. */ + /* ilim1 is the maximum number of significant digits we want, based on k and ndigits, + when it turns out that k was computed too high by one. */ + + boolean fast_failed = false; + if (ilim >= 0 && ilim <= Quick_max && try_quick) { + + /* Try to get by with floating-point arithmetic. */ + + i = 0; + d2 = d; + k0 = k; + ilim0 = ilim; + ieps = 2; /* conservative */ + /* Divide d by 10^k, keeping track of the roundoff error and avoiding overflows. */ + if (k > 0) { + ds = tens[k&0xf]; + j = k >> 4; + if ((j & Bletch) != 0) { + /* prevent overflows */ + j &= Bletch - 1; + d /= bigtens[n_bigtens-1]; + ieps++; + } + for(; (j != 0); j >>= 1, i++) + if ((j & 1) != 0) { + ieps++; + ds *= bigtens[i]; + } + d /= ds; + } + else if ((j1 = -k) != 0) { + d *= tens[j1 & 0xf]; + for(j = j1 >> 4; (j != 0); j >>= 1, i++) + if ((j & 1) != 0) { + ieps++; + d *= bigtens[i]; + } + } + /* Check that k was computed correctly. */ + if (k_check && d < 1.0 && ilim > 0) { + if (ilim1 <= 0) + fast_failed = true; + else { + ilim = ilim1; + k--; + d *= 10.; + ieps++; + } + } + /* eps bounds the cumulative error. */ +// eps = ieps*d + 7.0; +// word0(eps) -= (P-1)*Exp_msk1; + eps = ieps*d + 7.0; + eps = setWord0(eps, word0(eps) - (P-1)*Exp_msk1); + if (ilim == 0) { + S = mhi = null; + d -= 5.0; + if (d > eps) { + buf.append('1'); + k++; + return k + 1; + } + if (d < -eps) { + buf.setLength(0); + buf.append('0'); /* copy "0" to buffer */ + return 1; + } + fast_failed = true; + } + if (!fast_failed) { + fast_failed = true; + if (leftright) { + /* Use Steele & White method of only + * generating digits needed. + */ + eps = 0.5/tens[ilim-1] - eps; + for(i = 0;;) { + L = (long)d; + d -= L; + buf.append((char)('0' + L)); + if (d < eps) { + return k + 1; + } + if (1.0 - d < eps) { +// goto bump_up; + char lastCh; + while (true) { + lastCh = buf.charAt(buf.length() - 1); + buf.setLength(buf.length() - 1); + if (lastCh != '9') break; + if (buf.length() == 0) { + k++; + lastCh = '0'; + break; + } + } + buf.append((char)(lastCh + 1)); + return k + 1; + } + if (++i >= ilim) + break; + eps *= 10.0; + d *= 10.0; + } + } + else { + /* Generate ilim digits, then fix them up. */ + eps *= tens[ilim-1]; + for(i = 1;; i++, d *= 10.0) { + L = (long)d; + d -= L; + buf.append((char)('0' + L)); + if (i == ilim) { + if (d > 0.5 + eps) { +// goto bump_up; + char lastCh; + while (true) { + lastCh = buf.charAt(buf.length() - 1); + buf.setLength(buf.length() - 1); + if (lastCh != '9') break; + if (buf.length() == 0) { + k++; + lastCh = '0'; + break; + } + } + buf.append((char)(lastCh + 1)); + return k + 1; + } + else + if (d < 0.5 - eps) { + stripTrailingZeroes(buf); +// while(*--s == '0') ; +// s++; + return k + 1; + } + break; + } + } + } + } + if (fast_failed) { + buf.setLength(0); + d = d2; + k = k0; + ilim = ilim0; + } + } + + /* Do we have a "small" integer? */ + + if (be[0] >= 0 && k <= Int_max) { + /* Yes. */ + ds = tens[k]; + if (ndigits < 0 && ilim <= 0) { + S = mhi = null; + if (ilim < 0 || d < 5*ds || (!biasUp && d == 5*ds)) { + buf.setLength(0); + buf.append('0'); /* copy "0" to buffer */ + return 1; + } + buf.append('1'); + k++; + return k + 1; + } + for(i = 1;; i++) { + L = (long) (d / ds); + d -= L*ds; + buf.append((char)('0' + L)); + if (i == ilim) { + d += d; + if ((d > ds) || (d == ds && (((L & 1) != 0) || biasUp))) { +// bump_up: +// while(*--s == '9') +// if (s == buf) { +// k++; +// *s = '0'; +// break; +// } +// ++*s++; + char lastCh; + while (true) { + lastCh = buf.charAt(buf.length() - 1); + buf.setLength(buf.length() - 1); + if (lastCh != '9') break; + if (buf.length() == 0) { + k++; + lastCh = '0'; + break; + } + } + buf.append((char)(lastCh + 1)); + } + break; + } + d *= 10.0; + if (d == 0) + break; + } + return k + 1; + } + + m2 = b2; + m5 = b5; + mhi = mlo = null; + if (leftright) { + if (mode < 2) { + i = (denorm) ? be[0] + (Bias + (P-1) - 1 + 1) : 1 + P - bbits[0]; + /* i is 1 plus the number of trailing zero bits in d's significand. Thus, + (2^m2 * 5^m5) / (2^(s2+i) * 5^s5) = (1/2 lsb of d)/10^k. */ + } + else { + j = ilim - 1; + if (m5 >= j) + m5 -= j; + else { + s5 += j -= m5; + b5 += j; + m5 = 0; + } + if ((i = ilim) < 0) { + m2 -= i; + i = 0; + } + /* (2^m2 * 5^m5) / (2^(s2+i) * 5^s5) = (1/2 * 10^(1-ilim))/10^k. */ + } + b2 += i; + s2 += i; + mhi = BigInteger.valueOf(1); + /* (mhi * 2^m2 * 5^m5) / (2^s2 * 5^s5) = one-half of last printed (when mode >= 2) or + input (when mode < 2) significant digit, divided by 10^k. */ + } + /* We still have d/10^k = (b * 2^b2 * 5^b5) / (2^s2 * 5^s5). Reduce common factors in + b2, m2, and s2 without changing the equalities. */ + if (m2 > 0 && s2 > 0) { + i = (m2 < s2) ? m2 : s2; + b2 -= i; + m2 -= i; + s2 -= i; + } + + /* Fold b5 into b and m5 into mhi. */ + if (b5 > 0) { + if (leftright) { + if (m5 > 0) { + mhi = pow5mult(mhi, m5); + b1 = mhi.multiply(b); + b = b1; + } + if ((j = b5 - m5) != 0) + b = pow5mult(b, j); + } + else + b = pow5mult(b, b5); + } + /* Now we have d/10^k = (b * 2^b2) / (2^s2 * 5^s5) and + (mhi * 2^m2) / (2^s2 * 5^s5) = one-half of last printed or input significant digit, divided by 10^k. */ + + S = BigInteger.valueOf(1); + if (s5 > 0) + S = pow5mult(S, s5); + /* Now we have d/10^k = (b * 2^b2) / (S * 2^s2) and + (mhi * 2^m2) / (S * 2^s2) = one-half of last printed or input significant digit, divided by 10^k. */ + + /* Check for special case that d is a normalized power of 2. */ + spec_case = false; + if (mode < 2) { + if ( (word1(d) == 0) && ((word0(d) & Bndry_mask) == 0) + && ((word0(d) & (Exp_mask & Exp_mask << 1)) != 0) + ) { + /* The special case. Here we want to be within a quarter of the last input + significant digit instead of one half of it when the decimal output string's value is less than d. */ + b2 += Log2P; + s2 += Log2P; + spec_case = true; + } + } + + /* Arrange for convenient computation of quotients: + * shift left if necessary so divisor has 4 leading 0 bits. + * + * Perhaps we should just compute leading 28 bits of S once + * and for all and pass them and a shift to quorem, so it + * can do shifts and ors to compute the numerator for q. + */ + byte [] S_bytes = S.toByteArray(); + int S_hiWord = 0; + for (int idx = 0; idx < 4; idx++) { + S_hiWord = (S_hiWord << 8); + if (idx < S_bytes.length) + S_hiWord |= (S_bytes[idx] & 0xFF); + } + if ((i = (((s5 != 0) ? 32 - hi0bits(S_hiWord) : 1) + s2) & 0x1f) != 0) + i = 32 - i; + /* i is the number of leading zero bits in the most significant word of S*2^s2. */ + if (i > 4) { + i -= 4; + b2 += i; + m2 += i; + s2 += i; + } + else if (i < 4) { + i += 28; + b2 += i; + m2 += i; + s2 += i; + } + /* Now S*2^s2 has exactly four leading zero bits in its most significant word. */ + if (b2 > 0) + b = b.shiftLeft(b2); + if (s2 > 0) + S = S.shiftLeft(s2); + /* Now we have d/10^k = b/S and + (mhi * 2^m2) / S = maximum acceptable error, divided by 10^k. */ + if (k_check) { + if (b.compareTo(S) < 0) { + k--; + b = b.multiply(BigInteger.valueOf(10)); /* we botched the k estimate */ + if (leftright) + mhi = mhi.multiply(BigInteger.valueOf(10)); + ilim = ilim1; + } + } + /* At this point 1 <= d/10^k = b/S < 10. */ + + if (ilim <= 0 && mode > 2) { + /* We're doing fixed-mode output and d is less than the minimum nonzero output in this mode. + Output either zero or the minimum nonzero output depending on which is closer to d. */ + if ((ilim < 0 ) + || ((i = b.compareTo(S = S.multiply(BigInteger.valueOf(5)))) < 0) + || ((i == 0 && !biasUp))) { + /* Always emit at least one digit. If the number appears to be zero + using the current mode, then emit one '0' digit and set decpt to 1. */ + /*no_digits: + k = -1 - ndigits; + goto ret; */ + buf.setLength(0); + buf.append('0'); /* copy "0" to buffer */ + return 1; +// goto no_digits; + } +// one_digit: + buf.append('1'); + k++; + return k + 1; + } + if (leftright) { + if (m2 > 0) + mhi = mhi.shiftLeft(m2); + + /* Compute mlo -- check for special case + * that d is a normalized power of 2. + */ + + mlo = mhi; + if (spec_case) { + mhi = mlo; + mhi = mhi.shiftLeft(Log2P); + } + /* mlo/S = maximum acceptable error, divided by 10^k, if the output is less than d. */ + /* mhi/S = maximum acceptable error, divided by 10^k, if the output is greater than d. */ + + for(i = 1;;i++) { + BigInteger[] divResult = b.divideAndRemainder(S); + b = divResult[1]; + dig = (char)(divResult[0].intValue() + '0'); + /* Do we yet have the shortest decimal string + * that will round to d? + */ + j = b.compareTo(mlo); + /* j is b/S compared with mlo/S. */ + delta = S.subtract(mhi); + j1 = (delta.signum() <= 0) ? 1 : b.compareTo(delta); + /* j1 is b/S compared with 1 - mhi/S. */ + if ((j1 == 0) && (mode == 0) && ((word1(d) & 1) == 0)) { + if (dig == '9') { + buf.append('9'); + if (roundOff(buf)) { + k++; + buf.append('1'); + } + return k + 1; +// goto round_9_up; + } + if (j > 0) + dig++; + buf.append(dig); + return k + 1; + } + if ((j < 0) + || ((j == 0) + && (mode == 0) + && ((word1(d) & 1) == 0) + )) { + if (j1 > 0) { + /* Either dig or dig+1 would work here as the least significant decimal digit. + Use whichever would produce a decimal value closer to d. */ + b = b.shiftLeft(1); + j1 = b.compareTo(S); + if (((j1 > 0) || (j1 == 0 && (((dig & 1) == 1) || biasUp))) + && (dig++ == '9')) { + buf.append('9'); + if (roundOff(buf)) { + k++; + buf.append('1'); + } + return k + 1; +// goto round_9_up; + } + } + buf.append(dig); + return k + 1; + } + if (j1 > 0) { + if (dig == '9') { /* possible if i == 1 */ +// round_9_up: +// *s++ = '9'; +// goto roundoff; + buf.append('9'); + if (roundOff(buf)) { + k++; + buf.append('1'); + } + return k + 1; + } + buf.append((char)(dig + 1)); + return k + 1; + } + buf.append(dig); + if (i == ilim) + break; + b = b.multiply(BigInteger.valueOf(10)); + if (mlo == mhi) + mlo = mhi = mhi.multiply(BigInteger.valueOf(10)); + else { + mlo = mlo.multiply(BigInteger.valueOf(10)); + mhi = mhi.multiply(BigInteger.valueOf(10)); + } + } + } + else + for(i = 1;; i++) { +// (char)(dig = quorem(b,S) + '0'); + BigInteger[] divResult = b.divideAndRemainder(S); + b = divResult[1]; + dig = (char)(divResult[0].intValue() + '0'); + buf.append(dig); + if (i >= ilim) + break; + b = b.multiply(BigInteger.valueOf(10)); + } + + /* Round off last digit */ + + b = b.shiftLeft(1); + j = b.compareTo(S); + if ((j > 0) || (j == 0 && (((dig & 1) == 1) || biasUp))) { +// roundoff: +// while(*--s == '9') +// if (s == buf) { +// k++; +// *s++ = '1'; +// goto ret; +// } +// ++*s++; + if (roundOff(buf)) { + k++; + buf.append('1'); + return k + 1; + } + } + else { + stripTrailingZeroes(buf); +// while(*--s == '0') ; +// s++; + } +// ret: +// Bfree(S); +// if (mhi) { +// if (mlo && mlo != mhi) +// Bfree(mlo); +// Bfree(mhi); +// } +// ret1: +// Bfree(b); +// JS_ASSERT(s < buf + bufsize); + return k + 1; + } + + private static void + stripTrailingZeroes(StringBuffer buf) + { +// while(*--s == '0') ; +// s++; + int bl = buf.length(); + while(bl-->0 && buf.charAt(bl) == '0') { + // empty + } + buf.setLength(bl + 1); + } + + /* Mapping of JSDToStrMode -> JS_dtoa mode */ + private static final int dtoaModes[] = { + 0, /* DTOSTR_STANDARD */ + 0, /* DTOSTR_STANDARD_EXPONENTIAL, */ + 3, /* DTOSTR_FIXED, */ + 2, /* DTOSTR_EXPONENTIAL, */ + 2}; /* DTOSTR_PRECISION */ + + static void + JS_dtostr(StringBuffer buffer, int mode, int precision, double d) + { + int decPt; /* Position of decimal point relative to first digit returned by JS_dtoa */ + boolean[] sign = new boolean[1]; /* true if the sign bit was set in d */ + int nDigits; /* Number of significand digits returned by JS_dtoa */ + +// JS_ASSERT(bufferSize >= (size_t)(mode <= DTOSTR_STANDARD_EXPONENTIAL ? DTOSTR_STANDARD_BUFFER_SIZE : +// DTOSTR_VARIABLE_BUFFER_SIZE(precision))); + + if (mode == DTOSTR_FIXED && (d >= 1e21 || d <= -1e21)) + mode = DTOSTR_STANDARD; /* Change mode here rather than below because the buffer may not be large enough to hold a large integer. */ + + decPt = JS_dtoa(d, dtoaModes[mode], mode >= DTOSTR_FIXED, precision, sign, buffer); + nDigits = buffer.length(); + + /* If Infinity, -Infinity, or NaN, return the string regardless of the mode. */ + if (decPt != 9999) { + boolean exponentialNotation = false; + int minNDigits = 0; /* Minimum number of significand digits required by mode and precision */ + int p; + + switch (mode) { + case DTOSTR_STANDARD: + if (decPt < -5 || decPt > 21) + exponentialNotation = true; + else + minNDigits = decPt; + break; + + case DTOSTR_FIXED: + if (precision >= 0) + minNDigits = decPt + precision; + else + minNDigits = decPt; + break; + + case DTOSTR_EXPONENTIAL: +// JS_ASSERT(precision > 0); + minNDigits = precision; + /* Fall through */ + case DTOSTR_STANDARD_EXPONENTIAL: + exponentialNotation = true; + break; + + case DTOSTR_PRECISION: +// JS_ASSERT(precision > 0); + minNDigits = precision; + if (decPt < -5 || decPt > precision) + exponentialNotation = true; + break; + } + + /* If the number has fewer than minNDigits, pad it with zeros at the end */ + if (nDigits < minNDigits) { + p = minNDigits; + nDigits = minNDigits; + do { + buffer.append('0'); + } while (buffer.length() != p); + } + + if (exponentialNotation) { + /* Insert a decimal point if more than one significand digit */ + if (nDigits != 1) { + buffer.insert(1, '.'); + } + buffer.append('e'); + if ((decPt - 1) >= 0) + buffer.append('+'); + buffer.append(decPt - 1); +// JS_snprintf(numEnd, bufferSize - (numEnd - buffer), "e%+d", decPt-1); + } else if (decPt != nDigits) { + /* Some kind of a fraction in fixed notation */ +// JS_ASSERT(decPt <= nDigits); + if (decPt > 0) { + /* dd...dd . dd...dd */ + buffer.insert(decPt, '.'); + } else { + /* 0 . 00...00dd...dd */ + for (int i = 0; i < 1 - decPt; i++) + buffer.insert(0, '0'); + buffer.insert(1, '.'); + } + } + } + + /* If negative and neither -0.0 nor NaN, output a leading '-'. */ + if (sign[0] && + !(word0(d) == Sign_bit && word1(d) == 0) && + !((word0(d) & Exp_mask) == Exp_mask && + ((word1(d) != 0) || ((word0(d) & Frac_mask) != 0)))) { + buffer.insert(0, '-'); + } + } + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Decompiler.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Decompiler.java new file mode 100644 index 0000000..8547d37 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Decompiler.java @@ -0,0 +1,918 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Mike Ang + * Igor Bukanov + * Bob Jervis + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * The following class save decompilation information about the source. + * Source information is returned from the parser as a String + * associated with function nodes and with the toplevel script. When + * saved in the constant pool of a class, this string will be UTF-8 + * encoded, and token values will occupy a single byte. + + * Source is saved (mostly) as token numbers. The tokens saved pretty + * much correspond to the token stream of a 'canonical' representation + * of the input program, as directed by the parser. (There were a few + * cases where tokens could have been left out where decompiler could + * easily reconstruct them, but I left them in for clarity). (I also + * looked adding source collection to TokenStream instead, where I + * could have limited the changes to a few lines in getToken... but + * this wouldn't have saved any space in the resulting source + * representation, and would have meant that I'd have to duplicate + * parser logic in the decompiler to disambiguate situations where + * newlines are important.) The function decompile expands the + * tokens back into their string representations, using simple + * lookahead to correct spacing and indentation. + * + * Assignments are saved as two-token pairs (Token.ASSIGN, op). Number tokens + * are stored inline, as a NUMBER token, a character representing the type, and + * either 1 or 4 characters representing the bit-encoding of the number. String + * types NAME, STRING and OBJECT are currently stored as a token type, + * followed by a character giving the length of the string (assumed to + * be less than 2^16), followed by the characters of the string + * inlined into the source string. Changing this to some reference to + * to the string in the compiled class' constant pool would probably + * save a lot of space... but would require some method of deriving + * the final constant pool entry from information available at parse + * time. + */ +public class Decompiler +{ + /** + * Flag to indicate that the decompilation should omit the + * function header and trailing brace. + */ + public static final int ONLY_BODY_FLAG = 1 << 0; + + /** + * Flag to indicate that the decompilation generates toSource result. + */ + public static final int TO_SOURCE_FLAG = 1 << 1; + + /** + * Decompilation property to specify initial ident value. + */ + public static final int INITIAL_INDENT_PROP = 1; + + /** + * Decompilation property to specify default identation offset. + */ + public static final int INDENT_GAP_PROP = 2; + + /** + * Decompilation property to specify identation offset for case labels. + */ + public static final int CASE_GAP_PROP = 3; + + // Marker to denote the last RC of function so it can be distinguished from + // the last RC of object literals in case of function expressions + private static final int FUNCTION_END = Token.LAST_TOKEN + 1; + + String getEncodedSource() + { + return sourceToString(0); + } + + int getCurrentOffset() + { + return sourceTop; + } + + int markFunctionStart(int functionType) + { + int savedOffset = getCurrentOffset(); + addToken(Token.FUNCTION); + append((char)functionType); + return savedOffset; + } + + int markFunctionEnd(int functionStart) + { + int offset = getCurrentOffset(); + append((char)FUNCTION_END); + return offset; + } + + void addToken(int token) + { + if (!(0 <= token && token <= Token.LAST_TOKEN)) + throw new IllegalArgumentException(); + + append((char)token); + } + + void addEOL(int token) + { + if (!(0 <= token && token <= Token.LAST_TOKEN)) + throw new IllegalArgumentException(); + + append((char)token); + append((char)Token.EOL); + } + + void addName(String str) + { + addToken(Token.NAME); + appendString(str); + } + + void addString(String str) + { + addToken(Token.STRING); + appendString(str); + } + + void addRegexp(String regexp, String flags) + { + addToken(Token.REGEXP); + appendString('/' + regexp + '/' + flags); + } + + void addNumber(double n) + { + addToken(Token.NUMBER); + + /* encode the number in the source stream. + * Save as NUMBER type (char | char char char char) + * where type is + * 'D' - double, 'S' - short, 'J' - long. + + * We need to retain float vs. integer type info to keep the + * behavior of liveconnect type-guessing the same after + * decompilation. (Liveconnect tries to present 1.0 to Java + * as a float/double) + * OPT: This is no longer true. We could compress the format. + + * This may not be the most space-efficient encoding; + * the chars created below may take up to 3 bytes in + * constant pool UTF-8 encoding, so a Double could take + * up to 12 bytes. + */ + + long lbits = (long)n; + if (lbits != n) { + // if it's floating point, save as a Double bit pattern. + // (12/15/97 our scanner only returns Double for f.p.) + lbits = Double.doubleToLongBits(n); + append('D'); + append((char)(lbits >> 48)); + append((char)(lbits >> 32)); + append((char)(lbits >> 16)); + append((char)lbits); + } + else { + // we can ignore negative values, bc they're already prefixed + // by NEG + if (lbits < 0) Kit.codeBug(); + + // will it fit in a char? + // this gives a short encoding for integer values up to 2^16. + if (lbits <= Character.MAX_VALUE) { + append('S'); + append((char)lbits); + } + else { // Integral, but won't fit in a char. Store as a long. + append('J'); + append((char)(lbits >> 48)); + append((char)(lbits >> 32)); + append((char)(lbits >> 16)); + append((char)lbits); + } + } + } + + private void appendString(String str) + { + int L = str.length(); + int lengthEncodingSize = 1; + if (L >= 0x8000) { + lengthEncodingSize = 2; + } + int nextTop = sourceTop + lengthEncodingSize + L; + if (nextTop > sourceBuffer.length) { + increaseSourceCapacity(nextTop); + } + if (L >= 0x8000) { + // Use 2 chars to encode strings exceeding 32K, were the highest + // bit in the first char indicates presence of the next byte + sourceBuffer[sourceTop] = (char)(0x8000 | (L >>> 16)); + ++sourceTop; + } + sourceBuffer[sourceTop] = (char)L; + ++sourceTop; + str.getChars(0, L, sourceBuffer, sourceTop); + sourceTop = nextTop; + } + + private void append(char c) + { + if (sourceTop == sourceBuffer.length) { + increaseSourceCapacity(sourceTop + 1); + } + sourceBuffer[sourceTop] = c; + ++sourceTop; + } + + private void increaseSourceCapacity(int minimalCapacity) + { + // Call this only when capacity increase is must + if (minimalCapacity <= sourceBuffer.length) Kit.codeBug(); + int newCapacity = sourceBuffer.length * 2; + if (newCapacity < minimalCapacity) { + newCapacity = minimalCapacity; + } + char[] tmp = new char[newCapacity]; + System.arraycopy(sourceBuffer, 0, tmp, 0, sourceTop); + sourceBuffer = tmp; + } + + private String sourceToString(int offset) + { + if (offset < 0 || sourceTop < offset) Kit.codeBug(); + return new String(sourceBuffer, offset, sourceTop - offset); + } + + /** + * Decompile the source information associated with this js + * function/script back into a string. For the most part, this + * just means translating tokens back to their string + * representations; there's a little bit of lookahead logic to + * decide the proper spacing/indentation. Most of the work in + * mapping the original source to the prettyprinted decompiled + * version is done by the parser. + * + * @param source encoded source tree presentation + * + * @param flags flags to select output format + * + * @param properties indentation properties + * + */ + public static String decompile(String source, int flags, + UintMap properties) + { + int length = source.length(); + if (length == 0) { return ""; } + + int indent = properties.getInt(INITIAL_INDENT_PROP, 0); + if (indent < 0) throw new IllegalArgumentException(); + int indentGap = properties.getInt(INDENT_GAP_PROP, 4); + if (indentGap < 0) throw new IllegalArgumentException(); + int caseGap = properties.getInt(CASE_GAP_PROP, 2); + if (caseGap < 0) throw new IllegalArgumentException(); + + StringBuffer result = new StringBuffer(); + boolean justFunctionBody = (0 != (flags & Decompiler.ONLY_BODY_FLAG)); + boolean toSource = (0 != (flags & Decompiler.TO_SOURCE_FLAG)); + + // Spew tokens in source, for debugging. + // as TYPE number char + if (printSource) { + System.err.println("length:" + length); + for (int i = 0; i < length; ++i) { + // Note that tokenToName will fail unless Context.printTrees + // is true. + String tokenname = null; + if (Token.printNames) { + tokenname = Token.name(source.charAt(i)); + } + if (tokenname == null) { + tokenname = "---"; + } + String pad = tokenname.length() > 7 + ? "\t" + : "\t\t"; + System.err.println + (tokenname + + pad + (int)source.charAt(i) + + "\t'" + ScriptRuntime.escapeString + (source.substring(i, i+1)) + + "'"); + } + System.err.println(); + } + + int braceNesting = 0; + boolean afterFirstEOL = false; + int i = 0; + int topFunctionType; + if (source.charAt(i) == Token.SCRIPT) { + ++i; + topFunctionType = -1; + } else { + topFunctionType = source.charAt(i + 1); + } + + if (!toSource) { + // add an initial newline to exactly match js. + result.append('\n'); + for (int j = 0; j < indent; j++) + result.append(' '); + } else { + if (topFunctionType == FunctionNode.FUNCTION_EXPRESSION) { + result.append('('); + } + } + + while (i < length) { + switch(source.charAt(i)) { + case Token.GET: + case Token.SET: + result.append(source.charAt(i) == Token.GET ? "get " : "set "); + ++i; + i = printSourceString(source, i + 1, false, result); + // Now increment one more to get past the FUNCTION token + ++i; + break; + + case Token.NAME: + case Token.REGEXP: // re-wrapped in '/'s in parser... + i = printSourceString(source, i + 1, false, result); + continue; + + case Token.STRING: + i = printSourceString(source, i + 1, true, result); + continue; + + case Token.NUMBER: + i = printSourceNumber(source, i + 1, result); + continue; + + case Token.TRUE: + result.append("true"); + break; + + case Token.FALSE: + result.append("false"); + break; + + case Token.NULL: + result.append("null"); + break; + + case Token.THIS: + result.append("this"); + break; + + case Token.FUNCTION: + ++i; // skip function type + result.append("function "); + break; + + case FUNCTION_END: + // Do nothing + break; + + case Token.COMMA: + result.append(", "); + break; + + case Token.LC: + ++braceNesting; + if (Token.EOL == getNext(source, length, i)) + indent += indentGap; + result.append('{'); + break; + + case Token.RC: { + --braceNesting; + /* don't print the closing RC if it closes the + * toplevel function and we're called from + * decompileFunctionBody. + */ + if (justFunctionBody && braceNesting == 0) + break; + + result.append('}'); + switch (getNext(source, length, i)) { + case Token.EOL: + case FUNCTION_END: + indent -= indentGap; + break; + case Token.WHILE: + case Token.ELSE: + indent -= indentGap; + result.append(' '); + break; + } + break; + } + case Token.LP: + result.append('('); + break; + + case Token.RP: + result.append(')'); + if (Token.LC == getNext(source, length, i)) + result.append(' '); + break; + + case Token.LB: + result.append('['); + break; + + case Token.RB: + result.append(']'); + break; + + case Token.EOL: { + if (toSource) break; + boolean newLine = true; + if (!afterFirstEOL) { + afterFirstEOL = true; + if (justFunctionBody) { + /* throw away just added 'function name(...) {' + * and restore the original indent + */ + result.setLength(0); + indent -= indentGap; + newLine = false; + } + } + if (newLine) { + result.append('\n'); + } + + /* add indent if any tokens remain, + * less setback if next token is + * a label, case or default. + */ + if (i + 1 < length) { + int less = 0; + int nextToken = source.charAt(i + 1); + if (nextToken == Token.CASE + || nextToken == Token.DEFAULT) + { + less = indentGap - caseGap; + } else if (nextToken == Token.RC) { + less = indentGap; + } + + /* elaborate check against label... skip past a + * following inlined NAME and look for a COLON. + */ + else if (nextToken == Token.NAME) { + int afterName = getSourceStringEnd(source, i + 2); + if (source.charAt(afterName) == Token.COLON) + less = indentGap; + } + + for (; less < indent; less++) + result.append(' '); + } + break; + } + case Token.DOT: + result.append('.'); + break; + + case Token.NEW: + result.append("new "); + break; + + case Token.DELPROP: + result.append("delete "); + break; + + case Token.IF: + result.append("if "); + break; + + case Token.ELSE: + result.append("else "); + break; + + case Token.FOR: + result.append("for "); + break; + + case Token.IN: + result.append(" in "); + break; + + case Token.WITH: + result.append("with "); + break; + + case Token.WHILE: + result.append("while "); + break; + + case Token.DO: + result.append("do "); + break; + + case Token.TRY: + result.append("try "); + break; + + case Token.CATCH: + result.append("catch "); + break; + + case Token.FINALLY: + result.append("finally "); + break; + + case Token.THROW: + result.append("throw "); + break; + + case Token.SWITCH: + result.append("switch "); + break; + + case Token.BREAK: + result.append("break"); + if (Token.NAME == getNext(source, length, i)) + result.append(' '); + break; + + case Token.CONTINUE: + result.append("continue"); + if (Token.NAME == getNext(source, length, i)) + result.append(' '); + break; + + case Token.CASE: + result.append("case "); + break; + + case Token.DEFAULT: + result.append("default"); + break; + + case Token.RETURN: + result.append("return"); + if (Token.SEMI != getNext(source, length, i)) + result.append(' '); + break; + + case Token.VAR: + result.append("var "); + break; + + case Token.LET: + result.append("let "); + break; + + case Token.SEMI: + result.append(';'); + if (Token.EOL != getNext(source, length, i)) { + // separators in FOR + result.append(' '); + } + break; + + case Token.ASSIGN: + result.append(" = "); + break; + + case Token.ASSIGN_ADD: + result.append(" += "); + break; + + case Token.ASSIGN_SUB: + result.append(" -= "); + break; + + case Token.ASSIGN_MUL: + result.append(" *= "); + break; + + case Token.ASSIGN_DIV: + result.append(" /= "); + break; + + case Token.ASSIGN_MOD: + result.append(" %= "); + break; + + case Token.ASSIGN_BITOR: + result.append(" |= "); + break; + + case Token.ASSIGN_BITXOR: + result.append(" ^= "); + break; + + case Token.ASSIGN_BITAND: + result.append(" &= "); + break; + + case Token.ASSIGN_LSH: + result.append(" <<= "); + break; + + case Token.ASSIGN_RSH: + result.append(" >>= "); + break; + + case Token.ASSIGN_URSH: + result.append(" >>>= "); + break; + + case Token.HOOK: + result.append(" ? "); + break; + + case Token.OBJECTLIT: + // pun OBJECTLIT to mean colon in objlit property + // initialization. + // This needs to be distinct from COLON in the general case + // to distinguish from the colon in a ternary... which needs + // different spacing. + result.append(':'); + break; + + case Token.COLON: + if (Token.EOL == getNext(source, length, i)) + // it's the end of a label + result.append(':'); + else + // it's the middle part of a ternary + result.append(" : "); + break; + + case Token.OR: + result.append(" || "); + break; + + case Token.AND: + result.append(" && "); + break; + + case Token.BITOR: + result.append(" | "); + break; + + case Token.BITXOR: + result.append(" ^ "); + break; + + case Token.BITAND: + result.append(" & "); + break; + + case Token.SHEQ: + result.append(" === "); + break; + + case Token.SHNE: + result.append(" !== "); + break; + + case Token.EQ: + result.append(" == "); + break; + + case Token.NE: + result.append(" != "); + break; + + case Token.LE: + result.append(" <= "); + break; + + case Token.LT: + result.append(" < "); + break; + + case Token.GE: + result.append(" >= "); + break; + + case Token.GT: + result.append(" > "); + break; + + case Token.INSTANCEOF: + result.append(" instanceof "); + break; + + case Token.LSH: + result.append(" << "); + break; + + case Token.RSH: + result.append(" >> "); + break; + + case Token.URSH: + result.append(" >>> "); + break; + + case Token.TYPEOF: + result.append("typeof "); + break; + + case Token.VOID: + result.append("void "); + break; + + case Token.CONST: + result.append("const "); + break; + + case Token.YIELD: + result.append("yield "); + break; + + case Token.NOT: + result.append('!'); + break; + + case Token.BITNOT: + result.append('~'); + break; + + case Token.POS: + result.append('+'); + break; + + case Token.NEG: + result.append('-'); + break; + + case Token.INC: + result.append("++"); + break; + + case Token.DEC: + result.append("--"); + break; + + case Token.ADD: + result.append(" + "); + break; + + case Token.SUB: + result.append(" - "); + break; + + case Token.MUL: + result.append(" * "); + break; + + case Token.DIV: + result.append(" / "); + break; + + case Token.MOD: + result.append(" % "); + break; + + case Token.COLONCOLON: + result.append("::"); + break; + + case Token.DOTDOT: + result.append(".."); + break; + + case Token.DOTQUERY: + result.append(".("); + break; + + case Token.XMLATTR: + result.append('@'); + break; + + default: + // If we don't know how to decompile it, raise an exception. + throw new RuntimeException("Token: " + + Token.name(source.charAt(i))); + } + ++i; + } + + if (!toSource) { + // add that trailing newline if it's an outermost function. + if (!justFunctionBody) + result.append('\n'); + } else { + if (topFunctionType == FunctionNode.FUNCTION_EXPRESSION) { + result.append(')'); + } + } + + return result.toString(); + } + + private static int getNext(String source, int length, int i) + { + return (i + 1 < length) ? source.charAt(i + 1) : Token.EOF; + } + + private static int getSourceStringEnd(String source, int offset) + { + return printSourceString(source, offset, false, null); + } + + private static int printSourceString(String source, int offset, + boolean asQuotedString, + StringBuffer sb) + { + int length = source.charAt(offset); + ++offset; + if ((0x8000 & length) != 0) { + length = ((0x7FFF & length) << 16) | source.charAt(offset); + ++offset; + } + if (sb != null) { + String str = source.substring(offset, offset + length); + if (!asQuotedString) { + sb.append(str); + } else { + sb.append('"'); + sb.append(ScriptRuntime.escapeString(str)); + sb.append('"'); + } + } + return offset + length; + } + + private static int printSourceNumber(String source, int offset, + StringBuffer sb) + { + double number = 0.0; + char type = source.charAt(offset); + ++offset; + if (type == 'S') { + if (sb != null) { + int ival = source.charAt(offset); + number = ival; + } + ++offset; + } else if (type == 'J' || type == 'D') { + if (sb != null) { + long lbits; + lbits = (long)source.charAt(offset) << 48; + lbits |= (long)source.charAt(offset + 1) << 32; + lbits |= (long)source.charAt(offset + 2) << 16; + lbits |= source.charAt(offset + 3); + if (type == 'J') { + number = lbits; + } else { + number = Double.longBitsToDouble(lbits); + } + } + offset += 4; + } else { + // Bad source + throw new RuntimeException(); + } + if (sb != null) { + sb.append(ScriptRuntime.numberToString(number, 10)); + } + return offset; + } + + private char[] sourceBuffer = new char[128]; + +// Per script/function source buffer top: parent source does not include a +// nested functions source and uses function index as a reference instead. + private int sourceTop; + +// whether to do a debug print of the source information, when decompiling. + private static final boolean printSource = false; + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DefaultErrorReporter.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DefaultErrorReporter.java new file mode 100644 index 0000000..c7d93d4 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DefaultErrorReporter.java @@ -0,0 +1,113 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This is the default error reporter for JavaScript. + * + * @author Norris Boyd + */ +class DefaultErrorReporter implements ErrorReporter +{ + static final DefaultErrorReporter instance = new DefaultErrorReporter(); + + private boolean forEval; + private ErrorReporter chainedReporter; + + private DefaultErrorReporter() { } + + static ErrorReporter forEval(ErrorReporter reporter) + { + DefaultErrorReporter r = new DefaultErrorReporter(); + r.forEval = true; + r.chainedReporter = reporter; + return r; + } + + public void warning(String message, String sourceURI, int line, + String lineText, int lineOffset) + { + if (chainedReporter != null) { + chainedReporter.warning( + message, sourceURI, line, lineText, lineOffset); + } else { + // Do nothing + } + } + + public void error(String message, String sourceURI, int line, + String lineText, int lineOffset) + { + if (forEval) { + // Assume error message strings that start with "TypeError: " + // should become TypeError exceptions. A bit of a hack, but we + // don't want to change the ErrorReporter interface. + String error = "SyntaxError"; + final String TYPE_ERROR_NAME = "TypeError"; + final String DELIMETER = ": "; + final String prefix = TYPE_ERROR_NAME + DELIMETER; + if (message.startsWith(prefix)) { + error = TYPE_ERROR_NAME; + message = message.substring(prefix.length()); + } + throw ScriptRuntime.constructError(error, message, sourceURI, + line, lineText, lineOffset); + } + if (chainedReporter != null) { + chainedReporter.error( + message, sourceURI, line, lineText, lineOffset); + } else { + throw runtimeError( + message, sourceURI, line, lineText, lineOffset); + } + } + + public EvaluatorException runtimeError(String message, String sourceURI, + int line, String lineText, + int lineOffset) + { + if (chainedReporter != null) { + return chainedReporter.runtimeError( + message, sourceURI, line, lineText, lineOffset); + } else { + return new EvaluatorException( + message, sourceURI, line, lineText, lineOffset); + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DefiningClassLoader.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DefiningClassLoader.java new file mode 100644 index 0000000..5864b5d --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/DefiningClassLoader.java @@ -0,0 +1,88 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * Patrick Beard + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * Load generated classes. + * + * @author Norris Boyd + */ +public class DefiningClassLoader extends ClassLoader + implements GeneratedClassLoader +{ + public DefiningClassLoader() { + this.parentLoader = getClass().getClassLoader(); + } + + public DefiningClassLoader(ClassLoader parentLoader) { + this.parentLoader = parentLoader; + } + + public Class defineClass(String name, byte[] data) { + // Use our own protection domain for the generated classes. + // TODO: we might want to use a separate protection domain for classes + // compiled from scripts, based on where the script was loaded from. + return super.defineClass(name, data, 0, data.length, + SecurityUtilities.getProtectionDomain(getClass())); + } + + public void linkClass(Class cl) { + resolveClass(cl); + } + + public Class loadClass(String name, boolean resolve) + throws ClassNotFoundException + { + Class cl = findLoadedClass(name); + if (cl == null) { + if (parentLoader != null) { + cl = parentLoader.loadClass(name); + } else { + cl = findSystemClass(name); + } + } + if (resolve) { + resolveClass(cl); + } + return cl; + } + + private final ClassLoader parentLoader; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Delegator.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Delegator.java new file mode 100644 index 0000000..e044863 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Delegator.java @@ -0,0 +1,266 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Delegator.java, released + * Sep 27, 2000. + * + * The Initial Developer of the Original Code is + * Matthias Radestock. <matthias@sorted.org>. + * Portions created by the Initial Developer are Copyright (C) 2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * This is a helper class for implementing wrappers around Scriptable + * objects. It implements the Function interface and delegates all + * invocations to a delegee Scriptable object. The normal use of this + * class involves creating a sub-class and overriding one or more of + * the methods. + * + * A useful application is the implementation of interceptors, + * pre/post conditions, debugging. + * + * @see Function + * @see Scriptable + * @author Matthias Radestock + */ + +public class Delegator implements Function { + + protected Scriptable obj = null; + + /** + * Create a Delegator prototype. + * + * This constructor should only be used for creating prototype + * objects of Delegator. + * + * @see org.mozilla.javascript.Delegator#construct + */ + public Delegator() { + } + + /** + * Create a new Delegator that forwards requests to a delegee + * Scriptable object. + * + * @param obj the delegee + * @see org.mozilla.javascript.Scriptable + */ + public Delegator(Scriptable obj) { + this.obj = obj; + } + + /** + * Crete new Delegator instance. + * The default implementation calls this.getClass().newInstance(). + * + * @see #construct(Context cx, Scriptable scope, Object[] args) + */ + protected Delegator newInstance() + { + try { + return this.getClass().newInstance(); + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } + + /** + * Retrieve the delegee. + * + * @return the delegee + */ + public Scriptable getDelegee() { + return obj; + } + /** + * Set the delegee. + * + * @param obj the delegee + * @see org.mozilla.javascript.Scriptable + */ + public void setDelegee(Scriptable obj) { + this.obj = obj; + } + /** + * @see org.mozilla.javascript.Scriptable#getClassName + */ + public String getClassName() { + return obj.getClassName(); + } + /** + * @see org.mozilla.javascript.Scriptable#get(String, Scriptable) + */ + public Object get(String name, Scriptable start) { + return obj.get(name,start); + } + /** + * @see org.mozilla.javascript.Scriptable#get(int, Scriptable) + */ + public Object get(int index, Scriptable start) { + return obj.get(index,start); + } + /** + * @see org.mozilla.javascript.Scriptable#has(String, Scriptable) + */ + public boolean has(String name, Scriptable start) { + return obj.has(name,start); + } + /** + * @see org.mozilla.javascript.Scriptable#has(int, Scriptable) + */ + public boolean has(int index, Scriptable start) { + return obj.has(index,start); + } + /** + * @see org.mozilla.javascript.Scriptable#put(String, Scriptable, Object) + */ + public void put(String name, Scriptable start, Object value) { + obj.put(name,start,value); + } + /** + * @see org.mozilla.javascript.Scriptable#put(int, Scriptable, Object) + */ + public void put(int index, Scriptable start, Object value) { + obj.put(index,start,value); + } + /** + * @see org.mozilla.javascript.Scriptable#delete(String) + */ + public void delete(String name) { + obj.delete(name); + } + /** + * @see org.mozilla.javascript.Scriptable#delete(int) + */ + public void delete(int index) { + obj.delete(index); + } + /** + * @see org.mozilla.javascript.Scriptable#getPrototype + */ + public Scriptable getPrototype() { + return obj.getPrototype(); + } + /** + * @see org.mozilla.javascript.Scriptable#setPrototype + */ + public void setPrototype(Scriptable prototype) { + obj.setPrototype(prototype); + } + /** + * @see org.mozilla.javascript.Scriptable#getParentScope + */ + public Scriptable getParentScope() { + return obj.getParentScope(); + } + /** + * @see org.mozilla.javascript.Scriptable#setParentScope + */ + public void setParentScope(Scriptable parent) { + obj.setParentScope(parent); + } + /** + * @see org.mozilla.javascript.Scriptable#getIds + */ + public Object[] getIds() { + return obj.getIds(); + } + /** + * Note that this method does not get forwarded to the delegee if + * the <code>hint</code> parameter is null, + * <code>ScriptRuntime.ScriptableClass</code> or + * <code>ScriptRuntime.FunctionClass</code>. Instead the object + * itself is returned. + * + * @param hint the type hint + * @return the default value + * + * @see org.mozilla.javascript.Scriptable#getDefaultValue + */ + public Object getDefaultValue(Class hint) { + return (hint == null || + hint == ScriptRuntime.ScriptableClass || + hint == ScriptRuntime.FunctionClass) ? + this : obj.getDefaultValue(hint); + } + /** + * @see org.mozilla.javascript.Scriptable#hasInstance + */ + public boolean hasInstance(Scriptable instance) { + return obj.hasInstance(instance); + } + /** + * @see org.mozilla.javascript.Function#call + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return ((Function)obj).call(cx,scope,thisObj,args); + } + + /** + * Note that if the <code>delegee</code> is <code>null</code>, + * this method creates a new instance of the Delegator itself + * rathert than forwarding the call to the + * <code>delegee</code>. This permits the use of Delegator + * prototypes. + * + * @param cx the current Context for this thread + * @param scope an enclosing scope of the caller except + * when the function is called from a closure. + * @param args the array of arguments + * @return the allocated object + * + * @see Function#construct(Context, Scriptable, Object[]) + */ + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + if (obj == null) { + //this little trick allows us to declare prototype objects for + //Delegators + Delegator n = newInstance(); + Scriptable delegee; + if (args.length == 0) { + delegee = new NativeObject(); + } else { + delegee = ScriptRuntime.toObject(cx, scope, args[0]); + } + n.setDelegee(delegee); + return n; + } + else { + return ((Function)obj).construct(cx,scope,args); + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/EcmaError.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/EcmaError.java new file mode 100644 index 0000000..1fd8f03 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/EcmaError.java @@ -0,0 +1,160 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * The class of exceptions raised by the engine as described in + * ECMA edition 3. See section 15.11.6 in particular. + */ +public class EcmaError extends RhinoException +{ + static final long serialVersionUID = -6261226256957286699L; + + private String errorName; + private String errorMessage; + + /** + * Create an exception with the specified detail message. + * + * Errors internal to the JavaScript engine will simply throw a + * RuntimeException. + * + * @param sourceName the name of the source reponsible for the error + * @param lineNumber the line number of the source + * @param columnNumber the columnNumber of the source (may be zero if + * unknown) + * @param lineSource the source of the line containing the error (may be + * null if unknown) + */ + EcmaError(String errorName, String errorMessage, + String sourceName, int lineNumber, + String lineSource, int columnNumber) + { + recordErrorOrigin(sourceName, lineNumber, lineSource, columnNumber); + this.errorName = errorName; + this.errorMessage = errorMessage; + } + + /** + * @deprecated EcmaError error instances should not be constructed + * explicitly since they are generated by the engine. + */ + public EcmaError(Scriptable nativeError, String sourceName, + int lineNumber, int columnNumber, String lineSource) + { + this("InternalError", ScriptRuntime.toString(nativeError), + sourceName, lineNumber, lineSource, columnNumber); + } + + public String details() + { + return errorName+": "+errorMessage; + } + + /** + * Gets the name of the error. + * + * ECMA edition 3 defines the following + * errors: EvalError, RangeError, ReferenceError, + * SyntaxError, TypeError, and URIError. Additional error names + * may be added in the future. + * + * See ECMA edition 3, 15.11.7.9. + * + * @return the name of the error. + */ + public String getName() + { + return errorName; + } + + /** + * Gets the message corresponding to the error. + * + * See ECMA edition 3, 15.11.7.10. + * + * @return an implemenation-defined string describing the error. + */ + public String getErrorMessage() + { + return errorMessage; + } + + /** + * @deprecated Use {@link RhinoException#sourceName()} from the super class. + */ + public String getSourceName() + { + return sourceName(); + } + + /** + * @deprecated Use {@link RhinoException#lineNumber()} from the super class. + */ + public int getLineNumber() + { + return lineNumber(); + } + + /** + * @deprecated + * Use {@link RhinoException#columnNumber()} from the super class. + */ + public int getColumnNumber() { + return columnNumber(); + } + + /** + * @deprecated Use {@link RhinoException#lineSource()} from the super class. + */ + public String getLineSource() { + return lineSource(); + } + + /** + * @deprecated + * Always returns <b>null</b>. + */ + public Scriptable getErrorObject() + { + return null; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ErrorReporter.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ErrorReporter.java new file mode 100644 index 0000000..4649370 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ErrorReporter.java @@ -0,0 +1,106 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * This is interface defines a protocol for the reporting of + * errors during JavaScript translation or execution. + * + * @author Norris Boyd + */ + +public interface ErrorReporter { + + /** + * Report a warning. + * + * The implementing class may choose to ignore the warning + * if it desires. + * + * @param message a String describing the warning + * @param sourceName a String describing the JavaScript source + * where the warning occured; typically a filename or URL + * @param line the line number associated with the warning + * @param lineSource the text of the line (may be null) + * @param lineOffset the offset into lineSource where problem was detected + */ + void warning(String message, String sourceName, int line, + String lineSource, int lineOffset); + + /** + * Report an error. + * + * The implementing class is free to throw an exception if + * it desires. + * + * If execution has not yet begun, the JavaScript engine is + * free to find additional errors rather than terminating + * the translation. It will not execute a script that had + * errors, however. + * + * @param message a String describing the error + * @param sourceName a String describing the JavaScript source + * where the error occured; typically a filename or URL + * @param line the line number associated with the error + * @param lineSource the text of the line (may be null) + * @param lineOffset the offset into lineSource where problem was detected + */ + void error(String message, String sourceName, int line, + String lineSource, int lineOffset); + + /** + * Creates an EvaluatorException that may be thrown. + * + * runtimeErrors, unlike errors, will always terminate the + * current script. + * + * @param message a String describing the error + * @param sourceName a String describing the JavaScript source + * where the error occured; typically a filename or URL + * @param line the line number associated with the error + * @param lineSource the text of the line (may be null) + * @param lineOffset the offset into lineSource where problem was detected + * @return an EvaluatorException that will be thrown. + */ + EvaluatorException runtimeError(String message, String sourceName, + int line, String lineSource, + int lineOffset); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Evaluator.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Evaluator.java new file mode 100644 index 0000000..e222af3 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Evaluator.java @@ -0,0 +1,118 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.List; + +/** + * Abstraction of evaluation, which can be implemented either by an + * interpreter or compiler. + */ +public interface Evaluator { + + /** + * Compile the script or function from intermediate representation + * tree into an executable form. + * + * @param compilerEnv Compiler environment + * @param tree intermediate representation + * @param encodedSource encoding of the source code for decompilation + * @param returnFunction if true, compiling a function + * @return an opaque object that can be passed to either + * createFunctionObject or createScriptObject, depending on the + * value of returnFunction + */ + public Object compile(CompilerEnvirons compilerEnv, + ScriptOrFnNode tree, + String encodedSource, + boolean returnFunction); + + /** + * Create a function object. + * + * @param cx Current context + * @param scope scope of the function + * @param bytecode opaque object returned by compile + * @param staticSecurityDomain security domain + * @return Function object that can be called + */ + public Function createFunctionObject(Context cx, Scriptable scope, + Object bytecode, Object staticSecurityDomain); + + /** + * Create a script object. + * + * @param bytecode opaque object returned by compile + * @param staticSecurityDomain security domain + * @return Script object that can be evaluated + */ + public Script createScriptObject(Object bytecode, + Object staticSecurityDomain); + + /** + * Capture stack information from the given exception. + * @param ex an exception thrown during execution + */ + public void captureStackInfo(RhinoException ex); + + /** + * Get the source position information by examining the stack. + * @param cx Context + * @param linep Array object of length >= 1; getSourcePositionFromStack + * will assign the line number to linep[0]. + * @return the name of the file or other source container + */ + public String getSourcePositionFromStack(Context cx, int[] linep); + + /** + * Given a native stack trace, patch it with script-specific source + * and line information + * @param ex exception + * @param nativeStackTrace the native stack trace + * @return patched stack trace + */ + public String getPatchedStack(RhinoException ex, + String nativeStackTrace); + + /** + * Get the script stack for the given exception + * @param ex exception from execution + * @return list of strings for the stack trace + */ + public List getScriptStack(RhinoException ex); + + /** + * Mark the given script to indicate it was created by a call to + * eval() or to a Function constructor. + * @param script script to mark as from eval + */ + public void setEvalScriptFlag(Script script); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/EvaluatorException.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/EvaluatorException.java new file mode 100644 index 0000000..7b4e7cc --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/EvaluatorException.java @@ -0,0 +1,123 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript; + +/** + * The class of exceptions thrown by the JavaScript engine. + */ +public class EvaluatorException extends RhinoException +{ + static final long serialVersionUID = -8743165779676009808L; + + public EvaluatorException(String detail) + { + super(detail); + } + + /** + * Create an exception with the specified detail message. + * + * Errors internal to the JavaScript engine will simply throw a + * RuntimeException. + * + * @param detail the error message + * @param sourceName the name of the source reponsible for the error + * @param lineNumber the line number of the source + */ + public EvaluatorException(String detail, String sourceName, + int lineNumber) + { + this(detail, sourceName, lineNumber, null, 0); + } + + /** + * Create an exception with the specified detail message. + * + * Errors internal to the JavaScript engine will simply throw a + * RuntimeException. + * + * @param detail the error message + * @param sourceName the name of the source responsible for the error + * @param lineNumber the line number of the source + * @param columnNumber the columnNumber of the source (may be zero if + * unknown) + * @param lineSource the source of the line containing the error (may be + * null if unknown) + */ + public EvaluatorException(String detail, String sourceName, int lineNumber, + String lineSource, int columnNumber) + { + super(detail); + recordErrorOrigin(sourceName, lineNumber, lineSource, columnNumber); + } + + /** + * @deprecated Use {@link RhinoException#sourceName()} from the super class. + */ + public String getSourceName() + { + return sourceName(); + } + + /** + * @deprecated Use {@link RhinoException#lineNumber()} from the super class. + */ + public int getLineNumber() + { + return lineNumber(); + } + + /** + * @deprecated Use {@link RhinoException#columnNumber()} from the super class. + */ + public int getColumnNumber() + { + return columnNumber(); + } + + /** + * @deprecated Use {@link RhinoException#lineSource()} from the super class. + */ + public String getLineSource() + { + return lineSource(); + } + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Function.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Function.java new file mode 100644 index 0000000..a4377e6 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Function.java @@ -0,0 +1,84 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * This is interface that all functions in JavaScript must implement. + * The interface provides for calling functions and constructors. + * + * @see org.mozilla.javascript.Scriptable + * @author Norris Boyd + */ + +public interface Function extends Scriptable, Callable +{ + /** + * Call the function. + * + * Note that the array of arguments is not guaranteed to have + * length greater than 0. + * + * @param cx the current Context for this thread + * @param scope the scope to execute the function relative to. This is + * set to the value returned by getParentScope() except + * when the function is called from a closure. + * @param thisObj the JavaScript <code>this</code> object + * @param args the array of arguments + * @return the result of the call + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args); + + /** + * Call the function as a constructor. + * + * This method is invoked by the runtime in order to satisfy a use + * of the JavaScript <code>new</code> operator. This method is + * expected to create a new object and return it. + * + * @param cx the current Context for this thread + * @param scope an enclosing scope of the caller except + * when the function is called from a closure. + * @param args the array of arguments + * @return the allocated object + */ + public Scriptable construct(Context cx, Scriptable scope, Object[] args); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/FunctionNode.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/FunctionNode.java new file mode 100644 index 0000000..484167e --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/FunctionNode.java @@ -0,0 +1,117 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; +import java.util.ArrayList; +import java.util.HashMap; + +public class FunctionNode extends ScriptOrFnNode { + + public FunctionNode(String name) { + super(Token.FUNCTION); + functionName = name; + } + + public String getFunctionName() { + return functionName; + } + + public boolean requiresActivation() { + return itsNeedsActivation; + } + + public boolean getIgnoreDynamicScope() { + return itsIgnoreDynamicScope; + } + + public boolean isGenerator() { + return itsIsGenerator; + } + + public void addResumptionPoint(Node target) { + if (generatorResumePoints == null) + generatorResumePoints = new ArrayList(); + generatorResumePoints.add(target); + } + + public ArrayList getResumptionPoints() { + return generatorResumePoints; + } + + public HashMap getLiveLocals() { + return liveLocals; + } + + public void addLiveLocals(Node node, int[] locals) { + if (liveLocals == null) + liveLocals = new HashMap(); + liveLocals.put(node, locals); + } + + /** + * There are three types of functions that can be defined. The first + * is a function statement. This is a function appearing as a top-level + * statement (i.e., not nested inside some other statement) in either a + * script or a function. + * + * The second is a function expression, which is a function appearing in + * an expression except for the third type, which is... + * + * The third type is a function expression where the expression is the + * top-level expression in an expression statement. + * + * The three types of functions have different treatment and must be + * distinguished. + */ + public static final int FUNCTION_STATEMENT = 1; + public static final int FUNCTION_EXPRESSION = 2; + public static final int FUNCTION_EXPRESSION_STATEMENT = 3; + + public int getFunctionType() { + return itsFunctionType; + } + + String functionName; + int itsFunctionType; + boolean itsNeedsActivation; + boolean itsIgnoreDynamicScope; + boolean itsIsGenerator; + ArrayList generatorResumePoints; + HashMap liveLocals; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/FunctionObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/FunctionObject.java new file mode 100644 index 0000000..8fa4e68 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/FunctionObject.java @@ -0,0 +1,569 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * David C. Navas + * Ted Neward + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +import java.lang.reflect.*; +import java.io.*; + +public class FunctionObject extends BaseFunction +{ + static final long serialVersionUID = -5332312783643935019L; + + /** + * Create a JavaScript function object from a Java method. + * + * <p>The <code>member</code> argument must be either a java.lang.reflect.Method + * or a java.lang.reflect.Constructor and must match one of two forms.<p> + * + * The first form is a member with zero or more parameters + * of the following types: Object, String, boolean, Scriptable, + * int, or double. The Long type is not supported + * because the double representation of a long (which is the + * EMCA-mandated storage type for Numbers) may lose precision. + * If the member is a Method, the return value must be void or one + * of the types allowed for parameters.<p> + * + * The runtime will perform appropriate conversions based + * upon the type of the parameter. A parameter type of + * Object specifies that no conversions are to be done. A parameter + * of type String will use Context.toString to convert arguments. + * Similarly, parameters of type double, boolean, and Scriptable + * will cause Context.toNumber, Context.toBoolean, and + * Context.toObject, respectively, to be called.<p> + * + * If the method is not static, the Java 'this' value will + * correspond to the JavaScript 'this' value. Any attempt + * to call the function with a 'this' value that is not + * of the right Java type will result in an error.<p> + * + * The second form is the variable arguments (or "varargs") + * form. If the FunctionObject will be used as a constructor, + * the member must have the following parameters + * <pre> + * (Context cx, Object[] args, Function ctorObj, + * boolean inNewExpr)</pre> + * and if it is a Method, be static and return an Object result.<p> + * + * Otherwise, if the FunctionObject will <i>not</i> be used to define a + * constructor, the member must be a static Method with parameters + * (Context cx, Scriptable thisObj, Object[] args, + * Function funObj) </pre> + * <pre> + * and an Object result.<p> + * + * When the function varargs form is called as part of a function call, + * the <code>args</code> parameter contains the + * arguments, with <code>thisObj</code> + * set to the JavaScript 'this' value. <code>funObj</code> + * is the function object for the invoked function.<p> + * + * When the constructor varargs form is called or invoked while evaluating + * a <code>new</code> expression, <code>args</code> contains the + * arguments, <code>ctorObj</code> refers to this FunctionObject, and + * <code>inNewExpr</code> is true if and only if a <code>new</code> + * expression caused the call. This supports defining a function that + * has different behavior when called as a constructor than when + * invoked as a normal function call. (For example, the Boolean + * constructor, when called as a function, + * will convert to boolean rather than creating a new object.)<p> + * + * @param name the name of the function + * @param methodOrConstructor a java.lang.reflect.Method or a java.lang.reflect.Constructor + * that defines the object + * @param scope enclosing scope of function + * @see org.mozilla.javascript.Scriptable + */ + public FunctionObject(String name, Member methodOrConstructor, + Scriptable scope) + { + if (methodOrConstructor instanceof Constructor) { + member = new MemberBox((Constructor) methodOrConstructor); + isStatic = true; // well, doesn't take a 'this' + } else { + member = new MemberBox((Method) methodOrConstructor); + isStatic = member.isStatic(); + } + String methodName = member.getName(); + this.functionName = name; + Class[] types = member.argTypes; + int arity = types.length; + if (arity == 4 && (types[1].isArray() || types[2].isArray())) { + // Either variable args or an error. + if (types[1].isArray()) { + if (!isStatic || + types[0] != ScriptRuntime.ContextClass || + types[1].getComponentType() != ScriptRuntime.ObjectClass || + types[2] != ScriptRuntime.FunctionClass || + types[3] != Boolean.TYPE) + { + throw Context.reportRuntimeError1( + "msg.varargs.ctor", methodName); + } + parmsLength = VARARGS_CTOR; + } else { + if (!isStatic || + types[0] != ScriptRuntime.ContextClass || + types[1] != ScriptRuntime.ScriptableClass || + types[2].getComponentType() != ScriptRuntime.ObjectClass || + types[3] != ScriptRuntime.FunctionClass) + { + throw Context.reportRuntimeError1( + "msg.varargs.fun", methodName); + } + parmsLength = VARARGS_METHOD; + } + } else { + parmsLength = arity; + if (arity > 0) { + typeTags = new byte[arity]; + for (int i = 0; i != arity; ++i) { + int tag = getTypeTag(types[i]); + if (tag == JAVA_UNSUPPORTED_TYPE) { + throw Context.reportRuntimeError2( + "msg.bad.parms", types[i].getName(), methodName); + } + typeTags[i] = (byte)tag; + } + } + } + + if (member.isMethod()) { + Method method = member.method(); + Class returnType = method.getReturnType(); + if (returnType == Void.TYPE) { + hasVoidReturn = true; + } else { + returnTypeTag = getTypeTag(returnType); + } + } else { + Class ctorType = member.getDeclaringClass(); + if (!ScriptRuntime.ScriptableClass.isAssignableFrom(ctorType)) { + throw Context.reportRuntimeError1( + "msg.bad.ctor.return", ctorType.getName()); + } + } + + ScriptRuntime.setFunctionProtoAndParent(this, scope); + } + + /** + * @return One of <tt>JAVA_*_TYPE</tt> constants to indicate desired type + * or {@link #JAVA_UNSUPPORTED_TYPE} if the convertion is not + * possible + */ + public static int getTypeTag(Class type) + { + if (type == ScriptRuntime.StringClass) + return JAVA_STRING_TYPE; + if (type == ScriptRuntime.IntegerClass || type == Integer.TYPE) + return JAVA_INT_TYPE; + if (type == ScriptRuntime.BooleanClass || type == Boolean.TYPE) + return JAVA_BOOLEAN_TYPE; + if (type == ScriptRuntime.DoubleClass || type == Double.TYPE) + return JAVA_DOUBLE_TYPE; + if (ScriptRuntime.ScriptableClass.isAssignableFrom(type)) + return JAVA_SCRIPTABLE_TYPE; + if (type == ScriptRuntime.ObjectClass) + return JAVA_OBJECT_TYPE; + + // Note that the long type is not supported; see the javadoc for + // the constructor for this class + + return JAVA_UNSUPPORTED_TYPE; + } + + public static Object convertArg(Context cx, Scriptable scope, + Object arg, int typeTag) + { + switch (typeTag) { + case JAVA_STRING_TYPE: + if (arg instanceof String) + return arg; + return ScriptRuntime.toString(arg); + case JAVA_INT_TYPE: + if (arg instanceof Integer) + return arg; + return new Integer(ScriptRuntime.toInt32(arg)); + case JAVA_BOOLEAN_TYPE: + if (arg instanceof Boolean) + return arg; + return ScriptRuntime.toBoolean(arg) ? Boolean.TRUE + : Boolean.FALSE; + case JAVA_DOUBLE_TYPE: + if (arg instanceof Double) + return arg; + return new Double(ScriptRuntime.toNumber(arg)); + case JAVA_SCRIPTABLE_TYPE: + if (arg instanceof Scriptable) + return arg; + return ScriptRuntime.toObject(cx, scope, arg); + case JAVA_OBJECT_TYPE: + return arg; + default: + throw new IllegalArgumentException(); + } + } + + /** + * Return the value defined by the method used to construct the object + * (number of parameters of the method, or 1 if the method is a "varargs" + * form). + */ + public int getArity() { + return parmsLength < 0 ? 1 : parmsLength; + } + + /** + * Return the same value as {@link #getArity()}. + */ + public int getLength() { + return getArity(); + } + + public String getFunctionName() + { + return (functionName == null) ? "" : functionName; + } + + /** + * Get Java method or constructor this function represent. + */ + public Member getMethodOrConstructor() + { + if (member.isMethod()) { + return member.method(); + } else { + return member.ctor(); + } + } + + static Method findSingleMethod(Method[] methods, String name) + { + Method found = null; + for (int i = 0, N = methods.length; i != N; ++i) { + Method method = methods[i]; + if (method != null && name.equals(method.getName())) { + if (found != null) { + throw Context.reportRuntimeError2( + "msg.no.overload", name, + method.getDeclaringClass().getName()); + } + found = method; + } + } + return found; + } + + /** + * Returns all public methods declared by the specified class. This excludes + * inherited methods. + * + * @param clazz the class from which to pull public declared methods + * @return the public methods declared in the specified class + * @see Class#getDeclaredMethods() + */ + static Method[] getMethodList(Class clazz) { + Method[] methods = null; + try { + // getDeclaredMethods may be rejected by the security manager + // but getMethods is more expensive + if (!sawSecurityException) + methods = clazz.getDeclaredMethods(); + } catch (SecurityException e) { + // If we get an exception once, give up on getDeclaredMethods + sawSecurityException = true; + } + if (methods == null) { + methods = clazz.getMethods(); + } + int count = 0; + for (int i=0; i < methods.length; i++) { + if (sawSecurityException + ? methods[i].getDeclaringClass() != clazz + : !Modifier.isPublic(methods[i].getModifiers())) + { + methods[i] = null; + } else { + count++; + } + } + Method[] result = new Method[count]; + int j=0; + for (int i=0; i < methods.length; i++) { + if (methods[i] != null) + result[j++] = methods[i]; + } + return result; + } + + /** + * Define this function as a JavaScript constructor. + * <p> + * Sets up the "prototype" and "constructor" properties. Also + * calls setParent and setPrototype with appropriate values. + * Then adds the function object as a property of the given scope, using + * <code>prototype.getClassName()</code> + * as the name of the property. + * + * @param scope the scope in which to define the constructor (typically + * the global object) + * @param prototype the prototype object + * @see org.mozilla.javascript.Scriptable#setParentScope + * @see org.mozilla.javascript.Scriptable#setPrototype + * @see org.mozilla.javascript.Scriptable#getClassName + */ + public void addAsConstructor(Scriptable scope, Scriptable prototype) + { + initAsConstructor(scope, prototype); + defineProperty(scope, prototype.getClassName(), + this, ScriptableObject.DONTENUM); + } + + void initAsConstructor(Scriptable scope, Scriptable prototype) + { + ScriptRuntime.setFunctionProtoAndParent(this, scope); + setImmunePrototypeProperty(prototype); + + prototype.setParentScope(this); + + defineProperty(prototype, "constructor", this, + ScriptableObject.DONTENUM | + ScriptableObject.PERMANENT | + ScriptableObject.READONLY); + setParentScope(scope); + } + + /** + * @deprecated Use {@link #getTypeTag(Class)} + * and {@link #convertArg(Context, Scriptable, Object, int)} + * for type convertion. + */ + public static Object convertArg(Context cx, Scriptable scope, + Object arg, Class desired) + { + int tag = getTypeTag(desired); + if (tag == JAVA_UNSUPPORTED_TYPE) { + throw Context.reportRuntimeError1 + ("msg.cant.convert", desired.getName()); + } + return convertArg(cx, scope, arg, tag); + } + + /** + * Performs conversions on argument types if needed and + * invokes the underlying Java method or constructor. + * <p> + * Implements Function.call. + * + * @see org.mozilla.javascript.Function#call( + * Context, Scriptable, Scriptable, Object[]) + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + Object result; + boolean checkMethodResult = false; + + if (parmsLength < 0) { + if (parmsLength == VARARGS_METHOD) { + Object[] invokeArgs = { cx, thisObj, args, this }; + result = member.invoke(null, invokeArgs); + checkMethodResult = true; + } else { + boolean inNewExpr = (thisObj == null); + Boolean b = inNewExpr ? Boolean.TRUE : Boolean.FALSE; + Object[] invokeArgs = { cx, args, this, b }; + result = (member.isCtor()) + ? member.newInstance(invokeArgs) + : member.invoke(null, invokeArgs); + } + + } else { + if (!isStatic) { + Class clazz = member.getDeclaringClass(); + if (!clazz.isInstance(thisObj)) { + boolean compatible = false; + if (thisObj == scope) { + Scriptable parentScope = getParentScope(); + if (scope != parentScope) { + // Call with dynamic scope for standalone function, + // use parentScope as thisObj + compatible = clazz.isInstance(parentScope); + if (compatible) { + thisObj = parentScope; + } + } + } + if (!compatible) { + // Couldn't find an object to call this on. + throw ScriptRuntime.typeError1("msg.incompat.call", + functionName); + } + } + } + + Object[] invokeArgs; + if (parmsLength == args.length) { + // Do not allocate new argument array if java arguments are + // the same as the original js ones. + invokeArgs = args; + for (int i = 0; i != parmsLength; ++i) { + Object arg = args[i]; + Object converted = convertArg(cx, scope, arg, typeTags[i]); + if (arg != converted) { + if (invokeArgs == args) { + invokeArgs = args.clone(); + } + invokeArgs[i] = converted; + } + } + } else if (parmsLength == 0) { + invokeArgs = ScriptRuntime.emptyArgs; + } else { + invokeArgs = new Object[parmsLength]; + for (int i = 0; i != parmsLength; ++i) { + Object arg = (i < args.length) + ? args[i] + : Undefined.instance; + invokeArgs[i] = convertArg(cx, scope, arg, typeTags[i]); + } + } + + if (member.isMethod()) { + result = member.invoke(thisObj, invokeArgs); + checkMethodResult = true; + } else { + result = member.newInstance(invokeArgs); + } + + } + + if (checkMethodResult) { + if (hasVoidReturn) { + result = Undefined.instance; + } else if (returnTypeTag == JAVA_UNSUPPORTED_TYPE) { + result = cx.getWrapFactory().wrap(cx, scope, result, null); + } + // XXX: the code assumes that if returnTypeTag == JAVA_OBJECT_TYPE + // then the Java method did a proper job of converting the + // result to JS primitive or Scriptable to avoid + // potentially costly Context.javaToJS call. + } + + return result; + } + + /** + * Return new {@link Scriptable} instance using the default + * constructor for the class of the underlying Java method. + * Return null to indicate that the call method should be used to create + * new objects. + */ + public Scriptable createObject(Context cx, Scriptable scope) { + if (member.isCtor() || parmsLength == VARARGS_CTOR) { + return null; + } + Scriptable result; + try { + result = (Scriptable) member.getDeclaringClass().newInstance(); + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + + result.setPrototype(getClassPrototype()); + result.setParentScope(getParentScope()); + return result; + } + + boolean isVarArgsMethod() { + return parmsLength == VARARGS_METHOD; + } + + boolean isVarArgsConstructor() { + return parmsLength == VARARGS_CTOR; + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + if (parmsLength > 0) { + Class[] types = member.argTypes; + typeTags = new byte[parmsLength]; + for (int i = 0; i != parmsLength; ++i) { + typeTags[i] = (byte)getTypeTag(types[i]); + } + } + if (member.isMethod()) { + Method method = member.method(); + Class returnType = method.getReturnType(); + if (returnType == Void.TYPE) { + hasVoidReturn = true; + } else { + returnTypeTag = getTypeTag(returnType); + } + } + } + + private static final short VARARGS_METHOD = -1; + private static final short VARARGS_CTOR = -2; + + private static boolean sawSecurityException; + + public static final int JAVA_UNSUPPORTED_TYPE = 0; + public static final int JAVA_STRING_TYPE = 1; + public static final int JAVA_INT_TYPE = 2; + public static final int JAVA_BOOLEAN_TYPE = 3; + public static final int JAVA_DOUBLE_TYPE = 4; + public static final int JAVA_SCRIPTABLE_TYPE = 5; + public static final int JAVA_OBJECT_TYPE = 6; + + MemberBox member; + private String functionName; + private transient byte[] typeTags; + private int parmsLength; + private transient boolean hasVoidReturn; + private transient int returnTypeTag; + private boolean isStatic; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/GeneratedClassLoader.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/GeneratedClassLoader.java new file mode 100644 index 0000000..0f73615 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/GeneratedClassLoader.java @@ -0,0 +1,66 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Interface to define classes from generated byte code. + */ +public interface GeneratedClassLoader { + + /** + * Define a new Java class. + * Classes created via this method should have the same class loader. + * + * @param name fully qualified class name + * @param data class byte code + * @return new class object + */ + public Class defineClass(String name, byte[] data); + + /** + * Link the given class. + * + * @param cl Class instance returned from the previous call to + * {@link #defineClass(String, byte[])} + * @see java.lang.ClassLoader + */ + public void linkClass(Class cl); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IRFactory.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IRFactory.java new file mode 100644 index 0000000..1f51cb1 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IRFactory.java @@ -0,0 +1,1607 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Ethan Hugg + * Bob Jervis + * Terry Lucas + * Milen Nankov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.List; +import java.util.ArrayList; + +/** + * This class allows the creation of nodes, and follows the Factory pattern. + * + * @see Node + * @author Mike McCabe + * @author Norris Boyd + */ +final class IRFactory +{ + IRFactory(Parser parser) + { + this.parser = parser; + } + + ScriptOrFnNode createScript() + { + return new ScriptOrFnNode(Token.SCRIPT); + } + + /** + * Script (for associating file/url names with toplevel scripts.) + */ + void initScript(ScriptOrFnNode scriptNode, Node body) + { + Node children = body.getFirstChild(); + if (children != null) { scriptNode.addChildrenToBack(children); } + } + + /** + * Leaf + */ + Node createLeaf(int nodeType) + { + return new Node(nodeType); + } + + /** + * Statement leaf nodes. + */ + + Node createSwitch(Node expr, int lineno) + { + // + // The switch will be rewritten from: + // + // switch (expr) { + // case test1: statements1; + // ... + // default: statementsDefault; + // ... + // case testN: statementsN; + // } + // + // to: + // + // { + // switch (expr) { + // case test1: goto label1; + // ... + // case testN: goto labelN; + // } + // goto labelDefault; + // label1: + // statements1; + // ... + // labelDefault: + // statementsDefault; + // ... + // labelN: + // statementsN; + // breakLabel: + // } + // + // where inside switch each "break;" without label will be replaced + // by "goto breakLabel". + // + // If the original switch does not have the default label, then + // the transformed code would contain after the switch instead of + // goto labelDefault; + // the following goto: + // goto breakLabel; + // + + Node.Jump switchNode = new Node.Jump(Token.SWITCH, expr, lineno); + Node block = new Node(Token.BLOCK, switchNode); + return block; + } + + /** + * If caseExpression argument is null it indicate default label. + */ + void addSwitchCase(Node switchBlock, Node caseExpression, Node statements) + { + if (switchBlock.getType() != Token.BLOCK) throw Kit.codeBug(); + Node.Jump switchNode = (Node.Jump)switchBlock.getFirstChild(); + if (switchNode.getType() != Token.SWITCH) throw Kit.codeBug(); + + Node gotoTarget = Node.newTarget(); + if (caseExpression != null) { + Node.Jump caseNode = new Node.Jump(Token.CASE, caseExpression); + caseNode.target = gotoTarget; + switchNode.addChildToBack(caseNode); + } else { + switchNode.setDefault(gotoTarget); + } + switchBlock.addChildToBack(gotoTarget); + switchBlock.addChildToBack(statements); + } + + void closeSwitch(Node switchBlock) + { + if (switchBlock.getType() != Token.BLOCK) throw Kit.codeBug(); + Node.Jump switchNode = (Node.Jump)switchBlock.getFirstChild(); + if (switchNode.getType() != Token.SWITCH) throw Kit.codeBug(); + + Node switchBreakTarget = Node.newTarget(); + // switchNode.target is only used by NodeTransformer + // to detect switch end + switchNode.target = switchBreakTarget; + + Node defaultTarget = switchNode.getDefault(); + if (defaultTarget == null) { + defaultTarget = switchBreakTarget; + } + + switchBlock.addChildAfter(makeJump(Token.GOTO, defaultTarget), + switchNode); + switchBlock.addChildToBack(switchBreakTarget); + } + + Node createVariables(int token, int lineno) + { + return new Node(token, lineno); + } + + Node createExprStatement(Node expr, int lineno) + { + int type; + if (parser.insideFunction()) { + type = Token.EXPR_VOID; + } else { + type = Token.EXPR_RESULT; + } + return new Node(type, expr, lineno); + } + + Node createExprStatementNoReturn(Node expr, int lineno) + { + return new Node(Token.EXPR_VOID, expr, lineno); + } + + Node createDefaultNamespace(Node expr, int lineno) + { + // default xml namespace requires activation + setRequiresActivation(); + Node n = createUnary(Token.DEFAULTNAMESPACE, expr); + Node result = createExprStatement(n, lineno); + return result; + } + + /** + * Name + */ + Node createName(String name) + { + checkActivationName(name, Token.NAME); + return Node.newString(Token.NAME, name); + } + + private Node createName(int type, String name, Node child) + { + Node result = createName(name); + result.setType(type); + if (child != null) + result.addChildToBack(child); + return result; + } + + /** + * String (for literals) + */ + Node createString(String string) + { + return Node.newString(string); + } + + /** + * Number (for literals) + */ + Node createNumber(double number) + { + return Node.newNumber(number); + } + + /** + * Catch clause of try/catch/finally + * @param varName the name of the variable to bind to the exception + * @param catchCond the condition under which to catch the exception. + * May be null if no condition is given. + * @param stmts the statements in the catch clause + * @param lineno the starting line number of the catch clause + */ + Node createCatch(String varName, Node catchCond, Node stmts, int lineno) + { + if (catchCond == null) { + catchCond = new Node(Token.EMPTY); + } + return new Node(Token.CATCH, createName(varName), + catchCond, stmts, lineno); + } + + /** + * Throw + */ + Node createThrow(Node expr, int lineno) + { + return new Node(Token.THROW, expr, lineno); + } + + /** + * Return + */ + Node createReturn(Node expr, int lineno) + { + return expr == null + ? new Node(Token.RETURN, lineno) + : new Node(Token.RETURN, expr, lineno); + } + + /** + * Debugger + */ + Node createDebugger(int lineno) + { + return new Node(Token.DEBUGGER, lineno); + } + + /** + * Label + */ + Node createLabel(int lineno) + { + return new Node.Jump(Token.LABEL, lineno); + } + + Node getLabelLoop(Node label) + { + return ((Node.Jump)label).getLoop(); + } + + /** + * Label + */ + Node createLabeledStatement(Node labelArg, Node statement) + { + Node.Jump label = (Node.Jump)labelArg; + + // Make a target and put it _after_ the statement + // node. And in the LABEL node, so breaks get the + // right target. + + Node breakTarget = Node.newTarget(); + Node block = new Node(Token.BLOCK, label, statement, breakTarget); + label.target = breakTarget; + + return block; + } + + /** + * Break (possibly labeled) + */ + Node createBreak(Node breakStatement, int lineno) + { + Node.Jump n = new Node.Jump(Token.BREAK, lineno); + Node.Jump jumpStatement; + int t = breakStatement.getType(); + if (t == Token.LOOP || t == Token.LABEL) { + jumpStatement = (Node.Jump)breakStatement; + } else if (t == Token.BLOCK + && breakStatement.getFirstChild().getType() == Token.SWITCH) + { + jumpStatement = (Node.Jump)breakStatement.getFirstChild(); + } else { + throw Kit.codeBug(); + } + n.setJumpStatement(jumpStatement); + return n; + } + + /** + * Continue (possibly labeled) + */ + Node createContinue(Node loop, int lineno) + { + if (loop.getType() != Token.LOOP) Kit.codeBug(); + Node.Jump n = new Node.Jump(Token.CONTINUE, lineno); + n.setJumpStatement((Node.Jump)loop); + return n; + } + + /** + * Statement block + * Creates the empty statement block + * Must make subsequent calls to add statements to the node + */ + Node createBlock(int lineno) + { + return new Node(Token.BLOCK, lineno); + } + + FunctionNode createFunction(String name) + { + return new FunctionNode(name); + } + + Node initFunction(FunctionNode fnNode, int functionIndex, + Node statements, int functionType) + { + fnNode.itsFunctionType = functionType; + fnNode.addChildToBack(statements); + + int functionCount = fnNode.getFunctionCount(); + if (functionCount != 0) { + // Functions containing other functions require activation objects + fnNode.itsNeedsActivation = true; + } + + if (functionType == FunctionNode.FUNCTION_EXPRESSION) { + String name = fnNode.getFunctionName(); + if (name != null && name.length() != 0) { + // A function expression needs to have its name as a + // variable (if it isn't already allocated as a variable). + // See ECMA Ch. 13. We add code to the beginning of the + // function to initialize a local variable of the + // function's name to the function value. + Node setFn = new Node(Token.EXPR_VOID, + new Node(Token.SETNAME, + Node.newString(Token.BINDNAME, name), + new Node(Token.THISFN))); + statements.addChildrenToFront(setFn); + } + } + + // Add return to end if needed. + Node lastStmt = statements.getLastChild(); + if (lastStmt == null || lastStmt.getType() != Token.RETURN) { + statements.addChildToBack(new Node(Token.RETURN)); + } + + Node result = Node.newString(Token.FUNCTION, + fnNode.getFunctionName()); + result.putIntProp(Node.FUNCTION_PROP, functionIndex); + return result; + } + + /** + * Add a child to the back of the given node. This function + * breaks the Factory abstraction, but it removes a requirement + * from implementors of Node. + */ + void addChildToBack(Node parent, Node child) + { + parent.addChildToBack(child); + } + + /** + * Create a node that can be used to hold lexically scoped variable + * definitions (via let declarations). + * + * @param token the token of the node to create + * @param lineno line number of source + * @return the created node + */ + Node createScopeNode(int token, int lineno) { + return new Node.Scope(token, lineno); + } + + /** + * Create loop node. The parser will later call + * createWhile|createDoWhile|createFor|createForIn + * to finish loop generation. + */ + Node createLoopNode(Node loopLabel, int lineno) + { + Node.Jump result = new Node.Scope(Token.LOOP, lineno); + if (loopLabel != null) { + ((Node.Jump)loopLabel).setLoop(result); + } + return result; + } + + /** + * While + */ + Node createWhile(Node loop, Node cond, Node body) + { + return createLoop((Node.Jump)loop, LOOP_WHILE, body, cond, + null, null); + } + + /** + * DoWhile + */ + Node createDoWhile(Node loop, Node body, Node cond) + { + return createLoop((Node.Jump)loop, LOOP_DO_WHILE, body, cond, + null, null); + } + + /** + * For + */ + Node createFor(Node loop, Node init, Node test, Node incr, Node body) + { + if (init.getType() == Token.LET) { + // rewrite "for (let i=s; i < N; i++)..." as + // "let (i=s) { for (; i < N; i++)..." so that "s" is evaluated + // outside the scope of the for. + Node.Scope let = Node.Scope.splitScope((Node.Scope)loop); + let.setType(Token.LET); + let.addChildrenToBack(init); + let.addChildToBack(createLoop((Node.Jump)loop, LOOP_FOR, body, test, + new Node(Token.EMPTY), incr)); + return let; + } + return createLoop((Node.Jump)loop, LOOP_FOR, body, test, init, incr); + } + + private Node createLoop(Node.Jump loop, int loopType, Node body, Node cond, + Node init, Node incr) + { + Node bodyTarget = Node.newTarget(); + Node condTarget = Node.newTarget(); + if (loopType == LOOP_FOR && cond.getType() == Token.EMPTY) { + cond = new Node(Token.TRUE); + } + Node.Jump IFEQ = new Node.Jump(Token.IFEQ, cond); + IFEQ.target = bodyTarget; + Node breakTarget = Node.newTarget(); + + loop.addChildToBack(bodyTarget); + loop.addChildrenToBack(body); + if (loopType == LOOP_WHILE || loopType == LOOP_FOR) { + // propagate lineno to condition + loop.addChildrenToBack(new Node(Token.EMPTY, loop.getLineno())); + } + loop.addChildToBack(condTarget); + loop.addChildToBack(IFEQ); + loop.addChildToBack(breakTarget); + + loop.target = breakTarget; + Node continueTarget = condTarget; + + if (loopType == LOOP_WHILE || loopType == LOOP_FOR) { + // Just add a GOTO to the condition in the do..while + loop.addChildToFront(makeJump(Token.GOTO, condTarget)); + + if (loopType == LOOP_FOR) { + int initType = init.getType(); + if (initType != Token.EMPTY) { + if (initType != Token.VAR && initType != Token.LET) { + init = new Node(Token.EXPR_VOID, init); + } + loop.addChildToFront(init); + } + Node incrTarget = Node.newTarget(); + loop.addChildAfter(incrTarget, body); + if (incr.getType() != Token.EMPTY) { + incr = new Node(Token.EXPR_VOID, incr); + loop.addChildAfter(incr, incrTarget); + } + continueTarget = incrTarget; + } + } + + loop.setContinue(continueTarget); + + return loop; + } + + /** + * For .. In + * + */ + Node createForIn(int declType, Node loop, Node lhs, Node obj, Node body, + boolean isForEach) + { + int destructuring = -1; + int destructuringLen = 0; + Node lvalue; + int type = lhs.getType(); + if (type == Token.VAR || type == Token.LET) { + Node lastChild = lhs.getLastChild(); + if (lhs.getFirstChild() != lastChild) { + /* + * check that there was only one variable given. + * we can't do this in the parser, because then the + * parser would have to know something about the + * 'init' node of the for-in loop. + */ + parser.reportError("msg.mult.index"); + } + if (lastChild.getType() == Token.ARRAYLIT || + lastChild.getType() == Token.OBJECTLIT) + { + type = destructuring = lastChild.getType(); + lvalue = lastChild; + destructuringLen = lastChild.getIntProp( + Node.DESTRUCTURING_ARRAY_LENGTH, 0); + } else if (lastChild.getType() == Token.NAME) { + lvalue = Node.newString(Token.NAME, lastChild.getString()); + } else { + parser.reportError("msg.bad.for.in.lhs"); + return obj; + } + } else if (type == Token.ARRAYLIT || type == Token.OBJECTLIT) { + destructuring = type; + lvalue = lhs; + destructuringLen = lhs.getIntProp(Node.DESTRUCTURING_ARRAY_LENGTH, 0); + } else { + lvalue = makeReference(lhs); + if (lvalue == null) { + parser.reportError("msg.bad.for.in.lhs"); + return obj; + } + } + + Node localBlock = new Node(Token.LOCAL_BLOCK); + int initType = (isForEach) ? Token.ENUM_INIT_VALUES : + (destructuring != -1) ? Token.ENUM_INIT_ARRAY : + Token.ENUM_INIT_KEYS; + Node init = new Node(initType, obj); + init.putProp(Node.LOCAL_BLOCK_PROP, localBlock); + Node cond = new Node(Token.ENUM_NEXT); + cond.putProp(Node.LOCAL_BLOCK_PROP, localBlock); + Node id = new Node(Token.ENUM_ID); + id.putProp(Node.LOCAL_BLOCK_PROP, localBlock); + + Node newBody = new Node(Token.BLOCK); + Node assign; + if (destructuring != -1) { + assign = createDestructuringAssignment(declType, lvalue, id); + if (!isForEach && (destructuring == Token.OBJECTLIT || + destructuringLen != 2)) + { + // destructuring assignment is only allowed in for..each or + // with an array type of length 2 (to hold key and value) + parser.reportError("msg.bad.for.in.destruct"); + } + } else { + assign = simpleAssignment(lvalue, id); + } + newBody.addChildToBack(new Node(Token.EXPR_VOID, assign)); + newBody.addChildToBack(body); + + loop = createWhile(loop, cond, newBody); + loop.addChildToFront(init); + if (type == Token.VAR || type == Token.LET) + loop.addChildToFront(lhs); + localBlock.addChildToBack(loop); + + return localBlock; + } + + /** + * Try/Catch/Finally + * + * The IRFactory tries to express as much as possible in the tree; + * the responsibilities remaining for Codegen are to add the Java + * handlers: (Either (but not both) of TARGET and FINALLY might not + * be defined) + + * - a catch handler for javascript exceptions that unwraps the + * exception onto the stack and GOTOes to the catch target + + * - a finally handler + + * ... and a goto to GOTO around these handlers. + */ + Node createTryCatchFinally(Node tryBlock, Node catchBlocks, + Node finallyBlock, int lineno) + { + boolean hasFinally = (finallyBlock != null) + && (finallyBlock.getType() != Token.BLOCK + || finallyBlock.hasChildren()); + + // short circuit + if (tryBlock.getType() == Token.BLOCK && !tryBlock.hasChildren() + && !hasFinally) + { + return tryBlock; + } + + boolean hasCatch = catchBlocks.hasChildren(); + + // short circuit + if (!hasFinally && !hasCatch) { + // bc finally might be an empty block... + return tryBlock; + } + + + Node handlerBlock = new Node(Token.LOCAL_BLOCK); + Node.Jump pn = new Node.Jump(Token.TRY, tryBlock, lineno); + pn.putProp(Node.LOCAL_BLOCK_PROP, handlerBlock); + + if (hasCatch) { + // jump around catch code + Node endCatch = Node.newTarget(); + pn.addChildToBack(makeJump(Token.GOTO, endCatch)); + + // make a TARGET for the catch that the tcf node knows about + Node catchTarget = Node.newTarget(); + pn.target = catchTarget; + // mark it + pn.addChildToBack(catchTarget); + + // + // Given + // + // try { + // tryBlock; + // } catch (e if condition1) { + // something1; + // ... + // + // } catch (e if conditionN) { + // somethingN; + // } catch (e) { + // somethingDefault; + // } + // + // rewrite as + // + // try { + // tryBlock; + // goto after_catch: + // } catch (x) { + // with (newCatchScope(e, x)) { + // if (condition1) { + // something1; + // goto after_catch; + // } + // } + // ... + // with (newCatchScope(e, x)) { + // if (conditionN) { + // somethingN; + // goto after_catch; + // } + // } + // with (newCatchScope(e, x)) { + // somethingDefault; + // goto after_catch; + // } + // } + // after_catch: + // + // If there is no default catch, then the last with block + // arround "somethingDefault;" is replaced by "rethrow;" + + // It is assumed that catch handler generation will store + // exeception object in handlerBlock register + + // Block with local for exception scope objects + Node catchScopeBlock = new Node(Token.LOCAL_BLOCK); + + // expects catchblocks children to be (cond block) pairs. + Node cb = catchBlocks.getFirstChild(); + boolean hasDefault = false; + int scopeIndex = 0; + while (cb != null) { + int catchLineNo = cb.getLineno(); + + Node name = cb.getFirstChild(); + Node cond = name.getNext(); + Node catchStatement = cond.getNext(); + cb.removeChild(name); + cb.removeChild(cond); + cb.removeChild(catchStatement); + + // Add goto to the catch statement to jump out of catch + // but prefix it with LEAVEWITH since try..catch produces + // "with"code in order to limit the scope of the exception + // object. + catchStatement.addChildToBack(new Node(Token.LEAVEWITH)); + catchStatement.addChildToBack(makeJump(Token.GOTO, endCatch)); + + // Create condition "if" when present + Node condStmt; + if (cond.getType() == Token.EMPTY) { + condStmt = catchStatement; + hasDefault = true; + } else { + condStmt = createIf(cond, catchStatement, null, + catchLineNo); + } + + // Generate code to create the scope object and store + // it in catchScopeBlock register + Node catchScope = new Node(Token.CATCH_SCOPE, name, + createUseLocal(handlerBlock)); + catchScope.putProp(Node.LOCAL_BLOCK_PROP, catchScopeBlock); + catchScope.putIntProp(Node.CATCH_SCOPE_PROP, scopeIndex); + catchScopeBlock.addChildToBack(catchScope); + + // Add with statement based on catch scope object + catchScopeBlock.addChildToBack( + createWith(createUseLocal(catchScopeBlock), condStmt, + catchLineNo)); + + // move to next cb + cb = cb.getNext(); + ++scopeIndex; + } + pn.addChildToBack(catchScopeBlock); + if (!hasDefault) { + // Generate code to rethrow if no catch clause was executed + Node rethrow = new Node(Token.RETHROW); + rethrow.putProp(Node.LOCAL_BLOCK_PROP, handlerBlock); + pn.addChildToBack(rethrow); + } + + pn.addChildToBack(endCatch); + } + + if (hasFinally) { + Node finallyTarget = Node.newTarget(); + pn.setFinally(finallyTarget); + + // add jsr finally to the try block + pn.addChildToBack(makeJump(Token.JSR, finallyTarget)); + + // jump around finally code + Node finallyEnd = Node.newTarget(); + pn.addChildToBack(makeJump(Token.GOTO, finallyEnd)); + + pn.addChildToBack(finallyTarget); + Node fBlock = new Node(Token.FINALLY, finallyBlock); + fBlock.putProp(Node.LOCAL_BLOCK_PROP, handlerBlock); + pn.addChildToBack(fBlock); + + pn.addChildToBack(finallyEnd); + } + handlerBlock.addChildToBack(pn); + return handlerBlock; + } + + /** + * Throw, Return, Label, Break and Continue are defined in ASTFactory. + */ + + /** + * With + */ + Node createWith(Node obj, Node body, int lineno) + { + setRequiresActivation(); + Node result = new Node(Token.BLOCK, lineno); + result.addChildToBack(new Node(Token.ENTERWITH, obj)); + Node bodyNode = new Node(Token.WITH, body, lineno); + result.addChildrenToBack(bodyNode); + result.addChildToBack(new Node(Token.LEAVEWITH)); + return result; + } + + /** + * DOTQUERY + */ + public Node createDotQuery (Node obj, Node body, int lineno) + { + setRequiresActivation(); + Node result = new Node(Token.DOTQUERY, obj, body, lineno); + return result; + } + + Node createArrayLiteral(ObjArray elems, int skipCount, int destructuringLen) + { + int length = elems.size(); + int[] skipIndexes = null; + if (skipCount != 0) { + skipIndexes = new int[skipCount]; + } + Node array = new Node(Token.ARRAYLIT); + for (int i = 0, j = 0; i != length; ++i) { + Node elem = (Node)elems.get(i); + if (elem != null) { + array.addChildToBack(elem); + } else { + skipIndexes[j] = i; + ++j; + } + } + if (skipCount != 0) { + array.putProp(Node.SKIP_INDEXES_PROP, skipIndexes); + } + array.putIntProp(Node.DESTRUCTURING_ARRAY_LENGTH, destructuringLen); + return array; + } + + /** + * Object Literals + * <BR> createObjectLiteral rewrites its argument as object + * creation plus object property entries, so later compiler + * stages don't need to know about object literals. + */ + Node createObjectLiteral(ObjArray elems) + { + int size = elems.size() / 2; + Node object = new Node(Token.OBJECTLIT); + Object[] properties; + if (size == 0) { + properties = ScriptRuntime.emptyArgs; + } else { + properties = new Object[size]; + for (int i = 0; i != size; ++i) { + properties[i] = elems.get(2 * i); + Node value = (Node)elems.get(2 * i + 1); + object.addChildToBack(value); + } + } + object.putProp(Node.OBJECT_IDS_PROP, properties); + return object; + } + + /** + * Regular expressions + */ + Node createRegExp(int regexpIndex) + { + Node n = new Node(Token.REGEXP); + n.putIntProp(Node.REGEXP_PROP, regexpIndex); + return n; + } + + /** + * If statement + */ + Node createIf(Node cond, Node ifTrue, Node ifFalse, int lineno) + { + int condStatus = isAlwaysDefinedBoolean(cond); + if (condStatus == ALWAYS_TRUE_BOOLEAN) { + return ifTrue; + } else if (condStatus == ALWAYS_FALSE_BOOLEAN) { + if (ifFalse != null) { + return ifFalse; + } + // Replace if (false) xxx by empty block + return new Node(Token.BLOCK, lineno); + } + + Node result = new Node(Token.BLOCK, lineno); + Node ifNotTarget = Node.newTarget(); + Node.Jump IFNE = new Node.Jump(Token.IFNE, cond); + IFNE.target = ifNotTarget; + + result.addChildToBack(IFNE); + result.addChildrenToBack(ifTrue); + + if (ifFalse != null) { + Node endTarget = Node.newTarget(); + result.addChildToBack(makeJump(Token.GOTO, endTarget)); + result.addChildToBack(ifNotTarget); + result.addChildrenToBack(ifFalse); + result.addChildToBack(endTarget); + } else { + result.addChildToBack(ifNotTarget); + } + + return result; + } + + Node createCondExpr(Node cond, Node ifTrue, Node ifFalse) + { + int condStatus = isAlwaysDefinedBoolean(cond); + if (condStatus == ALWAYS_TRUE_BOOLEAN) { + return ifTrue; + } else if (condStatus == ALWAYS_FALSE_BOOLEAN) { + return ifFalse; + } + return new Node(Token.HOOK, cond, ifTrue, ifFalse); + } + + /** + * Unary + */ + Node createUnary(int nodeType, Node child) + { + int childType = child.getType(); + switch (nodeType) { + case Token.DELPROP: { + Node n; + if (childType == Token.NAME) { + // Transform Delete(Name "a") + // to Delete(Bind("a"), String("a")) + child.setType(Token.BINDNAME); + Node left = child; + Node right = Node.newString(child.getString()); + n = new Node(nodeType, left, right); + } else if (childType == Token.GETPROP || + childType == Token.GETELEM) + { + Node left = child.getFirstChild(); + Node right = child.getLastChild(); + child.removeChild(left); + child.removeChild(right); + n = new Node(nodeType, left, right); + } else if (childType == Token.GET_REF) { + Node ref = child.getFirstChild(); + child.removeChild(ref); + n = new Node(Token.DEL_REF, ref); + } else { + n = new Node(Token.TRUE); + } + return n; + } + case Token.TYPEOF: + if (childType == Token.NAME) { + child.setType(Token.TYPEOFNAME); + return child; + } + break; + case Token.BITNOT: + if (childType == Token.NUMBER) { + int value = ScriptRuntime.toInt32(child.getDouble()); + child.setDouble(~value); + return child; + } + break; + case Token.NEG: + if (childType == Token.NUMBER) { + child.setDouble(-child.getDouble()); + return child; + } + break; + case Token.NOT: { + int status = isAlwaysDefinedBoolean(child); + if (status != 0) { + int type; + if (status == ALWAYS_TRUE_BOOLEAN) { + type = Token.FALSE; + } else { + type = Token.TRUE; + } + if (childType == Token.TRUE || childType == Token.FALSE) { + child.setType(type); + return child; + } + return new Node(type); + } + break; + } + } + return new Node(nodeType, child); + } + + Node createYield(Node child, int lineno) + { + if (!parser.insideFunction()) { + parser.reportError("msg.bad.yield"); + } + setRequiresActivation(); + setIsGenerator(); + if (child != null) + return new Node(Token.YIELD, child, lineno); + else + return new Node(Token.YIELD, lineno); + } + + Node createCallOrNew(int nodeType, Node child) + { + int type = Node.NON_SPECIALCALL; + if (child.getType() == Token.NAME) { + String name = child.getString(); + if (name.equals("eval")) { + type = Node.SPECIALCALL_EVAL; + } else if (name.equals("With")) { + type = Node.SPECIALCALL_WITH; + } + } else if (child.getType() == Token.GETPROP) { + String name = child.getLastChild().getString(); + if (name.equals("eval")) { + type = Node.SPECIALCALL_EVAL; + } + } + Node node = new Node(nodeType, child); + if (type != Node.NON_SPECIALCALL) { + // Calls to these functions require activation objects. + setRequiresActivation(); + node.putIntProp(Node.SPECIALCALL_PROP, type); + } + return node; + } + + Node createIncDec(int nodeType, boolean post, Node child) + { + child = makeReference(child); + if (child == null) { + String msg; + if (nodeType == Token.DEC) { + msg = "msg.bad.decr"; + } else { + msg = "msg.bad.incr"; + } + parser.reportError(msg); + return null; + } + + int childType = child.getType(); + + switch (childType) { + case Token.NAME: + case Token.GETPROP: + case Token.GETELEM: + case Token.GET_REF: { + Node n = new Node(nodeType, child); + int incrDecrMask = 0; + if (nodeType == Token.DEC) { + incrDecrMask |= Node.DECR_FLAG; + } + if (post) { + incrDecrMask |= Node.POST_FLAG; + } + n.putIntProp(Node.INCRDECR_PROP, incrDecrMask); + return n; + } + } + throw Kit.codeBug(); + } + + Node createPropertyGet(Node target, String namespace, String name, + int memberTypeFlags) + { + if (namespace == null && memberTypeFlags == 0) { + if (target == null) { + return createName(name); + } + checkActivationName(name, Token.GETPROP); + if (ScriptRuntime.isSpecialProperty(name)) { + Node ref = new Node(Token.REF_SPECIAL, target); + ref.putProp(Node.NAME_PROP, name); + return new Node(Token.GET_REF, ref); + } + return new Node(Token.GETPROP, target, createString(name)); + } + Node elem = createString(name); + memberTypeFlags |= Node.PROPERTY_FLAG; + return createMemberRefGet(target, namespace, elem, memberTypeFlags); + } + + Node createElementGet(Node target, String namespace, Node elem, + int memberTypeFlags) + { + // OPT: could optimize to createPropertyGet + // iff elem is string that can not be number + if (namespace == null && memberTypeFlags == 0) { + // stand-alone [aaa] as primary expression is array literal + // declaration and should not come here! + if (target == null) throw Kit.codeBug(); + return new Node(Token.GETELEM, target, elem); + } + return createMemberRefGet(target, namespace, elem, memberTypeFlags); + } + + private Node createMemberRefGet(Node target, String namespace, Node elem, + int memberTypeFlags) + { + Node nsNode = null; + if (namespace != null) { + // See 11.1.2 in ECMA 357 + if (namespace.equals("*")) { + nsNode = new Node(Token.NULL); + } else { + nsNode = createName(namespace); + } + } + Node ref; + if (target == null) { + if (namespace == null) { + ref = new Node(Token.REF_NAME, elem); + } else { + ref = new Node(Token.REF_NS_NAME, nsNode, elem); + } + } else { + if (namespace == null) { + ref = new Node(Token.REF_MEMBER, target, elem); + } else { + ref = new Node(Token.REF_NS_MEMBER, target, nsNode, elem); + } + } + if (memberTypeFlags != 0) { + ref.putIntProp(Node.MEMBER_TYPE_PROP, memberTypeFlags); + } + return new Node(Token.GET_REF, ref); + } + + /** + * Binary + */ + Node createBinary(int nodeType, Node left, Node right) + { + switch (nodeType) { + + case Token.ADD: + // numerical addition and string concatenation + if (left.type == Token.STRING) { + String s2; + if (right.type == Token.STRING) { + s2 = right.getString(); + } else if (right.type == Token.NUMBER) { + s2 = ScriptRuntime.numberToString(right.getDouble(), 10); + } else { + break; + } + String s1 = left.getString(); + left.setString(s1.concat(s2)); + return left; + } else if (left.type == Token.NUMBER) { + if (right.type == Token.NUMBER) { + left.setDouble(left.getDouble() + right.getDouble()); + return left; + } else if (right.type == Token.STRING) { + String s1, s2; + s1 = ScriptRuntime.numberToString(left.getDouble(), 10); + s2 = right.getString(); + right.setString(s1.concat(s2)); + return right; + } + } + // can't do anything if we don't know both types - since + // 0 + object is supposed to call toString on the object and do + // string concantenation rather than addition + break; + + case Token.SUB: + // numerical subtraction + if (left.type == Token.NUMBER) { + double ld = left.getDouble(); + if (right.type == Token.NUMBER) { + //both numbers + left.setDouble(ld - right.getDouble()); + return left; + } else if (ld == 0.0) { + // first 0: 0-x -> -x + return new Node(Token.NEG, right); + } + } else if (right.type == Token.NUMBER) { + if (right.getDouble() == 0.0) { + //second 0: x - 0 -> +x + // can not make simply x because x - 0 must be number + return new Node(Token.POS, left); + } + } + break; + + case Token.MUL: + // numerical multiplication + if (left.type == Token.NUMBER) { + double ld = left.getDouble(); + if (right.type == Token.NUMBER) { + //both numbers + left.setDouble(ld * right.getDouble()); + return left; + } else if (ld == 1.0) { + // first 1: 1 * x -> +x + return new Node(Token.POS, right); + } + } else if (right.type == Token.NUMBER) { + if (right.getDouble() == 1.0) { + //second 1: x * 1 -> +x + // can not make simply x because x - 0 must be number + return new Node(Token.POS, left); + } + } + // can't do x*0: Infinity * 0 gives NaN, not 0 + break; + + case Token.DIV: + // number division + if (right.type == Token.NUMBER) { + double rd = right.getDouble(); + if (left.type == Token.NUMBER) { + // both constants -- just divide, trust Java to handle x/0 + left.setDouble(left.getDouble() / rd); + return left; + } else if (rd == 1.0) { + // second 1: x/1 -> +x + // not simply x to force number convertion + return new Node(Token.POS, left); + } + } + break; + + case Token.AND: { + // Since x && y gives x, not false, when Boolean(x) is false, + // and y, not Boolean(y), when Boolean(x) is true, x && y + // can only be simplified if x is defined. See bug 309957. + + int leftStatus = isAlwaysDefinedBoolean(left); + if (leftStatus == ALWAYS_FALSE_BOOLEAN) { + // if the first one is false, just return it + return left; + } else if (leftStatus == ALWAYS_TRUE_BOOLEAN) { + // if first is true, set to second + return right; + } + break; + } + + case Token.OR: { + // Since x || y gives x, not true, when Boolean(x) is true, + // and y, not Boolean(y), when Boolean(x) is false, x || y + // can only be simplified if x is defined. See bug 309957. + + int leftStatus = isAlwaysDefinedBoolean(left); + if (leftStatus == ALWAYS_TRUE_BOOLEAN) { + // if the first one is true, just return it + return left; + } else if (leftStatus == ALWAYS_FALSE_BOOLEAN) { + // if first is false, set to second + return right; + } + break; + } + } + + return new Node(nodeType, left, right); + } + + private Node simpleAssignment(Node left, Node right) + { + int nodeType = left.getType(); + switch (nodeType) { + case Token.NAME: + left.setType(Token.BINDNAME); + return new Node(Token.SETNAME, left, right); + + case Token.GETPROP: + case Token.GETELEM: { + Node obj = left.getFirstChild(); + Node id = left.getLastChild(); + int type; + if (nodeType == Token.GETPROP) { + type = Token.SETPROP; + } else { + type = Token.SETELEM; + } + return new Node(type, obj, id, right); + } + case Token.GET_REF: { + Node ref = left.getFirstChild(); + checkMutableReference(ref); + return new Node(Token.SET_REF, ref, right); + } + } + + throw Kit.codeBug(); + } + + private void checkMutableReference(Node n) + { + int memberTypeFlags = n.getIntProp(Node.MEMBER_TYPE_PROP, 0); + if ((memberTypeFlags & Node.DESCENDANTS_FLAG) != 0) { + parser.reportError("msg.bad.assign.left"); + } + } + + Node createAssignment(int assignType, Node left, Node right) + { + Node ref = makeReference(left); + if (ref == null) { + if (left.getType() == Token.ARRAYLIT || + left.getType() == Token.OBJECTLIT) + { + if (assignType != Token.ASSIGN) { + parser.reportError("msg.bad.destruct.op"); + return right; + } + return createDestructuringAssignment(-1, left, right); + } + parser.reportError("msg.bad.assign.left"); + return right; + } + left = ref; + + int assignOp; + switch (assignType) { + case Token.ASSIGN: + return simpleAssignment(left, right); + case Token.ASSIGN_BITOR: assignOp = Token.BITOR; break; + case Token.ASSIGN_BITXOR: assignOp = Token.BITXOR; break; + case Token.ASSIGN_BITAND: assignOp = Token.BITAND; break; + case Token.ASSIGN_LSH: assignOp = Token.LSH; break; + case Token.ASSIGN_RSH: assignOp = Token.RSH; break; + case Token.ASSIGN_URSH: assignOp = Token.URSH; break; + case Token.ASSIGN_ADD: assignOp = Token.ADD; break; + case Token.ASSIGN_SUB: assignOp = Token.SUB; break; + case Token.ASSIGN_MUL: assignOp = Token.MUL; break; + case Token.ASSIGN_DIV: assignOp = Token.DIV; break; + case Token.ASSIGN_MOD: assignOp = Token.MOD; break; + default: throw Kit.codeBug(); + } + + int nodeType = left.getType(); + switch (nodeType) { + case Token.NAME: { + Node op = new Node(assignOp, left, right); + Node lvalueLeft = Node.newString(Token.BINDNAME, left.getString()); + return new Node(Token.SETNAME, lvalueLeft, op); + } + case Token.GETPROP: + case Token.GETELEM: { + Node obj = left.getFirstChild(); + Node id = left.getLastChild(); + + int type = nodeType == Token.GETPROP + ? Token.SETPROP_OP + : Token.SETELEM_OP; + + Node opLeft = new Node(Token.USE_STACK); + Node op = new Node(assignOp, opLeft, right); + return new Node(type, obj, id, op); + } + case Token.GET_REF: { + ref = left.getFirstChild(); + checkMutableReference(ref); + Node opLeft = new Node(Token.USE_STACK); + Node op = new Node(assignOp, opLeft, right); + return new Node(Token.SET_REF_OP, ref, op); + } + } + + throw Kit.codeBug(); + } + + /** + * Given a destructuring assignment with a left hand side parsed + * as an array or object literal and a right hand side expression, + * rewrite as a series of assignments to the variables defined in + * left from property accesses to the expression on the right. + * @param type declaration type: Token.VAR or Token.LET or -1 + * @param left array or object literal containing NAME nodes for + * variables to assign + * @param right expression to assign from + * @return expression that performs a series of assignments to + * the variables defined in left + */ + Node createDestructuringAssignment(int type, Node left, Node right) + { + String tempName = parser.currentScriptOrFn.getNextTempName(); + Node result = destructuringAssignmentHelper(type, left, right, + tempName); + Node comma = result.getLastChild(); + comma.addChildToBack(createName(tempName)); + return result; + } + + private Node destructuringAssignmentHelper(int variableType, Node left, + Node right, String tempName) + { + Node result = createScopeNode(Token.LETEXPR, + parser.getCurrentLineNumber()); + result.addChildToFront(new Node(Token.LET, + createName(Token.NAME, tempName, right))); + try { + parser.pushScope(result); + parser.defineSymbol(Token.LET, tempName); + } finally { + parser.popScope(); + } + Node comma = new Node(Token.COMMA); + result.addChildToBack(comma); + final int setOp = variableType == Token.CONST ? Token.SETCONST + : Token.SETNAME; + List<String> destructuringNames = new ArrayList<String>(); + boolean empty = true; + int type = left.getType(); + if (type == Token.ARRAYLIT) { + int index = 0; + int[] skipIndices = (int[])left.getProp(Node.SKIP_INDEXES_PROP); + int skip = 0; + Node n = left.getFirstChild(); + for (;;) { + if (skipIndices != null) { + while (skip < skipIndices.length && + skipIndices[skip] == index) { + skip++; + index++; + } + } + if (n == null) + break; + Node rightElem = new Node(Token.GETELEM, + createName(tempName), + createNumber(index)); + if (n.getType() == Token.NAME) { + String name = n.getString(); + comma.addChildToBack(new Node(setOp, + createName(Token.BINDNAME, name, null), + rightElem)); + if (variableType != -1) { + parser.defineSymbol(variableType, name); + destructuringNames.add(name); + } + } else { + comma.addChildToBack( + destructuringAssignmentHelper(variableType, n, + rightElem, + parser.currentScriptOrFn.getNextTempName())); + } + index++; + empty = false; + n = n.getNext(); + } + } else if (type == Token.OBJECTLIT) { + int index = 0; + Object[] propertyIds = (Object[]) + left.getProp(Node.OBJECT_IDS_PROP); + for (Node n = left.getFirstChild(); n != null; n = n.getNext()) + { + Object id = propertyIds[index]; + Node rightElem = id instanceof String + ? new Node(Token.GETPROP, + createName(tempName), + createString((String)id)) + : new Node(Token.GETELEM, + createName(tempName), + createNumber(((Number)id).intValue())); + if (n.getType() == Token.NAME) { + String name = n.getString(); + comma.addChildToBack(new Node(setOp, + createName(Token.BINDNAME, name, null), + rightElem)); + if (variableType != -1) { + parser.defineSymbol(variableType, name); + destructuringNames.add(name); + } + } else { + comma.addChildToBack( + destructuringAssignmentHelper(variableType, n, + rightElem, + parser.currentScriptOrFn.getNextTempName())); + } + index++; + empty = false; + } + } else if (type == Token.GETPROP || type == Token.GETELEM) { + comma.addChildToBack(simpleAssignment(left, createName(tempName))); + } else { + parser.reportError("msg.bad.assign.left"); + } + if (empty) { + // Don't want a COMMA node with no children. Just add a zero. + comma.addChildToBack(createNumber(0)); + } + result.putProp(Node.DESTRUCTURING_NAMES, destructuringNames); + return result; + } + + Node createUseLocal(Node localBlock) + { + if (Token.LOCAL_BLOCK != localBlock.getType()) throw Kit.codeBug(); + Node result = new Node(Token.LOCAL_LOAD); + result.putProp(Node.LOCAL_BLOCK_PROP, localBlock); + return result; + } + + private Node.Jump makeJump(int type, Node target) + { + Node.Jump n = new Node.Jump(type); + n.target = target; + return n; + } + + private Node makeReference(Node node) + { + int type = node.getType(); + switch (type) { + case Token.NAME: + case Token.GETPROP: + case Token.GETELEM: + case Token.GET_REF: + return node; + case Token.CALL: + node.setType(Token.REF_CALL); + return new Node(Token.GET_REF, node); + } + // Signal caller to report error + return null; + } + + // Check if Node always mean true or false in boolean context + private static int isAlwaysDefinedBoolean(Node node) + { + switch (node.getType()) { + case Token.FALSE: + case Token.NULL: + return ALWAYS_FALSE_BOOLEAN; + case Token.TRUE: + return ALWAYS_TRUE_BOOLEAN; + case Token.NUMBER: { + double num = node.getDouble(); + if (num == num && num != 0.0) { + return ALWAYS_TRUE_BOOLEAN; + } else { + return ALWAYS_FALSE_BOOLEAN; + } + } + } + return 0; + } + + private void checkActivationName(String name, int token) + { + if (parser.insideFunction()) { + boolean activation = false; + if ("arguments".equals(name) + || (parser.compilerEnv.activationNames != null + && parser.compilerEnv.activationNames.containsKey(name))) + { + activation = true; + } else if ("length".equals(name)) { + if (token == Token.GETPROP + && parser.compilerEnv.getLanguageVersion() + == Context.VERSION_1_2) + { + // Use of "length" in 1.2 requires an activation object. + activation = true; + } + } + if (activation) { + setRequiresActivation(); + } + } + } + + private void setRequiresActivation() + { + if (parser.insideFunction()) { + ((FunctionNode)parser.currentScriptOrFn).itsNeedsActivation = true; + } + } + + private void setIsGenerator() + { + if (parser.insideFunction()) { + ((FunctionNode)parser.currentScriptOrFn).itsIsGenerator = true; + } + } + + private Parser parser; + + private static final int LOOP_DO_WHILE = 0; + private static final int LOOP_WHILE = 1; + private static final int LOOP_FOR = 2; + + private static final int ALWAYS_TRUE_BOOLEAN = 1; + private static final int ALWAYS_FALSE_BOOLEAN = -1; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdFunctionCall.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdFunctionCall.java new file mode 100644 index 0000000..713fabf --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdFunctionCall.java @@ -0,0 +1,55 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * Master for id-based functions that knows their properties and how to + * execute them. + */ +public interface IdFunctionCall +{ + /** + * 'thisObj' will be null if invoked as constructor, in which case + * instance of Scriptable should be returned + */ + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args); + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdFunctionObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdFunctionObject.java new file mode 100644 index 0000000..c578dfa --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdFunctionObject.java @@ -0,0 +1,189 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +public class IdFunctionObject extends BaseFunction +{ + + static final long serialVersionUID = -5332312783643935019L; + + public IdFunctionObject(IdFunctionCall idcall, Object tag, int id, int arity) + { + if (arity < 0) + throw new IllegalArgumentException(); + + this.idcall = idcall; + this.tag = tag; + this.methodId = id; + this.arity = arity; + if (arity < 0) throw new IllegalArgumentException(); + } + + public IdFunctionObject(IdFunctionCall idcall, Object tag, int id, + String name, int arity, Scriptable scope) + { + super(scope, null); + + if (arity < 0) + throw new IllegalArgumentException(); + if (name == null) + throw new IllegalArgumentException(); + + this.idcall = idcall; + this.tag = tag; + this.methodId = id; + this.arity = arity; + this.functionName = name; + } + + public void initFunction(String name, Scriptable scope) + { + if (name == null) throw new IllegalArgumentException(); + if (scope == null) throw new IllegalArgumentException(); + this.functionName = name; + setParentScope(scope); + } + + public final boolean hasTag(Object tag) + { + return this.tag == tag; + } + + public final int methodId() + { + return methodId; + } + + public final void markAsConstructor(Scriptable prototypeProperty) + { + useCallAsConstructor = true; + setImmunePrototypeProperty(prototypeProperty); + } + + public final void addAsProperty(Scriptable target) + { + ScriptableObject.defineProperty(target, functionName, this, + ScriptableObject.DONTENUM); + } + + public void exportAsScopeProperty() + { + addAsProperty(getParentScope()); + } + + public Scriptable getPrototype() + { + // Lazy initialization of prototype: for native functions this + // may not be called at all + Scriptable proto = super.getPrototype(); + if (proto == null) { + proto = getFunctionPrototype(getParentScope()); + setPrototype(proto); + } + return proto; + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return idcall.execIdCall(this, cx, scope, thisObj, args); + } + + public Scriptable createObject(Context cx, Scriptable scope) + { + if (useCallAsConstructor) { + return null; + } + // Throw error if not explicitly coded to be used as constructor, + // to satisfy ECMAScript standard (see bugzilla 202019). + // To follow current (2003-05-01) SpiderMonkey behavior, change it to: + // return super.createObject(cx, scope); + throw ScriptRuntime.typeError1("msg.not.ctor", functionName); + } + + String decompile(int indent, int flags) + { + StringBuffer sb = new StringBuffer(); + boolean justbody = (0 != (flags & Decompiler.ONLY_BODY_FLAG)); + if (!justbody) { + sb.append("function "); + sb.append(getFunctionName()); + sb.append("() { "); + } + sb.append("[native code for "); + if (idcall instanceof Scriptable) { + Scriptable sobj = (Scriptable)idcall; + sb.append(sobj.getClassName()); + sb.append('.'); + } + sb.append(getFunctionName()); + sb.append(", arity="); + sb.append(getArity()); + sb.append(justbody ? "]\n" : "] }\n"); + return sb.toString(); + } + + public int getArity() + { + return arity; + } + + public int getLength() { return getArity(); } + + public String getFunctionName() + { + return (functionName == null) ? "" : functionName; + } + + public final RuntimeException unknown() + { + // It is program error to call id-like methods for unknown function + return new IllegalArgumentException( + "BAD FUNCTION ID="+methodId+" MASTER="+idcall); + } + + private final IdFunctionCall idcall; + private final Object tag; + private final int methodId; + private int arity; + private boolean useCallAsConstructor; + private String functionName; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdScriptableObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdScriptableObject.java new file mode 100644 index 0000000..2b3ecf3 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/IdScriptableObject.java @@ -0,0 +1,734 @@ +/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.*; + +/** +Base class for native object implementation that uses IdFunctionObject to export its methods to script via <class-name>.prototype object. + +Any descendant should implement at least the following methods: + findInstanceIdInfo + getInstanceIdName + execIdCall + methodArity + +To define non-function properties, the descendant should override + getInstanceIdValue + setInstanceIdValue +to get/set property value and provide its default attributes. + + +To customize initializition of constructor and protype objects, descendant +may override scopeInit or fillConstructorProperties methods. + +*/ +public abstract class IdScriptableObject extends ScriptableObject + implements IdFunctionCall +{ + private transient volatile PrototypeValues prototypeValues; + + private static final class PrototypeValues implements Serializable + { + static final long serialVersionUID = 3038645279153854371L; + + private static final int VALUE_SLOT = 0; + private static final int NAME_SLOT = 1; + private static final int SLOT_SPAN = 2; + + private IdScriptableObject obj; + private int maxId; + private volatile Object[] valueArray; + private volatile short[] attributeArray; + private volatile int lastFoundId = 1; + + // The following helps to avoid creation of valueArray during runtime + // initialization for common case of "constructor" property + int constructorId; + private IdFunctionObject constructor; + private short constructorAttrs; + + PrototypeValues(IdScriptableObject obj, int maxId) + { + if (obj == null) throw new IllegalArgumentException(); + if (maxId < 1) throw new IllegalArgumentException(); + this.obj = obj; + this.maxId = maxId; + } + + final int getMaxId() + { + return maxId; + } + + final void initValue(int id, String name, Object value, int attributes) + { + if (!(1 <= id && id <= maxId)) + throw new IllegalArgumentException(); + if (name == null) + throw new IllegalArgumentException(); + if (value == NOT_FOUND) + throw new IllegalArgumentException(); + ScriptableObject.checkValidAttributes(attributes); + if (obj.findPrototypeId(name) != id) + throw new IllegalArgumentException(name); + + if (id == constructorId) { + if (!(value instanceof IdFunctionObject)) { + throw new IllegalArgumentException("consructor should be initialized with IdFunctionObject"); + } + constructor = (IdFunctionObject)value; + constructorAttrs = (short)attributes; + return; + } + + initSlot(id, name, value, attributes); + } + + private void initSlot(int id, String name, Object value, + int attributes) + { + Object[] array = valueArray; + if (array == null) + throw new IllegalStateException(); + + if (value == null) { + value = UniqueTag.NULL_VALUE; + } + int index = (id - 1) * SLOT_SPAN; + synchronized (this) { + Object value2 = array[index + VALUE_SLOT]; + if (value2 == null) { + array[index + VALUE_SLOT] = value; + array[index + NAME_SLOT] = name; + attributeArray[id - 1] = (short)attributes; + } else { + if (!name.equals(array[index + NAME_SLOT])) + throw new IllegalStateException(); + } + } + } + + final IdFunctionObject createPrecachedConstructor() + { + if (constructorId != 0) throw new IllegalStateException(); + constructorId = obj.findPrototypeId("constructor"); + if (constructorId == 0) { + throw new IllegalStateException( + "No id for constructor property"); + } + obj.initPrototypeId(constructorId); + if (constructor == null) { + throw new IllegalStateException( + obj.getClass().getName()+".initPrototypeId() did not " + +"initialize id="+constructorId); + } + constructor.initFunction(obj.getClassName(), + ScriptableObject.getTopLevelScope(obj)); + constructor.markAsConstructor(obj); + return constructor; + } + + final int findId(String name) + { + Object[] array = valueArray; + if (array == null) { + return obj.findPrototypeId(name); + } + int id = lastFoundId; + if (name == array[(id - 1) * SLOT_SPAN + NAME_SLOT]) { + return id; + } + id = obj.findPrototypeId(name); + if (id != 0) { + int nameSlot = (id - 1) * SLOT_SPAN + NAME_SLOT; + // Make cache to work! + array[nameSlot] = name; + lastFoundId = id; + } + return id; + } + + final boolean has(int id) + { + Object[] array = valueArray; + if (array == null) { + // Not yet initialized, assume all exists + return true; + } + int valueSlot = (id - 1) * SLOT_SPAN + VALUE_SLOT; + Object value = array[valueSlot]; + if (value == null) { + // The particular entry has not been yet initialized + return true; + } + return value != NOT_FOUND; + } + + final Object get(int id) + { + Object value = ensureId(id); + if (value == UniqueTag.NULL_VALUE) { + value = null; + } + return value; + } + + final void set(int id, Scriptable start, Object value) + { + if (value == NOT_FOUND) throw new IllegalArgumentException(); + ensureId(id); + int attr = attributeArray[id - 1]; + if ((attr & READONLY) == 0) { + if (start == obj) { + if (value == null) { + value = UniqueTag.NULL_VALUE; + } + int valueSlot = (id - 1) * SLOT_SPAN + VALUE_SLOT; + synchronized (this) { + valueArray[valueSlot] = value; + } + } + else { + int nameSlot = (id - 1) * SLOT_SPAN + NAME_SLOT; + String name = (String)valueArray[nameSlot]; + start.put(name, start, value); + } + } + } + + final void delete(int id) + { + ensureId(id); + int attr = attributeArray[id - 1]; + if ((attr & PERMANENT) == 0) { + int valueSlot = (id - 1) * SLOT_SPAN + VALUE_SLOT; + synchronized (this) { + valueArray[valueSlot] = NOT_FOUND; + attributeArray[id - 1] = EMPTY; + } + } + } + + final int getAttributes(int id) + { + ensureId(id); + return attributeArray[id - 1]; + } + + final void setAttributes(int id, int attributes) + { + ScriptableObject.checkValidAttributes(attributes); + ensureId(id); + synchronized (this) { + attributeArray[id - 1] = (short)attributes; + } + } + + final Object[] getNames(boolean getAll, Object[] extraEntries) + { + Object[] names = null; + int count = 0; + for (int id = 1; id <= maxId; ++id) { + Object value = ensureId(id); + if (getAll || (attributeArray[id - 1] & DONTENUM) == 0) { + if (value != NOT_FOUND) { + int nameSlot = (id - 1) * SLOT_SPAN + NAME_SLOT; + String name = (String)valueArray[nameSlot]; + if (names == null) { + names = new Object[maxId]; + } + names[count++] = name; + } + } + } + if (count == 0) { + return extraEntries; + } else if (extraEntries == null || extraEntries.length == 0) { + if (count != names.length) { + Object[] tmp = new Object[count]; + System.arraycopy(names, 0, tmp, 0, count); + names = tmp; + } + return names; + } else { + int extra = extraEntries.length; + Object[] tmp = new Object[extra + count]; + System.arraycopy(extraEntries, 0, tmp, 0, extra); + System.arraycopy(names, 0, tmp, extra, count); + return tmp; + } + } + + private Object ensureId(int id) + { + Object[] array = valueArray; + if (array == null) { + synchronized (this) { + array = valueArray; + if (array == null) { + array = new Object[maxId * SLOT_SPAN]; + valueArray = array; + attributeArray = new short[maxId]; + } + } + } + int valueSlot = (id - 1) * SLOT_SPAN + VALUE_SLOT; + Object value = array[valueSlot]; + if (value == null) { + if (id == constructorId) { + initSlot(constructorId, "constructor", + constructor, constructorAttrs); + constructor = null; // no need to refer it any longer + } else { + obj.initPrototypeId(id); + } + value = array[valueSlot]; + if (value == null) { + throw new IllegalStateException( + obj.getClass().getName()+".initPrototypeId(int id) " + +"did not initialize id="+id); + } + } + return value; + } + } + + public IdScriptableObject() + { + } + + public IdScriptableObject(Scriptable scope, Scriptable prototype) + { + super(scope, prototype); + } + + protected final Object defaultGet(String name) + { + return super.get(name, this); + } + + protected final void defaultPut(String name, Object value) + { + super.put(name, this, value); + } + + public boolean has(String name, Scriptable start) + { + int info = findInstanceIdInfo(name); + if (info != 0) { + int attr = (info >>> 16); + if ((attr & PERMANENT) != 0) { + return true; + } + int id = (info & 0xFFFF); + return NOT_FOUND != getInstanceIdValue(id); + } + if (prototypeValues != null) { + int id = prototypeValues.findId(name); + if (id != 0) { + return prototypeValues.has(id); + } + } + return super.has(name, start); + } + + public Object get(String name, Scriptable start) + { + int info = findInstanceIdInfo(name); + if (info != 0) { + int id = (info & 0xFFFF); + return getInstanceIdValue(id); + } + if (prototypeValues != null) { + int id = prototypeValues.findId(name); + if (id != 0) { + return prototypeValues.get(id); + } + } + return super.get(name, start); + } + + public void put(String name, Scriptable start, Object value) + { + int info = findInstanceIdInfo(name); + if (info != 0) { + if (start == this && isSealed()) { + throw Context.reportRuntimeError1("msg.modify.sealed", + name); + } + int attr = (info >>> 16); + if ((attr & READONLY) == 0) { + if (start == this) { + int id = (info & 0xFFFF); + setInstanceIdValue(id, value); + } + else { + start.put(name, start, value); + } + } + return; + } + if (prototypeValues != null) { + int id = prototypeValues.findId(name); + if (id != 0) { + if (start == this && isSealed()) { + throw Context.reportRuntimeError1("msg.modify.sealed", + name); + } + prototypeValues.set(id, start, value); + return; + } + } + super.put(name, start, value); + } + + public void delete(String name) + { + int info = findInstanceIdInfo(name); + if (info != 0) { + // Let the super class to throw exceptions for sealed objects + if (!isSealed()) { + int attr = (info >>> 16); + if ((attr & PERMANENT) == 0) { + int id = (info & 0xFFFF); + setInstanceIdValue(id, NOT_FOUND); + } + return; + } + } + if (prototypeValues != null) { + int id = prototypeValues.findId(name); + if (id != 0) { + if (!isSealed()) { + prototypeValues.delete(id); + } + return; + } + } + super.delete(name); + } + + public int getAttributes(String name) + { + int info = findInstanceIdInfo(name); + if (info != 0) { + int attr = (info >>> 16); + return attr; + } + if (prototypeValues != null) { + int id = prototypeValues.findId(name); + if (id != 0) { + return prototypeValues.getAttributes(id); + } + } + return super.getAttributes(name); + } + + public void setAttributes(String name, int attributes) + { + ScriptableObject.checkValidAttributes(attributes); + int info = findInstanceIdInfo(name); + if (info != 0) { + int currentAttributes = (info >>> 16); + if (attributes != currentAttributes) { + throw new RuntimeException( + "Change of attributes for this id is not supported"); + } + return; + } + if (prototypeValues != null) { + int id = prototypeValues.findId(name); + if (id != 0) { + prototypeValues.setAttributes(id, attributes); + return; + } + } + super.setAttributes(name, attributes); + } + + Object[] getIds(boolean getAll) + { + Object[] result = super.getIds(getAll); + + if (prototypeValues != null) { + result = prototypeValues.getNames(getAll, result); + } + + int maxInstanceId = getMaxInstanceId(); + if (maxInstanceId != 0) { + Object[] ids = null; + int count = 0; + + for (int id = maxInstanceId; id != 0; --id) { + String name = getInstanceIdName(id); + int info = findInstanceIdInfo(name); + if (info != 0) { + int attr = (info >>> 16); + if ((attr & PERMANENT) == 0) { + if (NOT_FOUND == getInstanceIdValue(id)) { + continue; + } + } + if (getAll || (attr & DONTENUM) == 0) { + if (count == 0) { + // Need extra room for no more then [1..id] names + ids = new Object[id]; + } + ids[count++] = name; + } + } + } + if (count != 0) { + if (result.length == 0 && ids.length == count) { + result = ids; + } + else { + Object[] tmp = new Object[result.length + count]; + System.arraycopy(result, 0, tmp, 0, result.length); + System.arraycopy(ids, 0, tmp, result.length, count); + result = tmp; + } + } + } + return result; + } + + /** + * Get maximum id findInstanceIdInfo can generate. + */ + protected int getMaxInstanceId() + { + return 0; + } + + protected static int instanceIdInfo(int attributes, int id) + { + return (attributes << 16) | id; + } + + /** + * Map name to id of instance property. + * Should return 0 if not found or the result of + * {@link #instanceIdInfo(int, int)}. + */ + protected int findInstanceIdInfo(String name) + { + return 0; + } + + /** Map id back to property name it defines. + */ + protected String getInstanceIdName(int id) + { + throw new IllegalArgumentException(String.valueOf(id)); + } + + /** Get id value. + ** If id value is constant, descendant can call cacheIdValue to store + ** value in the permanent cache. + ** Default implementation creates IdFunctionObject instance for given id + ** and cache its value + */ + protected Object getInstanceIdValue(int id) + { + throw new IllegalStateException(String.valueOf(id)); + } + + /** + * Set or delete id value. If value == NOT_FOUND , the implementation + * should make sure that the following getInstanceIdValue return NOT_FOUND. + */ + protected void setInstanceIdValue(int id, Object value) + { + throw new IllegalStateException(String.valueOf(id)); + } + + /** 'thisObj' will be null if invoked as constructor, in which case + ** instance of Scriptable should be returned. */ + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + throw f.unknown(); + } + + public final IdFunctionObject exportAsJSClass(int maxPrototypeId, + Scriptable scope, + boolean sealed) + { + // Set scope and prototype unless this is top level scope itself + if (scope != this && scope != null) { + setParentScope(scope); + setPrototype(getObjectPrototype(scope)); + } + + activatePrototypeMap(maxPrototypeId); + IdFunctionObject ctor = prototypeValues.createPrecachedConstructor(); + if (sealed) { + sealObject(); + } + fillConstructorProperties(ctor); + if (sealed) { + ctor.sealObject(); + } + ctor.exportAsScopeProperty(); + return ctor; + } + + public final boolean hasPrototypeMap() + { + return prototypeValues != null; + } + + public final void activatePrototypeMap(int maxPrototypeId) + { + PrototypeValues values = new PrototypeValues(this, maxPrototypeId); + synchronized (this) { + if (prototypeValues != null) + throw new IllegalStateException(); + prototypeValues = values; + } + } + + public final void initPrototypeMethod(Object tag, int id, String name, + int arity) + { + Scriptable scope = ScriptableObject.getTopLevelScope(this); + IdFunctionObject f = newIdFunction(tag, id, name, arity, scope); + prototypeValues.initValue(id, name, f, DONTENUM); + } + + public final void initPrototypeConstructor(IdFunctionObject f) + { + int id = prototypeValues.constructorId; + if (id == 0) + throw new IllegalStateException(); + if (f.methodId() != id) + throw new IllegalArgumentException(); + if (isSealed()) { f.sealObject(); } + prototypeValues.initValue(id, "constructor", f, DONTENUM); + } + + public final void initPrototypeValue(int id, String name, Object value, + int attributes) + { + prototypeValues.initValue(id, name, value, attributes); + } + + protected void initPrototypeId(int id) + { + throw new IllegalStateException(String.valueOf(id)); + } + + protected int findPrototypeId(String name) + { + throw new IllegalStateException(name); + } + + protected void fillConstructorProperties(IdFunctionObject ctor) + { + } + + protected void addIdFunctionProperty(Scriptable obj, Object tag, int id, + String name, int arity) + { + Scriptable scope = ScriptableObject.getTopLevelScope(obj); + IdFunctionObject f = newIdFunction(tag, id, name, arity, scope); + f.addAsProperty(obj); + } + + /** + * Utility method to construct type error to indicate incompatible call + * when converting script thisObj to a particular type is not possible. + * Possible usage would be to have a private function like realThis: + * <pre> + * private static NativeSomething realThis(Scriptable thisObj, + * IdFunctionObject f) + * { + * if (!(thisObj instanceof NativeSomething)) + * throw incompatibleCallError(f); + * return (NativeSomething)thisObj; + * } + * </pre> + * Note that although such function can be implemented universally via + * java.lang.Class.isInstance(), it would be much more slower. + * @param f function that is attempting to convert 'this' + * object. + * @return Scriptable object suitable for a check by the instanceof + * operator. + * @throws RuntimeException if no more instanceof target can be found + */ + protected static EcmaError incompatibleCallError(IdFunctionObject f) + { + throw ScriptRuntime.typeError1("msg.incompat.call", + f.getFunctionName()); + } + + private IdFunctionObject newIdFunction(Object tag, int id, String name, + int arity, Scriptable scope) + { + IdFunctionObject f = new IdFunctionObject(this, tag, id, name, arity, + scope); + if (isSealed()) { f.sealObject(); } + return f; + } + + private void readObject(ObjectInputStream stream) + throws IOException, ClassNotFoundException + { + stream.defaultReadObject(); + int maxPrototypeId = stream.readInt(); + if (maxPrototypeId != 0) { + activatePrototypeMap(maxPrototypeId); + } + } + + private void writeObject(ObjectOutputStream stream) + throws IOException + { + stream.defaultWriteObject(); + int maxPrototypeId = 0; + if (prototypeValues != null) { + maxPrototypeId = prototypeValues.getMaxId(); + } + stream.writeInt(maxPrototypeId); + } + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ImporterTopLevel.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ImporterTopLevel.java new file mode 100644 index 0000000..294deab --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ImporterTopLevel.java @@ -0,0 +1,318 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Matthias Radestock + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Class ImporterTopLevel + * + * This class defines a ScriptableObject that can be instantiated + * as a top-level ("global") object to provide functionality similar + * to Java's "import" statement. + * <p> + * This class can be used to create a top-level scope using the following code: + * <pre> + * Scriptable scope = new ImporterTopLevel(cx); + * </pre> + * Then JavaScript code will have access to the following methods: + * <ul> + * <li>importClass - will "import" a class by making its unqualified name + * available as a property of the top-level scope + * <li>importPackage - will "import" all the classes of the package by + * searching for unqualified names as classes qualified + * by the given package. + * </ul> + * The following code from the shell illustrates this use: + * <pre> + * js> importClass(java.io.File) + * js> f = new File('help.txt') + * help.txt + * js> importPackage(java.util) + * js> v = new Vector() + * [] + * + * @author Norris Boyd + */ +public class ImporterTopLevel extends IdScriptableObject +{ + static final long serialVersionUID = -9095380847465315412L; + + private static final Object IMPORTER_TAG = new Object(); + + public ImporterTopLevel() { } + + public ImporterTopLevel(Context cx) { + this(cx, false); + } + + public ImporterTopLevel(Context cx, boolean sealed) + { + initStandardObjects(cx, sealed); + } + + public String getClassName() + { + return (topScopeFlag) ? "global" : "JavaImporter"; + } + + public static void init(Context cx, Scriptable scope, boolean sealed) + { + ImporterTopLevel obj = new ImporterTopLevel(); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + public void initStandardObjects(Context cx, boolean sealed) + { + // Assume that Context.initStandardObjects initialize JavaImporter + // property lazily so the above init call is not yet called + cx.initStandardObjects(this, sealed); + topScopeFlag = true; + // If seal is true then exportAsJSClass(cx, seal) would seal + // this obj. Since this is scope as well, it would not allow + // to add variables. + IdFunctionObject ctor = exportAsJSClass(MAX_PROTOTYPE_ID, this, false); + if (sealed) { + ctor.sealObject(); + } + // delete "constructor" defined by exportAsJSClass so "constructor" + // name would refer to Object.constructor + // and not to JavaImporter.prototype.constructor. + delete("constructor"); + } + + public boolean has(String name, Scriptable start) { + return super.has(name, start) + || getPackageProperty(name, start) != NOT_FOUND; + } + + public Object get(String name, Scriptable start) { + Object result = super.get(name, start); + if (result != NOT_FOUND) + return result; + result = getPackageProperty(name, start); + return result; + } + + private Object getPackageProperty(String name, Scriptable start) { + Object result = NOT_FOUND; + Object[] elements; + synchronized (importedPackages) { + elements = importedPackages.toArray(); + } + for (int i=0; i < elements.length; i++) { + NativeJavaPackage p = (NativeJavaPackage) elements[i]; + Object v = p.getPkgProperty(name, start, false); + if (v != null && !(v instanceof NativeJavaPackage)) { + if (result == NOT_FOUND) { + result = v; + } else { + throw Context.reportRuntimeError2( + "msg.ambig.import", result.toString(), v.toString()); + } + } + } + return result; + } + + /** + * @deprecated Kept only for compatibility. + */ + public void importPackage(Context cx, Scriptable thisObj, Object[] args, + Function funObj) + { + js_importPackage(args); + } + + private Object js_construct(Scriptable scope, Object[] args) + { + ImporterTopLevel result = new ImporterTopLevel(); + for (int i = 0; i != args.length; ++i) { + Object arg = args[i]; + if (arg instanceof NativeJavaClass) { + result.importClass((NativeJavaClass)arg); + } else if (arg instanceof NativeJavaPackage) { + result.importPackage((NativeJavaPackage)arg); + } else { + throw Context.reportRuntimeError1( + "msg.not.class.not.pkg", Context.toString(arg)); + } + } + // set explicitly prototype and scope + // as otherwise in top scope mode BaseFunction.construct + // would keep them set to null. It also allow to use + // JavaImporter without new and still get properly + // initialized object. + result.setParentScope(scope); + result.setPrototype(this); + return result; + } + + private Object js_importClass(Object[] args) + { + for (int i = 0; i != args.length; i++) { + Object arg = args[i]; + if (!(arg instanceof NativeJavaClass)) { + throw Context.reportRuntimeError1( + "msg.not.class", Context.toString(arg)); + } + importClass((NativeJavaClass)arg); + } + return Undefined.instance; + } + + private Object js_importPackage(Object[] args) + { + for (int i = 0; i != args.length; i++) { + Object arg = args[i]; + if (!(arg instanceof NativeJavaPackage)) { + throw Context.reportRuntimeError1( + "msg.not.pkg", Context.toString(arg)); + } + importPackage((NativeJavaPackage)arg); + } + return Undefined.instance; + } + + private void importPackage(NativeJavaPackage pkg) + { + if(pkg == null) { + return; + } + synchronized (importedPackages) { + for (int j = 0; j != importedPackages.size(); j++) { + if (pkg.equals(importedPackages.get(j))) { + return; + } + } + importedPackages.add(pkg); + } + } + + private void importClass(NativeJavaClass cl) + { + String s = cl.getClassObject().getName(); + String n = s.substring(s.lastIndexOf('.')+1); + Object val = get(n, this); + if (val != NOT_FOUND && val != cl) { + throw Context.reportRuntimeError1("msg.prop.defined", n); + } + //defineProperty(n, cl, DONTENUM); + put(n, this, cl); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=0; s="constructor"; break; + case Id_importClass: arity=1; s="importClass"; break; + case Id_importPackage: arity=1; s="importPackage"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(IMPORTER_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(IMPORTER_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_constructor: + return js_construct(scope, args); + + case Id_importClass: + return realThis(thisObj, f).js_importClass(args); + + case Id_importPackage: + return realThis(thisObj, f).js_importPackage(args); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + + private ImporterTopLevel realThis(Scriptable thisObj, IdFunctionObject f) + { + if (topScopeFlag) { + // when used as top scope importPackage and importClass are global + // function that ignore thisObj + return this; + } + if (!(thisObj instanceof ImporterTopLevel)) + throw incompatibleCallError(f); + return (ImporterTopLevel)thisObj; + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:24 EDT + L0: { id = 0; String X = null; int c; + int s_length = s.length(); + if (s_length==11) { + c=s.charAt(0); + if (c=='c') { X="constructor";id=Id_constructor; } + else if (c=='i') { X="importClass";id=Id_importClass; } + } + else if (s_length==13) { X="importPackage";id=Id_importPackage; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_importClass = 2, + Id_importPackage = 3, + MAX_PROTOTYPE_ID = 3; + +// #/string_id_map# + + private ObjArray importedPackages = new ObjArray(); + private boolean topScopeFlag; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InformativeParser.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InformativeParser.java new file mode 100644 index 0000000..c73db34 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InformativeParser.java @@ -0,0 +1,225 @@ +package org.mozilla.javascript; + +import java.io.IOException; + +/** + * Subclass of Rhino's Parser that saves information about the token stream + * and error message to allow more helpful error messages. + * + * @author David Greenspan for AppJet + */ + +/* + This class is written with speed in mind, to some extent. Rhino's tokenizer + is pretty efficient, and we wouldn't want to slow it down by, for example, + creating a TokenInfo object on the heap for every token seen. + */ + +/*APPJET*/ +public class InformativeParser extends Parser { + + public static class InformativeEvaluatorException extends EvaluatorException { + final ParseErrorInfo pei; + + InformativeEvaluatorException(String errorMessage, + String sourceName, int lineNumber, + String lineSource, int columnNumber, + ParseErrorInfo peInfo) { + super(errorMessage, sourceName, + lineNumber, lineSource, columnNumber); + pei = peInfo; + } + + public ParseErrorInfo getParseErrorInfo() { + return pei; + } + } + + public static class ParseErrorInfo { + ParseErrorInfo() {} + + String messageId = null; + String messageArg = null; + + final int tokenMaxHistory = 10; + // ring buffers + final int[] tokenTypes = new int[tokenMaxHistory]; + final String[] tokenStrings = new String[tokenMaxHistory]; + final double[] tokenNumbers = new double[tokenMaxHistory]; + final int[] tokenLineNumbers = new int[tokenMaxHistory]; + final int[] tokenLineOffsets = new int[tokenMaxHistory]; + int nextBufPos = 0; + int historyLength = 0; + boolean tokenPeeking = false; + int peekSlot; + + void reportPeekToken(int type, String str, double num, int lineno, + int lineOffset) { + if (! tokenPeeking) { + peekSlot = nextBufPos; + tokenTypes[nextBufPos] = type; + tokenStrings[nextBufPos] = str; + tokenNumbers[nextBufPos] = num; + tokenLineNumbers[nextBufPos] = lineno; + tokenLineOffsets[nextBufPos] = lineOffset; + + nextBufPos++; + if (nextBufPos == tokenMaxHistory) nextBufPos = 0; + if (historyLength < tokenMaxHistory) historyLength++; + tokenPeeking = true; + } + } + + void reportConsumeToken() { + tokenPeeking = false; + } + + private TokenInfo backToken(int n) { + // 0 is most recent token added to history + if (n >= historyLength) return null; + int i = (nextBufPos - 1 - n); + while (i < 0) i += tokenMaxHistory; + return new TokenInfo(tokenTypes[i], tokenStrings[i], + tokenNumbers[i], tokenLineNumbers[i], + tokenLineOffsets[i]); + } + + public String getMessageId() { return messageId; } + public String getMessageArg() { return messageArg; } + public TokenInfo getPeekToken() { + if (tokenPeeking) return backToken(0); + return null; + } + public TokenInfo getPrevToken(int n) { + // 1 = last non-peek token seen, 2 = before that, etc. + if (! tokenPeeking) n--; + return backToken(n); + } + public TokenInfo getPrevToken() { + return getPrevToken(1); + } + } + + public static class TokenInfo { + private int type, lineno, lineOffset; + private String str; + private double num; + TokenInfo(int type, String str, double num, int lineno, + int lineOffset) { + this.type = type; this.str = str; this.num = num; + this.lineno = lineno; this.lineOffset = lineOffset; + } + public int getType() { return type; } + public int getLineNumber() { return lineno; } + public int getLineOffset() { return lineOffset; } + public double getNumber() { return num; } + public String getString() { return str; } + } + + ParseErrorInfo info = new ParseErrorInfo(); + + void doErrorReporterError(String message, String sourceURI, int line, + String lineText, int lineOffset) { + + throw new InformativeEvaluatorException(message, sourceURI, line, + lineText, lineOffset, info); + + } + + public InformativeParser(CompilerEnvirons compilerEnv) { + // we override most calls to the parent's ErrorReporter anyway + super(compilerEnv, DefaultErrorReporter.instance); + } + + @Override int peekToken() throws IOException { + int tt = super.peekToken(); + info.reportPeekToken(tt, ts.getString(), ts.getNumber(), + ts.getLineno(), ts.getOffset()); + return tt; + } + @Override void consumeToken() { + super.consumeToken(); + info.reportConsumeToken(); + } + + @Override void addWarning(String messageId, String messageArg) + { + info.messageId = messageId; + info.messageArg = messageArg; + + String message = ScriptRuntime.getMessage1(messageId, messageArg); + if (compilerEnv.reportWarningAsError()) { + ++syntaxErrorCount; + doErrorReporterError(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } + else { /* don't report */ } + } + + @Override void addError(String messageId) + { + info.messageId = messageId; + + ++syntaxErrorCount; + String message = ScriptRuntime.getMessage0(messageId); + doErrorReporterError(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } + + @Override void addError(String messageId, String messageArg) + { + info.messageId = messageId; + info.messageArg = messageArg; + + ++syntaxErrorCount; + String message = ScriptRuntime.getMessage1(messageId, messageArg); + doErrorReporterError(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } + + @Override protected Decompiler createDecompiler(CompilerEnvirons env) { + return new MyDecompiler(); + } + + public static final ErrorReporter THROW_INFORMATIVE_ERRORS + = new ErrorReporter() { + public void warning(String message, String sourceURI, int line, + String lineText, int lineOffset) { + DefaultErrorReporter.instance.warning + (message, sourceURI, line, lineText, lineOffset); + } + public void error(String message, String sourceURI, int line, + String lineText, int lineOffset) { + DefaultErrorReporter.instance.error + (message, sourceURI, line, lineText, lineOffset); + } + public EvaluatorException runtimeError(String message, + String sourceURI, + int line, String lineText, + int lineOffset) { + return DefaultErrorReporter.instance.runtimeError + (message, sourceURI, line, lineText, lineOffset); + } + + }; + + public static Parser makeParser(CompilerEnvirons compilerEnv, + ErrorReporter errorReporter) { + if (errorReporter == THROW_INFORMATIVE_ERRORS) { + return new InformativeParser(compilerEnv); + } + else { + return new Parser(compilerEnv, errorReporter); + } + } + + private class MyDecompiler extends Decompiler { + @Override void addRegexp(String regexp, String flags) { + super.addRegexp(regexp, flags); + String str = '/'+regexp+'/'+flags; + info.reportPeekToken(Token.REGEXP, str, ts.getNumber(), + ts.getLineno(), ts.getOffset()); + info.reportConsumeToken(); + } + } +}
\ No newline at end of file diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterfaceAdapter.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterfaceAdapter.java new file mode 100644 index 0000000..877e6a2 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterfaceAdapter.java @@ -0,0 +1,156 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.Method; + +/** + * Adapter to use JS function as implementation of Java interfaces with + * single method or multiple methods with the same signature. + */ +public class InterfaceAdapter +{ + private final Object proxyHelper; + + /** + * Make glue object implementing interface cl that will + * call the supplied JS function when called. + * Only interfaces were all methods have the same signature is supported. + * + * @return The glue object or null if <tt>cl</tt> is not interface or + * has methods with different signatures. + */ + static Object create(Context cx, Class cl, Callable function) + { + if (!cl.isInterface()) throw new IllegalArgumentException(); + + Scriptable topScope = ScriptRuntime.getTopCallScope(cx); + ClassCache cache = ClassCache.get(topScope); + InterfaceAdapter adapter; + adapter = (InterfaceAdapter)cache.getInterfaceAdapter(cl); + ContextFactory cf = cx.getFactory(); + if (adapter == null) { + Method[] methods = cl.getMethods(); + if (methods.length == 0) { + throw Context.reportRuntimeError2( + "msg.no.empty.interface.conversion", + String.valueOf(function), + cl.getClass().getName()); + } + boolean canCallFunction = false; + canCallFunctionChecks: { + Class[] argTypes = methods[0].getParameterTypes(); + // check that the rest of methods has the same signature + for (int i = 1; i != methods.length; ++i) { + Class[] types2 = methods[i].getParameterTypes(); + if (types2.length != argTypes.length) { + break canCallFunctionChecks; + } + for (int j = 0; j != argTypes.length; ++j) { + if (types2[j] != argTypes[j]) { + break canCallFunctionChecks; + } + } + } + canCallFunction= true; + } + if (!canCallFunction) { + throw Context.reportRuntimeError2( + "msg.no.function.interface.conversion", + String.valueOf(function), + cl.getClass().getName()); + } + adapter = new InterfaceAdapter(cf, cl); + cache.cacheInterfaceAdapter(cl, adapter); + } + return VMBridge.instance.newInterfaceProxy( + adapter.proxyHelper, cf, adapter, function, topScope); + } + + private InterfaceAdapter(ContextFactory cf, Class cl) + { + this.proxyHelper + = VMBridge.instance.getInterfaceProxyHelper( + cf, new Class[] { cl }); + } + + public Object invoke(ContextFactory cf, + final Object target, + final Scriptable topScope, + final Method method, + final Object[] args) + { + ContextAction action = new ContextAction() { + public Object run(Context cx) + { + return invokeImpl(cx, target, topScope, method, args); + } + }; + return cf.call(action); + } + + Object invokeImpl(Context cx, + Object target, + Scriptable topScope, + Method method, + Object[] args) + { + int N = (args == null) ? 0 : args.length; + + Callable function = (Callable)target; + Scriptable thisObj = topScope; + Object[] jsargs = new Object[N + 1]; + jsargs[N] = method.getName(); + if (N != 0) { + WrapFactory wf = cx.getWrapFactory(); + for (int i = 0; i != N; ++i) { + jsargs[i] = wf.wrap(cx, topScope, args[i], null); + } + } + + Object result = function.call(cx, topScope, thisObj, jsargs); + Class javaResultType = method.getReturnType(); + if (javaResultType == Void.TYPE) { + result = null; + } else { + result = Context.jsToJava(result, javaResultType); + } + return result; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java new file mode 100644 index 0000000..db84299 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpretedFunction.java @@ -0,0 +1,221 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * Bob Jervis + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import org.mozilla.javascript.debug.DebuggableScript; + +final class InterpretedFunction extends NativeFunction implements Script +{ + static final long serialVersionUID = 541475680333911468L; + + InterpreterData idata; + SecurityController securityController; + Object securityDomain; + Scriptable[] functionRegExps; + + private InterpretedFunction(InterpreterData idata, + Object staticSecurityDomain) + { + this.idata = idata; + + // Always get Context from the current thread to + // avoid security breaches via passing mangled Context instances + // with bogus SecurityController + Context cx = Context.getContext(); + SecurityController sc = cx.getSecurityController(); + Object dynamicDomain; + if (sc != null) { + dynamicDomain = sc.getDynamicSecurityDomain(staticSecurityDomain); + } else { + if (staticSecurityDomain != null) { + throw new IllegalArgumentException(); + } + dynamicDomain = null; + } + + this.securityController = sc; + this.securityDomain = dynamicDomain; + } + + private InterpretedFunction(InterpretedFunction parent, int index) + { + this.idata = parent.idata.itsNestedFunctions[index]; + this.securityController = parent.securityController; + this.securityDomain = parent.securityDomain; + } + + /** + * Create script from compiled bytecode. + */ + static InterpretedFunction createScript(InterpreterData idata, + Object staticSecurityDomain) + { + InterpretedFunction f; + f = new InterpretedFunction(idata, staticSecurityDomain); + return f; + } + + /** + * Create function compiled from Function(...) constructor. + */ + static InterpretedFunction createFunction(Context cx,Scriptable scope, + InterpreterData idata, + Object staticSecurityDomain) + { + InterpretedFunction f; + f = new InterpretedFunction(idata, staticSecurityDomain); + f.initInterpretedFunction(cx, scope); + return f; + } + + /** + * Create function embedded in script or another function. + */ + static InterpretedFunction createFunction(Context cx, Scriptable scope, + InterpretedFunction parent, + int index) + { + InterpretedFunction f = new InterpretedFunction(parent, index); + f.initInterpretedFunction(cx, scope); + return f; + } + + Scriptable[] createRegExpWraps(Context cx, Scriptable scope) + { + if (idata.itsRegExpLiterals == null) Kit.codeBug(); + + RegExpProxy rep = ScriptRuntime.checkRegExpProxy(cx); + int N = idata.itsRegExpLiterals.length; + Scriptable[] array = new Scriptable[N]; + for (int i = 0; i != N; ++i) { + array[i] = rep.wrapRegExp(cx, scope, idata.itsRegExpLiterals[i]); + } + return array; + } + + private void initInterpretedFunction(Context cx, Scriptable scope) + { + initScriptFunction(cx, scope); + if (idata.itsRegExpLiterals != null) { + functionRegExps = createRegExpWraps(cx, scope); + } + } + + public String getFunctionName() + { + return (idata.itsName == null) ? "" : idata.itsName; + } + + /** + * Calls the function. + * @param cx the current context + * @param scope the scope used for the call + * @param thisObj the value of "this" + * @param args function arguments. Must not be null. You can use + * {@link ScriptRuntime#emptyArgs} to pass empty arguments. + * @return the result of the function call. + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + if (!ScriptRuntime.hasTopCall(cx)) { + return ScriptRuntime.doTopCall(this, cx, scope, thisObj, args); + } + return Interpreter.interpret(this, cx, scope, thisObj, args); + } + + public Object exec(Context cx, Scriptable scope) + { + if (idata.itsFunctionType != 0) { + // Can only be applied to scripts + throw new IllegalStateException(); + } + if (!ScriptRuntime.hasTopCall(cx)) { + // It will go through "call" path. but they are equivalent + return ScriptRuntime.doTopCall( + this, cx, scope, scope, ScriptRuntime.emptyArgs); + } + return Interpreter.interpret( + this, cx, scope, scope, ScriptRuntime.emptyArgs); + } + + public String getEncodedSource() + { + return Interpreter.getEncodedSource(idata); + } + + public DebuggableScript getDebuggableView() + { + return idata; + } + + public Object resumeGenerator(Context cx, Scriptable scope, int operation, + Object state, Object value) + { + return Interpreter.resumeGenerator(cx, scope, operation, state, value); + } + + protected int getLanguageVersion() + { + return idata.languageVersion; + } + + protected int getParamCount() + { + return idata.argCount; + } + + protected int getParamAndVarCount() + { + return idata.argNames.length; + } + + protected String getParamOrVarName(int index) + { + return idata.argNames[index]; + } + + protected boolean getParamOrVarConst(int index) + { + return idata.argIsConst[index]; + } +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Interpreter.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Interpreter.java new file mode 100644 index 0000000..a68c025 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Interpreter.java @@ -0,0 +1,4643 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Patrick Beard + * Norris Boyd + * Igor Bukanov + * Ethan Hugg + * Bob Jervis + * Terry Lucas + * Roger Lawrence + * Milen Nankov + * Hannes Wallnoefer + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.PrintStream; +import java.io.Serializable; +import java.util.List; +import java.util.ArrayList; + +import org.mozilla.javascript.continuations.Continuation; +import org.mozilla.javascript.debug.DebugFrame; + +public class Interpreter implements Evaluator +{ + +// Additional interpreter-specific codes + + private static final int + + // Stack: ... value1 -> ... value1 value1 + Icode_DUP = -1, + + // Stack: ... value2 value1 -> ... value2 value1 value2 value1 + Icode_DUP2 = -2, + + // Stack: ... value2 value1 -> ... value1 value2 + Icode_SWAP = -3, + + // Stack: ... value1 -> ... + Icode_POP = -4, + + // Store stack top into return register and then pop it + Icode_POP_RESULT = -5, + + // To jump conditionally and pop additional stack value + Icode_IFEQ_POP = -6, + + // various types of ++/-- + Icode_VAR_INC_DEC = -7, + Icode_NAME_INC_DEC = -8, + Icode_PROP_INC_DEC = -9, + Icode_ELEM_INC_DEC = -10, + Icode_REF_INC_DEC = -11, + + // load/save scope from/to local + Icode_SCOPE_LOAD = -12, + Icode_SCOPE_SAVE = -13, + + Icode_TYPEOFNAME = -14, + + // helper for function calls + Icode_NAME_AND_THIS = -15, + Icode_PROP_AND_THIS = -16, + Icode_ELEM_AND_THIS = -17, + Icode_VALUE_AND_THIS = -18, + + // Create closure object for nested functions + Icode_CLOSURE_EXPR = -19, + Icode_CLOSURE_STMT = -20, + + // Special calls + Icode_CALLSPECIAL = -21, + + // To return undefined value + Icode_RETUNDEF = -22, + + // Exception handling implementation + Icode_GOSUB = -23, + Icode_STARTSUB = -24, + Icode_RETSUB = -25, + + // To indicating a line number change in icodes. + Icode_LINE = -26, + + // To store shorts and ints inline + Icode_SHORTNUMBER = -27, + Icode_INTNUMBER = -28, + + // To create and populate array to hold values for [] and {} literals + Icode_LITERAL_NEW = -29, + Icode_LITERAL_SET = -30, + + // Array literal with skipped index like [1,,2] + Icode_SPARE_ARRAYLIT = -31, + + // Load index register to prepare for the following index operation + Icode_REG_IND_C0 = -32, + Icode_REG_IND_C1 = -33, + Icode_REG_IND_C2 = -34, + Icode_REG_IND_C3 = -35, + Icode_REG_IND_C4 = -36, + Icode_REG_IND_C5 = -37, + Icode_REG_IND1 = -38, + Icode_REG_IND2 = -39, + Icode_REG_IND4 = -40, + + // Load string register to prepare for the following string operation + Icode_REG_STR_C0 = -41, + Icode_REG_STR_C1 = -42, + Icode_REG_STR_C2 = -43, + Icode_REG_STR_C3 = -44, + Icode_REG_STR1 = -45, + Icode_REG_STR2 = -46, + Icode_REG_STR4 = -47, + + // Version of getvar/setvar that read var index directly from bytecode + Icode_GETVAR1 = -48, + Icode_SETVAR1 = -49, + + // Load unefined + Icode_UNDEF = -50, + Icode_ZERO = -51, + Icode_ONE = -52, + + // entrance and exit from .() + Icode_ENTERDQ = -53, + Icode_LEAVEDQ = -54, + + Icode_TAIL_CALL = -55, + + // Clear local to allow GC its context + Icode_LOCAL_CLEAR = -56, + + // Literal get/set + Icode_LITERAL_GETTER = -57, + Icode_LITERAL_SETTER = -58, + + // const + Icode_SETCONST = -59, + Icode_SETCONSTVAR = -60, + Icode_SETCONSTVAR1 = -61, + + // Generator opcodes (along with Token.YIELD) + Icode_GENERATOR = -62, + Icode_GENERATOR_END = -63, + + Icode_DEBUGGER = -64, + + // Last icode + MIN_ICODE = -64; + + // data for parsing + + private CompilerEnvirons compilerEnv; + + private boolean itsInFunctionFlag; + private boolean itsInTryFlag; + + private InterpreterData itsData; + private ScriptOrFnNode scriptOrFn; + private int itsICodeTop; + private int itsStackDepth; + private int itsLineNumber; + private int itsDoubleTableTop; + private ObjToIntMap itsStrings = new ObjToIntMap(20); + private int itsLocalTop; + + private static final int MIN_LABEL_TABLE_SIZE = 32; + private static final int MIN_FIXUP_TABLE_SIZE = 40; + private int[] itsLabelTable; + private int itsLabelTableTop; +// itsFixupTable[i] = (label_index << 32) | fixup_site + private long[] itsFixupTable; + private int itsFixupTableTop; + private ObjArray itsLiteralIds = new ObjArray(); + + private int itsExceptionTableTop; + private static final int EXCEPTION_TRY_START_SLOT = 0; + private static final int EXCEPTION_TRY_END_SLOT = 1; + private static final int EXCEPTION_HANDLER_SLOT = 2; + private static final int EXCEPTION_TYPE_SLOT = 3; + private static final int EXCEPTION_LOCAL_SLOT = 4; + private static final int EXCEPTION_SCOPE_SLOT = 5; + // SLOT_SIZE: space for try start/end, handler, start, handler type, + // exception local and scope local + private static final int EXCEPTION_SLOT_SIZE = 6; + +// ECF_ or Expression Context Flags constants: for now only TAIL is available + private static final int ECF_TAIL = 1 << 0; + + /** + * Class to hold data corresponding to one interpreted call stack frame. + */ + private static class CallFrame implements Cloneable, Serializable + { + static final long serialVersionUID = -2843792508994958978L; + + CallFrame parentFrame; + // amount of stack frames before this one on the interpretation stack + int frameIndex; + // If true indicates read-only frame that is a part of continuation + boolean frozen; + + InterpretedFunction fnOrScript; + InterpreterData idata; + +// Stack structure +// stack[0 <= i < localShift]: arguments and local variables +// stack[localShift <= i <= emptyStackTop]: used for local temporaries +// stack[emptyStackTop < i < stack.length]: stack data +// sDbl[i]: if stack[i] is UniqueTag.DOUBLE_MARK, sDbl[i] holds the number value + + Object[] stack; + int[] stackAttributes; + double[] sDbl; + CallFrame varSource; // defaults to this unless continuation frame + int localShift; + int emptyStackTop; + + DebugFrame debuggerFrame; + boolean useActivation; + + Scriptable thisObj; + Scriptable[] scriptRegExps; + +// The values that change during interpretation + + Object result; + double resultDbl; + int pc; + int pcPrevBranch; + int pcSourceLineStart; + Scriptable scope; + + int savedStackTop; + int savedCallOp; + Object throwable; + + CallFrame cloneFrozen() + { + if (!frozen) Kit.codeBug(); + + CallFrame copy; + try { + copy = (CallFrame)clone(); + } catch (CloneNotSupportedException ex) { + throw new IllegalStateException(); + } + + // clone stack but keep varSource to point to values + // from this frame to share variables. + + copy.stack = stack.clone(); + copy.stackAttributes = stackAttributes.clone(); + copy.sDbl = sDbl.clone(); + + copy.frozen = false; + return copy; + } + } + + private static final class ContinuationJump implements Serializable + { + static final long serialVersionUID = 7687739156004308247L; + + CallFrame capturedFrame; + CallFrame branchFrame; + Object result; + double resultDbl; + + ContinuationJump(Continuation c, CallFrame current) + { + this.capturedFrame = (CallFrame)c.getImplementation(); + if (this.capturedFrame == null || current == null) { + // Continuation and current execution does not share + // any frames if there is nothing to capture or + // if there is no currently executed frames + this.branchFrame = null; + } else { + // Search for branch frame where parent frame chains starting + // from captured and current meet. + CallFrame chain1 = this.capturedFrame; + CallFrame chain2 = current; + + // First work parents of chain1 or chain2 until the same + // frame depth. + int diff = chain1.frameIndex - chain2.frameIndex; + if (diff != 0) { + if (diff < 0) { + // swap to make sure that + // chain1.frameIndex > chain2.frameIndex and diff > 0 + chain1 = current; + chain2 = this.capturedFrame; + diff = -diff; + } + do { + chain1 = chain1.parentFrame; + } while (--diff != 0); + if (chain1.frameIndex != chain2.frameIndex) Kit.codeBug(); + } + + // Now walk parents in parallel until a shared frame is found + // or until the root is reached. + while (chain1 != chain2 && chain1 != null) { + chain1 = chain1.parentFrame; + chain2 = chain2.parentFrame; + } + + this.branchFrame = chain1; + if (this.branchFrame != null && !this.branchFrame.frozen) + Kit.codeBug(); + } + } + } + + private static CallFrame captureFrameForGenerator(CallFrame frame) { + frame.frozen = true; + CallFrame result = frame.cloneFrozen(); + frame.frozen = false; + + // now isolate this frame from its previous context + result.parentFrame = null; + result.frameIndex = 0; + + return result; + } + + static { + // Checks for byte code consistencies, good compiler can eliminate them + + if (Token.LAST_BYTECODE_TOKEN > 127) { + String str = "Violation of Token.LAST_BYTECODE_TOKEN <= 127"; + System.err.println(str); + throw new IllegalStateException(str); + } + if (MIN_ICODE < -128) { + String str = "Violation of Interpreter.MIN_ICODE >= -128"; + System.err.println(str); + throw new IllegalStateException(str); + } + } + + private static String bytecodeName(int bytecode) + { + if (!validBytecode(bytecode)) { + throw new IllegalArgumentException(String.valueOf(bytecode)); + } + + if (!Token.printICode) { + return String.valueOf(bytecode); + } + + if (validTokenCode(bytecode)) { + return Token.name(bytecode); + } + + switch (bytecode) { + case Icode_DUP: return "DUP"; + case Icode_DUP2: return "DUP2"; + case Icode_SWAP: return "SWAP"; + case Icode_POP: return "POP"; + case Icode_POP_RESULT: return "POP_RESULT"; + case Icode_IFEQ_POP: return "IFEQ_POP"; + case Icode_VAR_INC_DEC: return "VAR_INC_DEC"; + case Icode_NAME_INC_DEC: return "NAME_INC_DEC"; + case Icode_PROP_INC_DEC: return "PROP_INC_DEC"; + case Icode_ELEM_INC_DEC: return "ELEM_INC_DEC"; + case Icode_REF_INC_DEC: return "REF_INC_DEC"; + case Icode_SCOPE_LOAD: return "SCOPE_LOAD"; + case Icode_SCOPE_SAVE: return "SCOPE_SAVE"; + case Icode_TYPEOFNAME: return "TYPEOFNAME"; + case Icode_NAME_AND_THIS: return "NAME_AND_THIS"; + case Icode_PROP_AND_THIS: return "PROP_AND_THIS"; + case Icode_ELEM_AND_THIS: return "ELEM_AND_THIS"; + case Icode_VALUE_AND_THIS: return "VALUE_AND_THIS"; + case Icode_CLOSURE_EXPR: return "CLOSURE_EXPR"; + case Icode_CLOSURE_STMT: return "CLOSURE_STMT"; + case Icode_CALLSPECIAL: return "CALLSPECIAL"; + case Icode_RETUNDEF: return "RETUNDEF"; + case Icode_GOSUB: return "GOSUB"; + case Icode_STARTSUB: return "STARTSUB"; + case Icode_RETSUB: return "RETSUB"; + case Icode_LINE: return "LINE"; + case Icode_SHORTNUMBER: return "SHORTNUMBER"; + case Icode_INTNUMBER: return "INTNUMBER"; + case Icode_LITERAL_NEW: return "LITERAL_NEW"; + case Icode_LITERAL_SET: return "LITERAL_SET"; + case Icode_SPARE_ARRAYLIT: return "SPARE_ARRAYLIT"; + case Icode_REG_IND_C0: return "REG_IND_C0"; + case Icode_REG_IND_C1: return "REG_IND_C1"; + case Icode_REG_IND_C2: return "REG_IND_C2"; + case Icode_REG_IND_C3: return "REG_IND_C3"; + case Icode_REG_IND_C4: return "REG_IND_C4"; + case Icode_REG_IND_C5: return "REG_IND_C5"; + case Icode_REG_IND1: return "LOAD_IND1"; + case Icode_REG_IND2: return "LOAD_IND2"; + case Icode_REG_IND4: return "LOAD_IND4"; + case Icode_REG_STR_C0: return "REG_STR_C0"; + case Icode_REG_STR_C1: return "REG_STR_C1"; + case Icode_REG_STR_C2: return "REG_STR_C2"; + case Icode_REG_STR_C3: return "REG_STR_C3"; + case Icode_REG_STR1: return "LOAD_STR1"; + case Icode_REG_STR2: return "LOAD_STR2"; + case Icode_REG_STR4: return "LOAD_STR4"; + case Icode_GETVAR1: return "GETVAR1"; + case Icode_SETVAR1: return "SETVAR1"; + case Icode_UNDEF: return "UNDEF"; + case Icode_ZERO: return "ZERO"; + case Icode_ONE: return "ONE"; + case Icode_ENTERDQ: return "ENTERDQ"; + case Icode_LEAVEDQ: return "LEAVEDQ"; + case Icode_TAIL_CALL: return "TAIL_CALL"; + case Icode_LOCAL_CLEAR: return "LOCAL_CLEAR"; + case Icode_LITERAL_GETTER: return "LITERAL_GETTER"; + case Icode_LITERAL_SETTER: return "LITERAL_SETTER"; + case Icode_SETCONST: return "SETCONST"; + case Icode_SETCONSTVAR: return "SETCONSTVAR"; + case Icode_SETCONSTVAR1: return "SETCONSTVAR1"; + case Icode_GENERATOR: return "GENERATOR"; + case Icode_GENERATOR_END: return "GENERATOR_END"; + case Icode_DEBUGGER: return "DEBUGGER"; + } + + // icode without name + throw new IllegalStateException(String.valueOf(bytecode)); + } + + private static boolean validIcode(int icode) + { + return MIN_ICODE <= icode && icode <= -1; + } + + private static boolean validTokenCode(int token) + { + return Token.FIRST_BYTECODE_TOKEN <= token + && token <= Token.LAST_BYTECODE_TOKEN; + } + + private static boolean validBytecode(int bytecode) + { + return validIcode(bytecode) || validTokenCode(bytecode); + } + + public Object compile(CompilerEnvirons compilerEnv, + ScriptOrFnNode tree, + String encodedSource, + boolean returnFunction) + { + this.compilerEnv = compilerEnv; + new NodeTransformer().transform(tree); + + if (Token.printTrees) { + /*APPJET*///System.out.println(tree.toStringTree(tree)); + } + + if (returnFunction) { + tree = tree.getFunctionNode(0); + } + + scriptOrFn = tree; + itsData = new InterpreterData(compilerEnv.getLanguageVersion(), + scriptOrFn.getSourceName(), + encodedSource); + itsData.topLevel = true; + + if (returnFunction) { + generateFunctionICode(); + } else { + generateICodeFromTree(scriptOrFn); + } + + return itsData; + } + + public Script createScriptObject(Object bytecode, Object staticSecurityDomain) + { + if(bytecode != itsData) + { + Kit.codeBug(); + } + return InterpretedFunction.createScript(itsData, + staticSecurityDomain); + } + + public void setEvalScriptFlag(Script script) { + ((InterpretedFunction)script).idata.evalScriptFlag = true; + } + + + public Function createFunctionObject(Context cx, Scriptable scope, + Object bytecode, Object staticSecurityDomain) + { + if(bytecode != itsData) + { + Kit.codeBug(); + } + return InterpretedFunction.createFunction(cx, scope, itsData, + staticSecurityDomain); + } + + private void generateFunctionICode() + { + itsInFunctionFlag = true; + + FunctionNode theFunction = (FunctionNode)scriptOrFn; + + itsData.itsFunctionType = theFunction.getFunctionType(); + itsData.itsNeedsActivation = theFunction.requiresActivation(); + itsData.itsName = theFunction.getFunctionName(); + if (!theFunction.getIgnoreDynamicScope()) { + if (compilerEnv.isUseDynamicScope()) { + itsData.useDynamicScope = true; + } + } + if (theFunction.isGenerator()) { + addIcode(Icode_GENERATOR); + addUint16(theFunction.getBaseLineno() & 0xFFFF); + } + + generateICodeFromTree(theFunction.getLastChild()); + } + + private void generateICodeFromTree(Node tree) + { + generateNestedFunctions(); + + generateRegExpLiterals(); + + visitStatement(tree, 0); + fixLabelGotos(); + // add RETURN_RESULT only to scripts as function always ends with RETURN + if (itsData.itsFunctionType == 0) { + addToken(Token.RETURN_RESULT); + } + + if (itsData.itsICode.length != itsICodeTop) { + // Make itsData.itsICode length exactly itsICodeTop to save memory + // and catch bugs with jumps beyond icode as early as possible + byte[] tmp = new byte[itsICodeTop]; + System.arraycopy(itsData.itsICode, 0, tmp, 0, itsICodeTop); + itsData.itsICode = tmp; + } + if (itsStrings.size() == 0) { + itsData.itsStringTable = null; + } else { + itsData.itsStringTable = new String[itsStrings.size()]; + ObjToIntMap.Iterator iter = itsStrings.newIterator(); + for (iter.start(); !iter.done(); iter.next()) { + String str = (String)iter.getKey(); + int index = iter.getValue(); + if (itsData.itsStringTable[index] != null) Kit.codeBug(); + itsData.itsStringTable[index] = str; + } + } + if (itsDoubleTableTop == 0) { + itsData.itsDoubleTable = null; + } else if (itsData.itsDoubleTable.length != itsDoubleTableTop) { + double[] tmp = new double[itsDoubleTableTop]; + System.arraycopy(itsData.itsDoubleTable, 0, tmp, 0, + itsDoubleTableTop); + itsData.itsDoubleTable = tmp; + } + if (itsExceptionTableTop != 0 + && itsData.itsExceptionTable.length != itsExceptionTableTop) + { + int[] tmp = new int[itsExceptionTableTop]; + System.arraycopy(itsData.itsExceptionTable, 0, tmp, 0, + itsExceptionTableTop); + itsData.itsExceptionTable = tmp; + } + + itsData.itsMaxVars = scriptOrFn.getParamAndVarCount(); + // itsMaxFrameArray: interpret method needs this amount for its + // stack and sDbl arrays + itsData.itsMaxFrameArray = itsData.itsMaxVars + + itsData.itsMaxLocals + + itsData.itsMaxStack; + + itsData.argNames = scriptOrFn.getParamAndVarNames(); + itsData.argIsConst = scriptOrFn.getParamAndVarConst(); + itsData.argCount = scriptOrFn.getParamCount(); + + itsData.encodedSourceStart = scriptOrFn.getEncodedSourceStart(); + itsData.encodedSourceEnd = scriptOrFn.getEncodedSourceEnd(); + + if (itsLiteralIds.size() != 0) { + itsData.literalIds = itsLiteralIds.toArray(); + } + + if (Token.printICode) dumpICode(itsData); + } + + private void generateNestedFunctions() + { + int functionCount = scriptOrFn.getFunctionCount(); + if (functionCount == 0) return; + + InterpreterData[] array = new InterpreterData[functionCount]; + for (int i = 0; i != functionCount; i++) { + FunctionNode def = scriptOrFn.getFunctionNode(i); + Interpreter jsi = new Interpreter(); + jsi.compilerEnv = compilerEnv; + jsi.scriptOrFn = def; + jsi.itsData = new InterpreterData(itsData); + jsi.generateFunctionICode(); + array[i] = jsi.itsData; + } + itsData.itsNestedFunctions = array; + } + + private void generateRegExpLiterals() + { + int N = scriptOrFn.getRegexpCount(); + if (N == 0) return; + + Context cx = Context.getContext(); + RegExpProxy rep = ScriptRuntime.checkRegExpProxy(cx); + Object[] array = new Object[N]; + for (int i = 0; i != N; i++) { + String string = scriptOrFn.getRegexpString(i); + String flags = scriptOrFn.getRegexpFlags(i); + array[i] = rep.compileRegExp(cx, string, flags); + } + itsData.itsRegExpLiterals = array; + } + + private void updateLineNumber(Node node) + { + int lineno = node.getLineno(); + if (lineno != itsLineNumber && lineno >= 0) { + if (itsData.firstLinePC < 0) { + itsData.firstLinePC = lineno; + } + itsLineNumber = lineno; + addIcode(Icode_LINE); + addUint16(lineno & 0xFFFF); + } + } + + private RuntimeException badTree(Node node) + { + throw new RuntimeException(node.toString()); + } + + private void visitStatement(Node node, int initialStackDepth) + { + int type = node.getType(); + Node child = node.getFirstChild(); + switch (type) { + + case Token.FUNCTION: + { + int fnIndex = node.getExistingIntProp(Node.FUNCTION_PROP); + int fnType = scriptOrFn.getFunctionNode(fnIndex). + getFunctionType(); + // Only function expressions or function expression + // statements need closure code creating new function + // object on stack as function statements are initialized + // at script/function start. + // In addition, function expressions can not be present here + // at statement level, they must only be present as expressions. + if (fnType == FunctionNode.FUNCTION_EXPRESSION_STATEMENT) { + addIndexOp(Icode_CLOSURE_STMT, fnIndex); + } else { + if (fnType != FunctionNode.FUNCTION_STATEMENT) { + throw Kit.codeBug(); + } + } + // For function statements or function expression statements + // in scripts, we need to ensure that the result of the script + // is the function if it is the last statement in the script. + // For example, eval("function () {}") should return a + // function, not undefined. + if (!itsInFunctionFlag) { + addIndexOp(Icode_CLOSURE_EXPR, fnIndex); + stackChange(1); + addIcode(Icode_POP_RESULT); + stackChange(-1); + } + } + break; + + case Token.LABEL: + case Token.LOOP: + case Token.BLOCK: + case Token.EMPTY: + case Token.WITH: + updateLineNumber(node); + case Token.SCRIPT: + // fall through + while (child != null) { + visitStatement(child, initialStackDepth); + child = child.getNext(); + } + break; + + case Token.ENTERWITH: + visitExpression(child, 0); + addToken(Token.ENTERWITH); + stackChange(-1); + break; + + case Token.LEAVEWITH: + addToken(Token.LEAVEWITH); + break; + + case Token.LOCAL_BLOCK: + { + int local = allocLocal(); + node.putIntProp(Node.LOCAL_PROP, local); + updateLineNumber(node); + while (child != null) { + visitStatement(child, initialStackDepth); + child = child.getNext(); + } + addIndexOp(Icode_LOCAL_CLEAR, local); + releaseLocal(local); + } + break; + + case Token.DEBUGGER: + addIcode(Icode_DEBUGGER); + break; + + case Token.SWITCH: + updateLineNumber(node); + // See comments in IRFactory.createSwitch() for description + // of SWITCH node + { + visitExpression(child, 0); + for (Node.Jump caseNode = (Node.Jump)child.getNext(); + caseNode != null; + caseNode = (Node.Jump)caseNode.getNext()) + { + if (caseNode.getType() != Token.CASE) + throw badTree(caseNode); + Node test = caseNode.getFirstChild(); + addIcode(Icode_DUP); + stackChange(1); + visitExpression(test, 0); + addToken(Token.SHEQ); + stackChange(-1); + // If true, Icode_IFEQ_POP will jump and remove case + // value from stack + addGoto(caseNode.target, Icode_IFEQ_POP); + stackChange(-1); + } + addIcode(Icode_POP); + stackChange(-1); + } + break; + + case Token.TARGET: + markTargetLabel(node); + break; + + case Token.IFEQ : + case Token.IFNE : + { + Node target = ((Node.Jump)node).target; + visitExpression(child, 0); + addGoto(target, type); + stackChange(-1); + } + break; + + case Token.GOTO: + { + Node target = ((Node.Jump)node).target; + addGoto(target, type); + } + break; + + case Token.JSR: + { + Node target = ((Node.Jump)node).target; + addGoto(target, Icode_GOSUB); + } + break; + + case Token.FINALLY: + { + // Account for incomming GOTOSUB address + stackChange(1); + int finallyRegister = getLocalBlockRef(node); + addIndexOp(Icode_STARTSUB, finallyRegister); + stackChange(-1); + while (child != null) { + visitStatement(child, initialStackDepth); + child = child.getNext(); + } + addIndexOp(Icode_RETSUB, finallyRegister); + } + break; + + case Token.EXPR_VOID: + case Token.EXPR_RESULT: + updateLineNumber(node); + visitExpression(child, 0); + addIcode((type == Token.EXPR_VOID) ? Icode_POP : Icode_POP_RESULT); + stackChange(-1); + break; + + case Token.TRY: + { + Node.Jump tryNode = (Node.Jump)node; + int exceptionObjectLocal = getLocalBlockRef(tryNode); + int scopeLocal = allocLocal(); + + addIndexOp(Icode_SCOPE_SAVE, scopeLocal); + + int tryStart = itsICodeTop; + boolean savedFlag = itsInTryFlag; + itsInTryFlag = true; + while (child != null) { + visitStatement(child, initialStackDepth); + child = child.getNext(); + } + itsInTryFlag = savedFlag; + + Node catchTarget = tryNode.target; + if (catchTarget != null) { + int catchStartPC + = itsLabelTable[getTargetLabel(catchTarget)]; + addExceptionHandler( + tryStart, catchStartPC, catchStartPC, + false, exceptionObjectLocal, scopeLocal); + } + Node finallyTarget = tryNode.getFinally(); + if (finallyTarget != null) { + int finallyStartPC + = itsLabelTable[getTargetLabel(finallyTarget)]; + addExceptionHandler( + tryStart, finallyStartPC, finallyStartPC, + true, exceptionObjectLocal, scopeLocal); + } + + addIndexOp(Icode_LOCAL_CLEAR, scopeLocal); + releaseLocal(scopeLocal); + } + break; + + case Token.CATCH_SCOPE: + { + int localIndex = getLocalBlockRef(node); + int scopeIndex = node.getExistingIntProp(Node.CATCH_SCOPE_PROP); + String name = child.getString(); + child = child.getNext(); + visitExpression(child, 0); // load expression object + addStringPrefix(name); + addIndexPrefix(localIndex); + addToken(Token.CATCH_SCOPE); + addUint8(scopeIndex != 0 ? 1 : 0); + stackChange(-1); + } + break; + + case Token.THROW: + updateLineNumber(node); + visitExpression(child, 0); + addToken(Token.THROW); + addUint16(itsLineNumber & 0xFFFF); + stackChange(-1); + break; + + case Token.RETHROW: + updateLineNumber(node); + addIndexOp(Token.RETHROW, getLocalBlockRef(node)); + break; + + case Token.RETURN: + updateLineNumber(node); + if (node.getIntProp(Node.GENERATOR_END_PROP, 0) != 0) { + // We're in a generator, so change RETURN to GENERATOR_END + addIcode(Icode_GENERATOR_END); + addUint16(itsLineNumber & 0xFFFF); + } else if (child != null) { + visitExpression(child, ECF_TAIL); + addToken(Token.RETURN); + stackChange(-1); + } else { + addIcode(Icode_RETUNDEF); + } + break; + + case Token.RETURN_RESULT: + updateLineNumber(node); + addToken(Token.RETURN_RESULT); + break; + + case Token.ENUM_INIT_KEYS: + case Token.ENUM_INIT_VALUES: + case Token.ENUM_INIT_ARRAY: + visitExpression(child, 0); + addIndexOp(type, getLocalBlockRef(node)); + stackChange(-1); + break; + + case Icode_GENERATOR: + break; + + default: + throw badTree(node); + } + + if (itsStackDepth != initialStackDepth) { + throw Kit.codeBug(); + } + } + + private void visitExpression(Node node, int contextFlags) + { + int type = node.getType(); + Node child = node.getFirstChild(); + int savedStackDepth = itsStackDepth; + switch (type) { + + case Token.FUNCTION: + { + int fnIndex = node.getExistingIntProp(Node.FUNCTION_PROP); + FunctionNode fn = scriptOrFn.getFunctionNode(fnIndex); + // See comments in visitStatement for Token.FUNCTION case + if (fn.getFunctionType() != FunctionNode.FUNCTION_EXPRESSION) { + throw Kit.codeBug(); + } + addIndexOp(Icode_CLOSURE_EXPR, fnIndex); + stackChange(1); + } + break; + + case Token.LOCAL_LOAD: + { + int localIndex = getLocalBlockRef(node); + addIndexOp(Token.LOCAL_LOAD, localIndex); + stackChange(1); + } + break; + + case Token.COMMA: + { + Node lastChild = node.getLastChild(); + while (child != lastChild) { + visitExpression(child, 0); + addIcode(Icode_POP); + stackChange(-1); + child = child.getNext(); + } + // Preserve tail context flag if any + visitExpression(child, contextFlags & ECF_TAIL); + } + break; + + case Token.USE_STACK: + // Indicates that stack was modified externally, + // like placed catch object + stackChange(1); + break; + + case Token.REF_CALL: + case Token.CALL: + case Token.NEW: + { + if (type == Token.NEW) { + visitExpression(child, 0); + } else { + generateCallFunAndThis(child); + } + int argCount = 0; + while ((child = child.getNext()) != null) { + visitExpression(child, 0); + ++argCount; + } + int callType = node.getIntProp(Node.SPECIALCALL_PROP, + Node.NON_SPECIALCALL); + if (callType != Node.NON_SPECIALCALL) { + // embed line number and source filename + addIndexOp(Icode_CALLSPECIAL, argCount); + addUint8(callType); + addUint8(type == Token.NEW ? 1 : 0); + addUint16(itsLineNumber & 0xFFFF); + } else { + // Only use the tail call optimization if we're not in a try + // or we're not generating debug info (since the + // optimization will confuse the debugger) + if (type == Token.CALL && (contextFlags & ECF_TAIL) != 0 && + !compilerEnv.isGenerateDebugInfo() && !itsInTryFlag) + { + type = Icode_TAIL_CALL; + } + addIndexOp(type, argCount); + } + // adjust stack + if (type == Token.NEW) { + // new: f, args -> result + stackChange(-argCount); + } else { + // call: f, thisObj, args -> result + // ref_call: f, thisObj, args -> ref + stackChange(-1 - argCount); + } + if (argCount > itsData.itsMaxCalleeArgs) { + itsData.itsMaxCalleeArgs = argCount; + } + } + break; + + case Token.AND: + case Token.OR: + { + visitExpression(child, 0); + addIcode(Icode_DUP); + stackChange(1); + int afterSecondJumpStart = itsICodeTop; + int jump = (type == Token.AND) ? Token.IFNE : Token.IFEQ; + addGotoOp(jump); + stackChange(-1); + addIcode(Icode_POP); + stackChange(-1); + child = child.getNext(); + // Preserve tail context flag if any + visitExpression(child, contextFlags & ECF_TAIL); + resolveForwardGoto(afterSecondJumpStart); + } + break; + + case Token.HOOK: + { + Node ifThen = child.getNext(); + Node ifElse = ifThen.getNext(); + visitExpression(child, 0); + int elseJumpStart = itsICodeTop; + addGotoOp(Token.IFNE); + stackChange(-1); + // Preserve tail context flag if any + visitExpression(ifThen, contextFlags & ECF_TAIL); + int afterElseJumpStart = itsICodeTop; + addGotoOp(Token.GOTO); + resolveForwardGoto(elseJumpStart); + itsStackDepth = savedStackDepth; + // Preserve tail context flag if any + visitExpression(ifElse, contextFlags & ECF_TAIL); + resolveForwardGoto(afterElseJumpStart); + } + break; + + case Token.GETPROP: + case Token.GETPROPNOWARN: + visitExpression(child, 0); + child = child.getNext(); + addStringOp(type, child.getString()); + break; + + case Token.GETELEM: + case Token.DELPROP: + case Token.BITAND: + case Token.BITOR: + case Token.BITXOR: + case Token.LSH: + case Token.RSH: + case Token.URSH: + case Token.ADD: + case Token.SUB: + case Token.MOD: + case Token.DIV: + case Token.MUL: + case Token.EQ: + case Token.NE: + case Token.SHEQ: + case Token.SHNE: + case Token.IN: + case Token.INSTANCEOF: + case Token.LE: + case Token.LT: + case Token.GE: + case Token.GT: + visitExpression(child, 0); + child = child.getNext(); + visitExpression(child, 0); + addToken(type); + stackChange(-1); + break; + + case Token.POS: + case Token.NEG: + case Token.NOT: + case Token.BITNOT: + case Token.TYPEOF: + case Token.VOID: + visitExpression(child, 0); + if (type == Token.VOID) { + addIcode(Icode_POP); + addIcode(Icode_UNDEF); + } else { + addToken(type); + } + break; + + case Token.GET_REF: + case Token.DEL_REF: + visitExpression(child, 0); + addToken(type); + break; + + case Token.SETPROP: + case Token.SETPROP_OP: + { + visitExpression(child, 0); + child = child.getNext(); + String property = child.getString(); + child = child.getNext(); + if (type == Token.SETPROP_OP) { + addIcode(Icode_DUP); + stackChange(1); + addStringOp(Token.GETPROP, property); + // Compensate for the following USE_STACK + stackChange(-1); + } + visitExpression(child, 0); + addStringOp(Token.SETPROP, property); + stackChange(-1); + } + break; + + case Token.SETELEM: + case Token.SETELEM_OP: + visitExpression(child, 0); + child = child.getNext(); + visitExpression(child, 0); + child = child.getNext(); + if (type == Token.SETELEM_OP) { + addIcode(Icode_DUP2); + stackChange(2); + addToken(Token.GETELEM); + stackChange(-1); + // Compensate for the following USE_STACK + stackChange(-1); + } + visitExpression(child, 0); + addToken(Token.SETELEM); + stackChange(-2); + break; + + case Token.SET_REF: + case Token.SET_REF_OP: + visitExpression(child, 0); + child = child.getNext(); + if (type == Token.SET_REF_OP) { + addIcode(Icode_DUP); + stackChange(1); + addToken(Token.GET_REF); + // Compensate for the following USE_STACK + stackChange(-1); + } + visitExpression(child, 0); + addToken(Token.SET_REF); + stackChange(-1); + break; + + case Token.SETNAME: + { + String name = child.getString(); + visitExpression(child, 0); + child = child.getNext(); + visitExpression(child, 0); + addStringOp(Token.SETNAME, name); + stackChange(-1); + } + break; + + case Token.SETCONST: + { + String name = child.getString(); + visitExpression(child, 0); + child = child.getNext(); + visitExpression(child, 0); + addStringOp(Icode_SETCONST, name); + stackChange(-1); + } + break; + + case Token.TYPEOFNAME: + { + int index = -1; + // use typeofname if an activation frame exists + // since the vars all exist there instead of in jregs + if (itsInFunctionFlag && !itsData.itsNeedsActivation) + index = scriptOrFn.getIndexForNameNode(node); + if (index == -1) { + addStringOp(Icode_TYPEOFNAME, node.getString()); + stackChange(1); + } else { + addVarOp(Token.GETVAR, index); + stackChange(1); + addToken(Token.TYPEOF); + } + } + break; + + case Token.BINDNAME: + case Token.NAME: + case Token.STRING: + addStringOp(type, node.getString()); + stackChange(1); + break; + + case Token.INC: + case Token.DEC: + visitIncDec(node, child); + break; + + case Token.NUMBER: + { + double num = node.getDouble(); + int inum = (int)num; + if (inum == num) { + if (inum == 0) { + addIcode(Icode_ZERO); + // Check for negative zero + if (1.0 / num < 0.0) { + addToken(Token.NEG); + } + } else if (inum == 1) { + addIcode(Icode_ONE); + } else if ((short)inum == inum) { + addIcode(Icode_SHORTNUMBER); + // write short as uin16 bit pattern + addUint16(inum & 0xFFFF); + } else { + addIcode(Icode_INTNUMBER); + addInt(inum); + } + } else { + int index = getDoubleIndex(num); + addIndexOp(Token.NUMBER, index); + } + stackChange(1); + } + break; + + case Token.GETVAR: + { + if (itsData.itsNeedsActivation) Kit.codeBug(); + int index = scriptOrFn.getIndexForNameNode(node); + addVarOp(Token.GETVAR, index); + stackChange(1); + } + break; + + case Token.SETVAR: + { + if (itsData.itsNeedsActivation) Kit.codeBug(); + int index = scriptOrFn.getIndexForNameNode(child); + child = child.getNext(); + visitExpression(child, 0); + addVarOp(Token.SETVAR, index); + } + break; + + case Token.SETCONSTVAR: + { + if (itsData.itsNeedsActivation) Kit.codeBug(); + int index = scriptOrFn.getIndexForNameNode(child); + child = child.getNext(); + visitExpression(child, 0); + addVarOp(Token.SETCONSTVAR, index); + } + break; + + case Token.NULL: + case Token.THIS: + case Token.THISFN: + case Token.FALSE: + case Token.TRUE: + addToken(type); + stackChange(1); + break; + + case Token.ENUM_NEXT: + case Token.ENUM_ID: + addIndexOp(type, getLocalBlockRef(node)); + stackChange(1); + break; + + case Token.REGEXP: + { + int index = node.getExistingIntProp(Node.REGEXP_PROP); + addIndexOp(Token.REGEXP, index); + stackChange(1); + } + break; + + case Token.ARRAYLIT: + case Token.OBJECTLIT: + visitLiteral(node, child); + break; + + case Token.ARRAYCOMP: + visitArrayComprehension(node, child, child.getNext()); + break; + + case Token.REF_SPECIAL: + visitExpression(child, 0); + addStringOp(type, (String)node.getProp(Node.NAME_PROP)); + break; + + case Token.REF_MEMBER: + case Token.REF_NS_MEMBER: + case Token.REF_NAME: + case Token.REF_NS_NAME: + { + int memberTypeFlags = node.getIntProp(Node.MEMBER_TYPE_PROP, 0); + // generate possible target, possible namespace and member + int childCount = 0; + do { + visitExpression(child, 0); + ++childCount; + child = child.getNext(); + } while (child != null); + addIndexOp(type, memberTypeFlags); + stackChange(1 - childCount); + } + break; + + case Token.DOTQUERY: + { + int queryPC; + updateLineNumber(node); + visitExpression(child, 0); + addIcode(Icode_ENTERDQ); + stackChange(-1); + queryPC = itsICodeTop; + visitExpression(child.getNext(), 0); + addBackwardGoto(Icode_LEAVEDQ, queryPC); + } + break; + + case Token.DEFAULTNAMESPACE : + case Token.ESCXMLATTR : + case Token.ESCXMLTEXT : + visitExpression(child, 0); + addToken(type); + break; + + case Token.YIELD: + if (child != null) { + visitExpression(child, 0); + } else { + addIcode(Icode_UNDEF); + stackChange(1); + } + addToken(Token.YIELD); + addUint16(node.getLineno() & 0xFFFF); + break; + + case Token.WITHEXPR: { + Node enterWith = node.getFirstChild(); + Node with = enterWith.getNext(); + visitExpression(enterWith.getFirstChild(), 0); + addToken(Token.ENTERWITH); + stackChange(-1); + visitExpression(with.getFirstChild(), 0); + addToken(Token.LEAVEWITH); + break; + } + + default: + throw badTree(node); + } + if (savedStackDepth + 1 != itsStackDepth) { + Kit.codeBug(); + } + } + + private void generateCallFunAndThis(Node left) + { + // Generate code to place on stack function and thisObj + int type = left.getType(); + switch (type) { + case Token.NAME: { + String name = left.getString(); + // stack: ... -> ... function thisObj + addStringOp(Icode_NAME_AND_THIS, name); + stackChange(2); + break; + } + case Token.GETPROP: + case Token.GETELEM: { + Node target = left.getFirstChild(); + visitExpression(target, 0); + Node id = target.getNext(); + if (type == Token.GETPROP) { + String property = id.getString(); + // stack: ... target -> ... function thisObj + addStringOp(Icode_PROP_AND_THIS, property); + stackChange(1); + } else { + visitExpression(id, 0); + // stack: ... target id -> ... function thisObj + addIcode(Icode_ELEM_AND_THIS); + } + break; + } + default: + // Including Token.GETVAR + visitExpression(left, 0); + // stack: ... value -> ... function thisObj + addIcode(Icode_VALUE_AND_THIS); + stackChange(1); + break; + } + } + + private void visitIncDec(Node node, Node child) + { + int incrDecrMask = node.getExistingIntProp(Node.INCRDECR_PROP); + int childType = child.getType(); + switch (childType) { + case Token.GETVAR : { + if (itsData.itsNeedsActivation) Kit.codeBug(); + int i = scriptOrFn.getIndexForNameNode(child); + addVarOp(Icode_VAR_INC_DEC, i); + addUint8(incrDecrMask); + stackChange(1); + break; + } + case Token.NAME : { + String name = child.getString(); + addStringOp(Icode_NAME_INC_DEC, name); + addUint8(incrDecrMask); + stackChange(1); + break; + } + case Token.GETPROP : { + Node object = child.getFirstChild(); + visitExpression(object, 0); + String property = object.getNext().getString(); + addStringOp(Icode_PROP_INC_DEC, property); + addUint8(incrDecrMask); + break; + } + case Token.GETELEM : { + Node object = child.getFirstChild(); + visitExpression(object, 0); + Node index = object.getNext(); + visitExpression(index, 0); + addIcode(Icode_ELEM_INC_DEC); + addUint8(incrDecrMask); + stackChange(-1); + break; + } + case Token.GET_REF : { + Node ref = child.getFirstChild(); + visitExpression(ref, 0); + addIcode(Icode_REF_INC_DEC); + addUint8(incrDecrMask); + break; + } + default : { + throw badTree(node); + } + } + } + + private void visitLiteral(Node node, Node child) + { + int type = node.getType(); + int count; + Object[] propertyIds = null; + if (type == Token.ARRAYLIT) { + count = 0; + for (Node n = child; n != null; n = n.getNext()) { + ++count; + } + } else if (type == Token.OBJECTLIT) { + propertyIds = (Object[])node.getProp(Node.OBJECT_IDS_PROP); + count = propertyIds.length; + } else { + throw badTree(node); + } + addIndexOp(Icode_LITERAL_NEW, count); + stackChange(2); + while (child != null) { + int childType = child.getType(); + if (childType == Token.GET) { + visitExpression(child.getFirstChild(), 0); + addIcode(Icode_LITERAL_GETTER); + } else if (childType == Token.SET) { + visitExpression(child.getFirstChild(), 0); + addIcode(Icode_LITERAL_SETTER); + } else { + visitExpression(child, 0); + addIcode(Icode_LITERAL_SET); + } + stackChange(-1); + child = child.getNext(); + } + if (type == Token.ARRAYLIT) { + int[] skipIndexes = (int[])node.getProp(Node.SKIP_INDEXES_PROP); + if (skipIndexes == null) { + addToken(Token.ARRAYLIT); + } else { + int index = itsLiteralIds.size(); + itsLiteralIds.add(skipIndexes); + addIndexOp(Icode_SPARE_ARRAYLIT, index); + } + } else { + int index = itsLiteralIds.size(); + itsLiteralIds.add(propertyIds); + addIndexOp(Token.OBJECTLIT, index); + } + stackChange(-1); + } + + private void visitArrayComprehension(Node node, Node initStmt, Node expr) + { + // A bit of a hack: array comprehensions are implemented using + // statement nodes for the iteration, yet they appear in an + // expression context. So we pass the current stack depth to + // visitStatement so it can check that the depth is not altered + // by statements. + visitStatement(initStmt, itsStackDepth); + visitExpression(expr, 0); + } + + private int getLocalBlockRef(Node node) + { + Node localBlock = (Node)node.getProp(Node.LOCAL_BLOCK_PROP); + return localBlock.getExistingIntProp(Node.LOCAL_PROP); + } + + private int getTargetLabel(Node target) + { + int label = target.labelId(); + if (label != -1) { + return label; + } + label = itsLabelTableTop; + if (itsLabelTable == null || label == itsLabelTable.length) { + if (itsLabelTable == null) { + itsLabelTable = new int[MIN_LABEL_TABLE_SIZE]; + }else { + int[] tmp = new int[itsLabelTable.length * 2]; + System.arraycopy(itsLabelTable, 0, tmp, 0, label); + itsLabelTable = tmp; + } + } + itsLabelTableTop = label + 1; + itsLabelTable[label] = -1; + + target.labelId(label); + return label; + } + + private void markTargetLabel(Node target) + { + int label = getTargetLabel(target); + if (itsLabelTable[label] != -1) { + // Can mark label only once + Kit.codeBug(); + } + itsLabelTable[label] = itsICodeTop; + } + + private void addGoto(Node target, int gotoOp) + { + int label = getTargetLabel(target); + if (!(label < itsLabelTableTop)) Kit.codeBug(); + int targetPC = itsLabelTable[label]; + + if (targetPC != -1) { + addBackwardGoto(gotoOp, targetPC); + } else { + int gotoPC = itsICodeTop; + addGotoOp(gotoOp); + int top = itsFixupTableTop; + if (itsFixupTable == null || top == itsFixupTable.length) { + if (itsFixupTable == null) { + itsFixupTable = new long[MIN_FIXUP_TABLE_SIZE]; + } else { + long[] tmp = new long[itsFixupTable.length * 2]; + System.arraycopy(itsFixupTable, 0, tmp, 0, top); + itsFixupTable = tmp; + } + } + itsFixupTableTop = top + 1; + itsFixupTable[top] = ((long)label << 32) | gotoPC; + } + } + + private void fixLabelGotos() + { + for (int i = 0; i < itsFixupTableTop; i++) { + long fixup = itsFixupTable[i]; + int label = (int)(fixup >> 32); + int jumpSource = (int)fixup; + int pc = itsLabelTable[label]; + if (pc == -1) { + // Unlocated label + throw Kit.codeBug(); + } + resolveGoto(jumpSource, pc); + } + itsFixupTableTop = 0; + } + + private void addBackwardGoto(int gotoOp, int jumpPC) + { + int fromPC = itsICodeTop; + // Ensure that this is a jump backward + if (fromPC <= jumpPC) throw Kit.codeBug(); + addGotoOp(gotoOp); + resolveGoto(fromPC, jumpPC); + } + + private void resolveForwardGoto(int fromPC) + { + // Ensure that forward jump skips at least self bytecode + if (itsICodeTop < fromPC + 3) throw Kit.codeBug(); + resolveGoto(fromPC, itsICodeTop); + } + + private void resolveGoto(int fromPC, int jumpPC) + { + int offset = jumpPC - fromPC; + // Ensure that jumps do not overlap + if (0 <= offset && offset <= 2) throw Kit.codeBug(); + int offsetSite = fromPC + 1; + if (offset != (short)offset) { + if (itsData.longJumps == null) { + itsData.longJumps = new UintMap(); + } + itsData.longJumps.put(offsetSite, jumpPC); + offset = 0; + } + byte[] array = itsData.itsICode; + array[offsetSite] = (byte)(offset >> 8); + array[offsetSite + 1] = (byte)offset; + } + + private void addToken(int token) + { + if (!validTokenCode(token)) throw Kit.codeBug(); + addUint8(token); + } + + private void addIcode(int icode) + { + if (!validIcode(icode)) throw Kit.codeBug(); + // Write negative icode as uint8 bits + addUint8(icode & 0xFF); + } + + private void addUint8(int value) + { + if ((value & ~0xFF) != 0) throw Kit.codeBug(); + byte[] array = itsData.itsICode; + int top = itsICodeTop; + if (top == array.length) { + array = increaseICodeCapacity(1); + } + array[top] = (byte)value; + itsICodeTop = top + 1; + } + + private void addUint16(int value) + { + if ((value & ~0xFFFF) != 0) throw Kit.codeBug(); + byte[] array = itsData.itsICode; + int top = itsICodeTop; + if (top + 2 > array.length) { + array = increaseICodeCapacity(2); + } + array[top] = (byte)(value >>> 8); + array[top + 1] = (byte)value; + itsICodeTop = top + 2; + } + + private void addInt(int i) + { + byte[] array = itsData.itsICode; + int top = itsICodeTop; + if (top + 4 > array.length) { + array = increaseICodeCapacity(4); + } + array[top] = (byte)(i >>> 24); + array[top + 1] = (byte)(i >>> 16); + array[top + 2] = (byte)(i >>> 8); + array[top + 3] = (byte)i; + itsICodeTop = top + 4; + } + + private int getDoubleIndex(double num) + { + int index = itsDoubleTableTop; + if (index == 0) { + itsData.itsDoubleTable = new double[64]; + } else if (itsData.itsDoubleTable.length == index) { + double[] na = new double[index * 2]; + System.arraycopy(itsData.itsDoubleTable, 0, na, 0, index); + itsData.itsDoubleTable = na; + } + itsData.itsDoubleTable[index] = num; + itsDoubleTableTop = index + 1; + return index; + } + + private void addGotoOp(int gotoOp) + { + byte[] array = itsData.itsICode; + int top = itsICodeTop; + if (top + 3 > array.length) { + array = increaseICodeCapacity(3); + } + array[top] = (byte)gotoOp; + // Offset would written later + itsICodeTop = top + 1 + 2; + } + + private void addVarOp(int op, int varIndex) + { + switch (op) { + case Token.SETCONSTVAR: + if (varIndex < 128) { + addIcode(Icode_SETCONSTVAR1); + addUint8(varIndex); + return; + } + addIndexOp(Icode_SETCONSTVAR, varIndex); + return; + case Token.GETVAR: + case Token.SETVAR: + if (varIndex < 128) { + addIcode(op == Token.GETVAR ? Icode_GETVAR1 : Icode_SETVAR1); + addUint8(varIndex); + return; + } + // fallthrough + case Icode_VAR_INC_DEC: + addIndexOp(op, varIndex); + return; + } + throw Kit.codeBug(); + } + + private void addStringOp(int op, String str) + { + addStringPrefix(str); + if (validIcode(op)) { + addIcode(op); + } else { + addToken(op); + } + } + + private void addIndexOp(int op, int index) + { + addIndexPrefix(index); + if (validIcode(op)) { + addIcode(op); + } else { + addToken(op); + } + } + + private void addStringPrefix(String str) + { + int index = itsStrings.get(str, -1); + if (index == -1) { + index = itsStrings.size(); + itsStrings.put(str, index); + } + if (index < 4) { + addIcode(Icode_REG_STR_C0 - index); + } else if (index <= 0xFF) { + addIcode(Icode_REG_STR1); + addUint8(index); + } else if (index <= 0xFFFF) { + addIcode(Icode_REG_STR2); + addUint16(index); + } else { + addIcode(Icode_REG_STR4); + addInt(index); + } + } + + private void addIndexPrefix(int index) + { + if (index < 0) Kit.codeBug(); + if (index < 6) { + addIcode(Icode_REG_IND_C0 - index); + } else if (index <= 0xFF) { + addIcode(Icode_REG_IND1); + addUint8(index); + } else if (index <= 0xFFFF) { + addIcode(Icode_REG_IND2); + addUint16(index); + } else { + addIcode(Icode_REG_IND4); + addInt(index); + } + } + + private void addExceptionHandler(int icodeStart, int icodeEnd, + int handlerStart, boolean isFinally, + int exceptionObjectLocal, int scopeLocal) + { + int top = itsExceptionTableTop; + int[] table = itsData.itsExceptionTable; + if (table == null) { + if (top != 0) Kit.codeBug(); + table = new int[EXCEPTION_SLOT_SIZE * 2]; + itsData.itsExceptionTable = table; + } else if (table.length == top) { + table = new int[table.length * 2]; + System.arraycopy(itsData.itsExceptionTable, 0, table, 0, top); + itsData.itsExceptionTable = table; + } + table[top + EXCEPTION_TRY_START_SLOT] = icodeStart; + table[top + EXCEPTION_TRY_END_SLOT] = icodeEnd; + table[top + EXCEPTION_HANDLER_SLOT] = handlerStart; + table[top + EXCEPTION_TYPE_SLOT] = isFinally ? 1 : 0; + table[top + EXCEPTION_LOCAL_SLOT] = exceptionObjectLocal; + table[top + EXCEPTION_SCOPE_SLOT] = scopeLocal; + + itsExceptionTableTop = top + EXCEPTION_SLOT_SIZE; + } + + private byte[] increaseICodeCapacity(int extraSize) + { + int capacity = itsData.itsICode.length; + int top = itsICodeTop; + if (top + extraSize <= capacity) throw Kit.codeBug(); + capacity *= 2; + if (top + extraSize > capacity) { + capacity = top + extraSize; + } + byte[] array = new byte[capacity]; + System.arraycopy(itsData.itsICode, 0, array, 0, top); + itsData.itsICode = array; + return array; + } + + private void stackChange(int change) + { + if (change <= 0) { + itsStackDepth += change; + } else { + int newDepth = itsStackDepth + change; + if (newDepth > itsData.itsMaxStack) { + itsData.itsMaxStack = newDepth; + } + itsStackDepth = newDepth; + } + } + + private int allocLocal() + { + int localSlot = itsLocalTop; + ++itsLocalTop; + if (itsLocalTop > itsData.itsMaxLocals) { + itsData.itsMaxLocals = itsLocalTop; + } + return localSlot; + } + + private void releaseLocal(int localSlot) + { + --itsLocalTop; + if (localSlot != itsLocalTop) Kit.codeBug(); + } + + private static int getShort(byte[] iCode, int pc) { + return (iCode[pc] << 8) | (iCode[pc + 1] & 0xFF); + } + + private static int getIndex(byte[] iCode, int pc) { + return ((iCode[pc] & 0xFF) << 8) | (iCode[pc + 1] & 0xFF); + } + + private static int getInt(byte[] iCode, int pc) { + return (iCode[pc] << 24) | ((iCode[pc + 1] & 0xFF) << 16) + | ((iCode[pc + 2] & 0xFF) << 8) | (iCode[pc + 3] & 0xFF); + } + + private static int getExceptionHandler(CallFrame frame, + boolean onlyFinally) + { + int[] exceptionTable = frame.idata.itsExceptionTable; + if (exceptionTable == null) { + // No exception handlers + return -1; + } + + // Icode switch in the interpreter increments PC immediately + // and it is necessary to subtract 1 from the saved PC + // to point it before the start of the next instruction. + int pc = frame.pc - 1; + + // OPT: use binary search + int best = -1, bestStart = 0, bestEnd = 0; + for (int i = 0; i != exceptionTable.length; i += EXCEPTION_SLOT_SIZE) { + int start = exceptionTable[i + EXCEPTION_TRY_START_SLOT]; + int end = exceptionTable[i + EXCEPTION_TRY_END_SLOT]; + if (!(start <= pc && pc < end)) { + continue; + } + if (onlyFinally && exceptionTable[i + EXCEPTION_TYPE_SLOT] != 1) { + continue; + } + if (best >= 0) { + // Since handlers always nest and they never have shared end + // although they can share start it is sufficient to compare + // handlers ends + if (bestEnd < end) { + continue; + } + // Check the above assumption + if (bestStart > start) Kit.codeBug(); // should be nested + if (bestEnd == end) Kit.codeBug(); // no ens sharing + } + best = i; + bestStart = start; + bestEnd = end; + } + return best; + } + + private static void dumpICode(InterpreterData idata) + { + if (!Token.printICode) { + return; + } + + byte iCode[] = idata.itsICode; + int iCodeLength = iCode.length; + String[] strings = idata.itsStringTable; + PrintStream out = System.out; + out.println("ICode dump, for " + idata.itsName + + ", length = " + iCodeLength); + out.println("MaxStack = " + idata.itsMaxStack); + + int indexReg = 0; + for (int pc = 0; pc < iCodeLength; ) { + out.flush(); + out.print(" [" + pc + "] "); + int token = iCode[pc]; + int icodeLength = bytecodeSpan(token); + String tname = bytecodeName(token); + int old_pc = pc; + ++pc; + switch (token) { + default: + if (icodeLength != 1) Kit.codeBug(); + out.println(tname); + break; + + case Icode_GOSUB : + case Token.GOTO : + case Token.IFEQ : + case Token.IFNE : + case Icode_IFEQ_POP : + case Icode_LEAVEDQ : { + int newPC = pc + getShort(iCode, pc) - 1; + out.println(tname + " " + newPC); + pc += 2; + break; + } + case Icode_VAR_INC_DEC : + case Icode_NAME_INC_DEC : + case Icode_PROP_INC_DEC : + case Icode_ELEM_INC_DEC : + case Icode_REF_INC_DEC: { + int incrDecrType = iCode[pc]; + out.println(tname + " " + incrDecrType); + ++pc; + break; + } + + case Icode_CALLSPECIAL : { + int callType = iCode[pc] & 0xFF; + boolean isNew = (iCode[pc + 1] != 0); + int line = getIndex(iCode, pc+2); + out.println(tname+" "+callType+" "+isNew+" "+indexReg+" "+line); + pc += 4; + break; + } + + case Token.CATCH_SCOPE: + { + boolean afterFisrtFlag = (iCode[pc] != 0); + out.println(tname+" "+afterFisrtFlag); + ++pc; + } + break; + case Token.REGEXP : + out.println(tname+" "+idata.itsRegExpLiterals[indexReg]); + break; + case Token.OBJECTLIT : + case Icode_SPARE_ARRAYLIT : + out.println(tname+" "+idata.literalIds[indexReg]); + break; + case Icode_CLOSURE_EXPR : + case Icode_CLOSURE_STMT : + out.println(tname+" "+idata.itsNestedFunctions[indexReg]); + break; + case Token.CALL : + case Icode_TAIL_CALL : + case Token.REF_CALL : + case Token.NEW : + out.println(tname+' '+indexReg); + break; + case Token.THROW : + case Token.YIELD : + case Icode_GENERATOR : + case Icode_GENERATOR_END : + { + int line = getIndex(iCode, pc); + out.println(tname + " : " + line); + pc += 2; + break; + } + case Icode_SHORTNUMBER : { + int value = getShort(iCode, pc); + out.println(tname + " " + value); + pc += 2; + break; + } + case Icode_INTNUMBER : { + int value = getInt(iCode, pc); + out.println(tname + " " + value); + pc += 4; + break; + } + case Token.NUMBER : { + double value = idata.itsDoubleTable[indexReg]; + out.println(tname + " " + value); + break; + } + case Icode_LINE : { + int line = getIndex(iCode, pc); + out.println(tname + " : " + line); + pc += 2; + break; + } + case Icode_REG_STR1: { + String str = strings[0xFF & iCode[pc]]; + out.println(tname + " \"" + str + '"'); + ++pc; + break; + } + case Icode_REG_STR2: { + String str = strings[getIndex(iCode, pc)]; + out.println(tname + " \"" + str + '"'); + pc += 2; + break; + } + case Icode_REG_STR4: { + String str = strings[getInt(iCode, pc)]; + out.println(tname + " \"" + str + '"'); + pc += 4; + break; + } + case Icode_REG_IND_C0: + indexReg = 0; + out.println(tname); + break; + case Icode_REG_IND_C1: + indexReg = 1; + out.println(tname); + break; + case Icode_REG_IND_C2: + indexReg = 2; + out.println(tname); + break; + case Icode_REG_IND_C3: + indexReg = 3; + out.println(tname); + break; + case Icode_REG_IND_C4: + indexReg = 4; + out.println(tname); + break; + case Icode_REG_IND_C5: + indexReg = 5; + out.println(tname); + break; + case Icode_REG_IND1: { + indexReg = 0xFF & iCode[pc]; + out.println(tname+" "+indexReg); + ++pc; + break; + } + case Icode_REG_IND2: { + indexReg = getIndex(iCode, pc); + out.println(tname+" "+indexReg); + pc += 2; + break; + } + case Icode_REG_IND4: { + indexReg = getInt(iCode, pc); + out.println(tname+" "+indexReg); + pc += 4; + break; + } + case Icode_GETVAR1: + case Icode_SETVAR1: + case Icode_SETCONSTVAR1: + indexReg = iCode[pc]; + out.println(tname+" "+indexReg); + ++pc; + break; + } + if (old_pc + icodeLength != pc) Kit.codeBug(); + } + + int[] table = idata.itsExceptionTable; + if (table != null) { + out.println("Exception handlers: " + +table.length / EXCEPTION_SLOT_SIZE); + for (int i = 0; i != table.length; + i += EXCEPTION_SLOT_SIZE) + { + int tryStart = table[i + EXCEPTION_TRY_START_SLOT]; + int tryEnd = table[i + EXCEPTION_TRY_END_SLOT]; + int handlerStart = table[i + EXCEPTION_HANDLER_SLOT]; + int type = table[i + EXCEPTION_TYPE_SLOT]; + int exceptionLocal = table[i + EXCEPTION_LOCAL_SLOT]; + int scopeLocal = table[i + EXCEPTION_SCOPE_SLOT]; + + out.println(" tryStart="+tryStart+" tryEnd="+tryEnd + +" handlerStart="+handlerStart + +" type="+(type == 0 ? "catch" : "finally") + +" exceptionLocal="+exceptionLocal); + } + } + out.flush(); + } + + private static int bytecodeSpan(int bytecode) + { + switch (bytecode) { + case Token.THROW : + case Token.YIELD: + case Icode_GENERATOR: + case Icode_GENERATOR_END: + // source line + return 1 + 2; + + case Icode_GOSUB : + case Token.GOTO : + case Token.IFEQ : + case Token.IFNE : + case Icode_IFEQ_POP : + case Icode_LEAVEDQ : + // target pc offset + return 1 + 2; + + case Icode_CALLSPECIAL : + // call type + // is new + // line number + return 1 + 1 + 1 + 2; + + case Token.CATCH_SCOPE: + // scope flag + return 1 + 1; + + case Icode_VAR_INC_DEC: + case Icode_NAME_INC_DEC: + case Icode_PROP_INC_DEC: + case Icode_ELEM_INC_DEC: + case Icode_REF_INC_DEC: + // type of ++/-- + return 1 + 1; + + case Icode_SHORTNUMBER : + // short number + return 1 + 2; + + case Icode_INTNUMBER : + // int number + return 1 + 4; + + case Icode_REG_IND1: + // ubyte index + return 1 + 1; + + case Icode_REG_IND2: + // ushort index + return 1 + 2; + + case Icode_REG_IND4: + // int index + return 1 + 4; + + case Icode_REG_STR1: + // ubyte string index + return 1 + 1; + + case Icode_REG_STR2: + // ushort string index + return 1 + 2; + + case Icode_REG_STR4: + // int string index + return 1 + 4; + + case Icode_GETVAR1: + case Icode_SETVAR1: + case Icode_SETCONSTVAR1: + // byte var index + return 1 + 1; + + case Icode_LINE : + // line number + return 1 + 2; + } + if (!validBytecode(bytecode)) throw Kit.codeBug(); + return 1; + } + + static int[] getLineNumbers(InterpreterData data) + { + UintMap presentLines = new UintMap(); + + byte[] iCode = data.itsICode; + int iCodeLength = iCode.length; + for (int pc = 0; pc != iCodeLength;) { + int bytecode = iCode[pc]; + int span = bytecodeSpan(bytecode); + if (bytecode == Icode_LINE) { + if (span != 3) Kit.codeBug(); + int line = getIndex(iCode, pc + 1); + presentLines.put(line, 0); + } + pc += span; + } + + return presentLines.getKeys(); + } + + public void captureStackInfo(RhinoException ex) + { + Context cx = Context.getCurrentContext(); + if (cx == null || cx.lastInterpreterFrame == null) { + // No interpreter invocations + ex.interpreterStackInfo = null; + ex.interpreterLineData = null; + return; + } + // has interpreter frame on the stack + CallFrame[] array; + if (cx.previousInterpreterInvocations == null + || cx.previousInterpreterInvocations.size() == 0) + { + array = new CallFrame[1]; + } else { + int previousCount = cx.previousInterpreterInvocations.size(); + if (cx.previousInterpreterInvocations.peek() + == cx.lastInterpreterFrame) + { + // It can happen if exception was generated after + // frame was pushed to cx.previousInterpreterInvocations + // but before assignment to cx.lastInterpreterFrame. + // In this case frames has to be ignored. + --previousCount; + } + array = new CallFrame[previousCount + 1]; + cx.previousInterpreterInvocations.toArray(array); + } + array[array.length - 1] = (CallFrame)cx.lastInterpreterFrame; + + int interpreterFrameCount = 0; + for (int i = 0; i != array.length; ++i) { + interpreterFrameCount += 1 + array[i].frameIndex; + } + + int[] linePC = new int[interpreterFrameCount]; + // Fill linePC with pc positions from all interpreter frames. + // Start from the most nested frame + int linePCIndex = interpreterFrameCount; + for (int i = array.length; i != 0;) { + --i; + CallFrame frame = array[i]; + while (frame != null) { + --linePCIndex; + linePC[linePCIndex] = frame.pcSourceLineStart; + frame = frame.parentFrame; + } + } + if (linePCIndex != 0) Kit.codeBug(); + + ex.interpreterStackInfo = array; + ex.interpreterLineData = linePC; + } + + public String getSourcePositionFromStack(Context cx, int[] linep) + { + CallFrame frame = (CallFrame)cx.lastInterpreterFrame; + InterpreterData idata = frame.idata; + if (frame.pcSourceLineStart >= 0) { + linep[0] = getIndex(idata.itsICode, frame.pcSourceLineStart); + } else { + linep[0] = 0; + } + return idata.itsSourceFile; + } + + public String getPatchedStack(RhinoException ex, + String nativeStackTrace) + { + String tag = "org.mozilla.javascript.Interpreter.interpretLoop"; + StringBuffer sb = new StringBuffer(nativeStackTrace.length() + 1000); + String lineSeparator = SecurityUtilities.getSystemProperty("line.separator"); + + CallFrame[] array = (CallFrame[])ex.interpreterStackInfo; + int[] linePC = ex.interpreterLineData; + int arrayIndex = array.length; + int linePCIndex = linePC.length; + int offset = 0; + while (arrayIndex != 0) { + --arrayIndex; + int pos = nativeStackTrace.indexOf(tag, offset); + if (pos < 0) { + break; + } + + // Skip tag length + pos += tag.length(); + // Skip until the end of line + for (; pos != nativeStackTrace.length(); ++pos) { + char c = nativeStackTrace.charAt(pos); + if (c == '\n' || c == '\r') { + break; + } + } + sb.append(nativeStackTrace.substring(offset, pos)); + offset = pos; + + CallFrame frame = array[arrayIndex]; + while (frame != null) { + if (linePCIndex == 0) Kit.codeBug(); + --linePCIndex; + InterpreterData idata = frame.idata; + sb.append(lineSeparator); + sb.append("\tat script"); + if (idata.itsName != null && idata.itsName.length() != 0) { + sb.append('.'); + sb.append(idata.itsName); + } + sb.append('('); + sb.append(idata.itsSourceFile); + int pc = linePC[linePCIndex]; + if (pc >= 0) { + // Include line info only if available + sb.append(':'); + sb.append(getIndex(idata.itsICode, pc)); + } + sb.append(')'); + frame = frame.parentFrame; + } + } + sb.append(nativeStackTrace.substring(offset)); + + return sb.toString(); + } + + public List getScriptStack(RhinoException ex) + { + if (ex.interpreterStackInfo == null) { + return null; + } + + List list = new ArrayList(); + String lineSeparator = + SecurityUtilities.getSystemProperty("line.separator"); + + CallFrame[] array = (CallFrame[])ex.interpreterStackInfo; + int[] linePC = ex.interpreterLineData; + int arrayIndex = array.length; + int linePCIndex = linePC.length; + while (arrayIndex != 0) { + --arrayIndex; + StringBuffer sb = new StringBuffer(); + CallFrame frame = array[arrayIndex]; + while (frame != null) { + if (linePCIndex == 0) Kit.codeBug(); + --linePCIndex; + InterpreterData idata = frame.idata; + sb.append("\tat "); + sb.append(idata.itsSourceFile); + int pc = linePC[linePCIndex]; + if (pc >= 0) { + // Include line info only if available + sb.append(':'); + sb.append(getIndex(idata.itsICode, pc)); + } + if (idata.itsName != null && idata.itsName.length() != 0) { + sb.append(" ("); + sb.append(idata.itsName); + sb.append(')'); + } + sb.append(lineSeparator); + frame = frame.parentFrame; + } + list.add(sb.toString()); + } + return list; + } + + static String getEncodedSource(InterpreterData idata) + { + if (idata.encodedSource == null) { + return null; + } + return idata.encodedSource.substring(idata.encodedSourceStart, + idata.encodedSourceEnd); + } + + private static void initFunction(Context cx, Scriptable scope, + InterpretedFunction parent, int index) + { + InterpretedFunction fn; + fn = InterpretedFunction.createFunction(cx, scope, parent, index); + ScriptRuntime.initFunction(cx, scope, fn, fn.idata.itsFunctionType, + parent.idata.evalScriptFlag); + } + + static Object interpret(InterpretedFunction ifun, + Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!ScriptRuntime.hasTopCall(cx)) Kit.codeBug(); + + if (cx.interpreterSecurityDomain != ifun.securityDomain) { + Object savedDomain = cx.interpreterSecurityDomain; + cx.interpreterSecurityDomain = ifun.securityDomain; + try { + return ifun.securityController.callWithDomain( + ifun.securityDomain, cx, ifun, scope, thisObj, args); + } finally { + cx.interpreterSecurityDomain = savedDomain; + } + } + + CallFrame frame = new CallFrame(); + initFrame(cx, scope, thisObj, args, null, 0, args.length, + ifun, null, frame); + + return interpretLoop(cx, frame, null); + } + + static class GeneratorState { + GeneratorState(int operation, Object value) { + this.operation = operation; + this.value = value; + } + int operation; + Object value; + RuntimeException returnedException; + } + + public static Object resumeGenerator(Context cx, + Scriptable scope, + int operation, + Object savedState, + Object value) + { + CallFrame frame = (CallFrame) savedState; + GeneratorState generatorState = new GeneratorState(operation, value); + if (operation == NativeGenerator.GENERATOR_CLOSE) { + try { + return interpretLoop(cx, frame, generatorState); + } catch (RuntimeException e) { + // Only propagate exceptions other than closingException + if (e != value) + throw e; + } + return Undefined.instance; + } + Object result = interpretLoop(cx, frame, generatorState); + if (generatorState.returnedException != null) + throw generatorState.returnedException; + return result; + } + + public static Object restartContinuation(Continuation c, Context cx, + Scriptable scope, Object[] args) + { + if (!ScriptRuntime.hasTopCall(cx)) { + return ScriptRuntime.doTopCall(c, cx, scope, null, args); + } + + Object arg; + if (args.length == 0) { + arg = Undefined.instance; + } else { + arg = args[0]; + } + + CallFrame capturedFrame = (CallFrame)c.getImplementation(); + if (capturedFrame == null) { + // No frames to restart + return arg; + } + + ContinuationJump cjump = new ContinuationJump(c, null); + + cjump.result = arg; + return interpretLoop(cx, null, cjump); + } + + private static Object interpretLoop(Context cx, CallFrame frame, + Object throwable) + { + // throwable holds exception object to rethrow or catch + // It is also used for continuation restart in which case + // it holds ContinuationJump + + final Object DBL_MRK = UniqueTag.DOUBLE_MARK; + final Object undefined = Undefined.instance; + + final boolean instructionCounting = (cx.instructionThreshold != 0); + // arbitrary number to add to instructionCount when calling + // other functions + final int INVOCATION_COST = 100; + // arbitrary exception cost for instruction counting + final int EXCEPTION_COST = 100; + + String stringReg = null; + int indexReg = -1; + + if (cx.lastInterpreterFrame != null) { + // save the top frame from the previous interpretLoop + // invocation on the stack + if (cx.previousInterpreterInvocations == null) { + cx.previousInterpreterInvocations = new ObjArray(); + } + cx.previousInterpreterInvocations.push(cx.lastInterpreterFrame); + } + + // When restarting continuation throwable is not null and to jump + // to the code that rewind continuation state indexReg should be set + // to -1. + // With the normal call throable == null and indexReg == -1 allows to + // catch bugs with using indeReg to access array eleemnts before + // initializing indexReg. + + GeneratorState generatorState = null; + if (throwable != null) { + if (throwable instanceof GeneratorState) { + generatorState = (GeneratorState) throwable; + + // reestablish this call frame + enterFrame(cx, frame, ScriptRuntime.emptyArgs, true); + throwable = null; + } else if (!(throwable instanceof ContinuationJump)) { + // It should be continuation + Kit.codeBug(); + } + } + + Object interpreterResult = null; + double interpreterResultDbl = 0.0; + + StateLoop: for (;;) { + withoutExceptions: try { + + if (throwable != null) { + // Need to return both 'frame' and 'throwable' from + // 'processThrowable', so just added a 'throwable' + // member in 'frame'. + frame = processThrowable(cx, throwable, frame, indexReg, + instructionCounting); + throwable = frame.throwable; + frame.throwable = null; + } else { + if (generatorState == null && frame.frozen) Kit.codeBug(); + } + + // Use local variables for constant values in frame + // for faster access + Object[] stack = frame.stack; + double[] sDbl = frame.sDbl; + Object[] vars = frame.varSource.stack; + double[] varDbls = frame.varSource.sDbl; + int[] varAttributes = frame.varSource.stackAttributes; + byte[] iCode = frame.idata.itsICode; + String[] strings = frame.idata.itsStringTable; + + // Use local for stackTop as well. Since execption handlers + // can only exist at statement level where stack is empty, + // it is necessary to save/restore stackTop only across + // function calls and normal returns. + int stackTop = frame.savedStackTop; + + // Store new frame in cx which is used for error reporting etc. + cx.lastInterpreterFrame = frame; + + Loop: for (;;) { + + // Exception handler assumes that PC is already incremented + // pass the instruction start when it searches the + // exception handler + int op = iCode[frame.pc++]; + jumplessRun: { + + // Back indent to ease implementation reading +switch (op) { + case Icode_GENERATOR: { + if (!frame.frozen) { + // First time encountering this opcode: create new generator + // object and return + frame.pc--; // we want to come back here when we resume + CallFrame generatorFrame = captureFrameForGenerator(frame); + generatorFrame.frozen = true; + NativeGenerator generator = new NativeGenerator(frame.scope, + generatorFrame.fnOrScript, generatorFrame); + frame.result = generator; + break Loop; + } else { + // We are now resuming execution. Fall through to YIELD case. + } + } + // fall through... + case Token.YIELD: { + if (!frame.frozen) { + return freezeGenerator(cx, frame, stackTop, generatorState); + } else { + Object obj = thawGenerator(frame, stackTop, generatorState, op); + if (obj != Scriptable.NOT_FOUND) { + throwable = obj; + break withoutExceptions; + } + continue Loop; + } + } + case Icode_GENERATOR_END: { + // throw StopIteration + frame.frozen = true; + int sourceLine = getIndex(iCode, frame.pc); + generatorState.returnedException = new JavaScriptException( + NativeIterator.getStopIterationObject(frame.scope), + frame.idata.itsSourceFile, sourceLine); + break Loop; + } + case Token.THROW: { + Object value = stack[stackTop]; + if (value == DBL_MRK) value = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + + int sourceLine = getIndex(iCode, frame.pc); + throwable = new JavaScriptException(value, + frame.idata.itsSourceFile, + sourceLine); + break withoutExceptions; + } + case Token.RETHROW: { + indexReg += frame.localShift; + throwable = stack[indexReg]; + break withoutExceptions; + } + case Token.GE : + case Token.LE : + case Token.GT : + case Token.LT : { + --stackTop; + Object rhs = stack[stackTop + 1]; + Object lhs = stack[stackTop]; + boolean valBln; + object_compare: + { + number_compare: + { + double rDbl, lDbl; + if (rhs == DBL_MRK) { + rDbl = sDbl[stackTop + 1]; + lDbl = stack_double(frame, stackTop); + } else if (lhs == DBL_MRK) { + rDbl = ScriptRuntime.toNumber(rhs); + lDbl = sDbl[stackTop]; + } else { + break number_compare; + } + switch (op) { + case Token.GE: + valBln = (lDbl >= rDbl); + break object_compare; + case Token.LE: + valBln = (lDbl <= rDbl); + break object_compare; + case Token.GT: + valBln = (lDbl > rDbl); + break object_compare; + case Token.LT: + valBln = (lDbl < rDbl); + break object_compare; + default: + throw Kit.codeBug(); + } + } + switch (op) { + case Token.GE: + valBln = ScriptRuntime.cmp_LE(rhs, lhs); + break; + case Token.LE: + valBln = ScriptRuntime.cmp_LE(lhs, rhs); + break; + case Token.GT: + valBln = ScriptRuntime.cmp_LT(rhs, lhs); + break; + case Token.LT: + valBln = ScriptRuntime.cmp_LT(lhs, rhs); + break; + default: + throw Kit.codeBug(); + } + } + stack[stackTop] = ScriptRuntime.wrapBoolean(valBln); + continue Loop; + } + case Token.IN : + case Token.INSTANCEOF : { + Object rhs = stack[stackTop]; + if (rhs == DBL_MRK) rhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + boolean valBln; + if (op == Token.IN) { + valBln = ScriptRuntime.in(lhs, rhs, cx); + } else { + valBln = ScriptRuntime.instanceOf(lhs, rhs, cx); + } + stack[stackTop] = ScriptRuntime.wrapBoolean(valBln); + continue Loop; + } + case Token.EQ : + case Token.NE : { + --stackTop; + boolean valBln; + Object rhs = stack[stackTop + 1]; + Object lhs = stack[stackTop]; + if (rhs == DBL_MRK) { + if (lhs == DBL_MRK) { + valBln = (sDbl[stackTop] == sDbl[stackTop + 1]); + } else { + valBln = ScriptRuntime.eqNumber(sDbl[stackTop + 1], lhs); + } + } else { + if (lhs == DBL_MRK) { + valBln = ScriptRuntime.eqNumber(sDbl[stackTop], rhs); + } else { + valBln = ScriptRuntime.eq(lhs, rhs); + } + } + valBln ^= (op == Token.NE); + stack[stackTop] = ScriptRuntime.wrapBoolean(valBln); + continue Loop; + } + case Token.SHEQ : + case Token.SHNE : { + --stackTop; + Object rhs = stack[stackTop + 1]; + Object lhs = stack[stackTop]; + boolean valBln; + shallow_compare: { + double rdbl, ldbl; + if (rhs == DBL_MRK) { + rdbl = sDbl[stackTop + 1]; + if (lhs == DBL_MRK) { + ldbl = sDbl[stackTop]; + } else if (lhs instanceof Number) { + ldbl = ((Number)lhs).doubleValue(); + } else { + valBln = false; + break shallow_compare; + } + } else if (lhs == DBL_MRK) { + ldbl = sDbl[stackTop]; + if (rhs == DBL_MRK) { + rdbl = sDbl[stackTop + 1]; + } else if (rhs instanceof Number) { + rdbl = ((Number)rhs).doubleValue(); + } else { + valBln = false; + break shallow_compare; + } + } else { + valBln = ScriptRuntime.shallowEq(lhs, rhs); + break shallow_compare; + } + valBln = (ldbl == rdbl); + } + valBln ^= (op == Token.SHNE); + stack[stackTop] = ScriptRuntime.wrapBoolean(valBln); + continue Loop; + } + case Token.IFNE : + if (stack_boolean(frame, stackTop--)) { + frame.pc += 2; + continue Loop; + } + break jumplessRun; + case Token.IFEQ : + if (!stack_boolean(frame, stackTop--)) { + frame.pc += 2; + continue Loop; + } + break jumplessRun; + case Icode_IFEQ_POP : + if (!stack_boolean(frame, stackTop--)) { + frame.pc += 2; + continue Loop; + } + stack[stackTop--] = null; + break jumplessRun; + case Token.GOTO : + break jumplessRun; + case Icode_GOSUB : + ++stackTop; + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = frame.pc + 2; + break jumplessRun; + case Icode_STARTSUB : + if (stackTop == frame.emptyStackTop + 1) { + // Call from Icode_GOSUB: store return PC address in the local + indexReg += frame.localShift; + stack[indexReg] = stack[stackTop]; + sDbl[indexReg] = sDbl[stackTop]; + --stackTop; + } else { + // Call from exception handler: exception object is already stored + // in the local + if (stackTop != frame.emptyStackTop) Kit.codeBug(); + } + continue Loop; + case Icode_RETSUB : { + // indexReg: local to store return address + if (instructionCounting) { + addInstructionCount(cx, frame, 0); + } + indexReg += frame.localShift; + Object value = stack[indexReg]; + if (value != DBL_MRK) { + // Invocation from exception handler, restore object to rethrow + throwable = value; + break withoutExceptions; + } + // Normal return from GOSUB + frame.pc = (int)sDbl[indexReg]; + if (instructionCounting) { + frame.pcPrevBranch = frame.pc; + } + continue Loop; + } + case Icode_POP : + stack[stackTop] = null; + stackTop--; + continue Loop; + case Icode_POP_RESULT : + frame.result = stack[stackTop]; + frame.resultDbl = sDbl[stackTop]; + stack[stackTop] = null; + --stackTop; + continue Loop; + case Icode_DUP : + stack[stackTop + 1] = stack[stackTop]; + sDbl[stackTop + 1] = sDbl[stackTop]; + stackTop++; + continue Loop; + case Icode_DUP2 : + stack[stackTop + 1] = stack[stackTop - 1]; + sDbl[stackTop + 1] = sDbl[stackTop - 1]; + stack[stackTop + 2] = stack[stackTop]; + sDbl[stackTop + 2] = sDbl[stackTop]; + stackTop += 2; + continue Loop; + case Icode_SWAP : { + Object o = stack[stackTop]; + stack[stackTop] = stack[stackTop - 1]; + stack[stackTop - 1] = o; + double d = sDbl[stackTop]; + sDbl[stackTop] = sDbl[stackTop - 1]; + sDbl[stackTop - 1] = d; + continue Loop; + } + case Token.RETURN : + frame.result = stack[stackTop]; + frame.resultDbl = sDbl[stackTop]; + --stackTop; + break Loop; + case Token.RETURN_RESULT : + break Loop; + case Icode_RETUNDEF : + frame.result = undefined; + break Loop; + case Token.BITNOT : { + int rIntValue = stack_int32(frame, stackTop); + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = ~rIntValue; + continue Loop; + } + case Token.BITAND : + case Token.BITOR : + case Token.BITXOR : + case Token.LSH : + case Token.RSH : { + int lIntValue = stack_int32(frame, stackTop-1); + int rIntValue = stack_int32(frame, stackTop); + stack[--stackTop] = DBL_MRK; + switch (op) { + case Token.BITAND: + lIntValue &= rIntValue; + break; + case Token.BITOR: + lIntValue |= rIntValue; + break; + case Token.BITXOR: + lIntValue ^= rIntValue; + break; + case Token.LSH: + lIntValue <<= rIntValue; + break; + case Token.RSH: + lIntValue >>= rIntValue; + break; + } + sDbl[stackTop] = lIntValue; + continue Loop; + } + case Token.URSH : { + double lDbl = stack_double(frame, stackTop-1); + int rIntValue = stack_int32(frame, stackTop) & 0x1F; + stack[--stackTop] = DBL_MRK; + sDbl[stackTop] = ScriptRuntime.toUint32(lDbl) >>> rIntValue; + continue Loop; + } + case Token.NEG : + case Token.POS : { + double rDbl = stack_double(frame, stackTop); + stack[stackTop] = DBL_MRK; + if (op == Token.NEG) { + rDbl = -rDbl; + } + sDbl[stackTop] = rDbl; + continue Loop; + } + case Token.ADD : + --stackTop; + do_add(stack, sDbl, stackTop, cx); + continue Loop; + case Token.SUB : + case Token.MUL : + case Token.DIV : + case Token.MOD : { + double rDbl = stack_double(frame, stackTop); + --stackTop; + double lDbl = stack_double(frame, stackTop); + stack[stackTop] = DBL_MRK; + switch (op) { + case Token.SUB: + lDbl -= rDbl; + break; + case Token.MUL: + lDbl *= rDbl; + break; + case Token.DIV: + lDbl /= rDbl; + break; + case Token.MOD: + lDbl %= rDbl; + break; + } + sDbl[stackTop] = lDbl; + continue Loop; + } + case Token.NOT : + stack[stackTop] = ScriptRuntime.wrapBoolean( + !stack_boolean(frame, stackTop)); + continue Loop; + case Token.BINDNAME : + stack[++stackTop] = ScriptRuntime.bind(cx, frame.scope, stringReg); + continue Loop; + case Token.SETNAME : { + Object rhs = stack[stackTop]; + if (rhs == DBL_MRK) rhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Scriptable lhs = (Scriptable)stack[stackTop]; + stack[stackTop] = ScriptRuntime.setName(lhs, rhs, cx, + frame.scope, stringReg); + continue Loop; + } + case Icode_SETCONST: { + Object rhs = stack[stackTop]; + if (rhs == DBL_MRK) rhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Scriptable lhs = (Scriptable)stack[stackTop]; + stack[stackTop] = ScriptRuntime.setConst(lhs, rhs, cx, stringReg); + continue Loop; + } + case Token.DELPROP : { + Object rhs = stack[stackTop]; + if (rhs == DBL_MRK) rhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.delete(lhs, rhs, cx); + continue Loop; + } + case Token.GETPROPNOWARN : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.getObjectPropNoWarn(lhs, stringReg, cx); + continue Loop; + } + case Token.GETPROP : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.getObjectProp(lhs, stringReg, cx); + continue Loop; + } + case Token.SETPROP : { + Object rhs = stack[stackTop]; + if (rhs == DBL_MRK) rhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.setObjectProp(lhs, stringReg, rhs, + cx); + continue Loop; + } + case Icode_PROP_INC_DEC : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.propIncrDecr(lhs, stringReg, + cx, iCode[frame.pc]); + ++frame.pc; + continue Loop; + } + case Token.GETELEM : { + --stackTop; + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) { + lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + } + Object value; + Object id = stack[stackTop + 1]; + if (id != DBL_MRK) { + value = ScriptRuntime.getObjectElem(lhs, id, cx); + } else { + double d = sDbl[stackTop + 1]; + value = ScriptRuntime.getObjectIndex(lhs, d, cx); + } + stack[stackTop] = value; + continue Loop; + } + case Token.SETELEM : { + stackTop -= 2; + Object rhs = stack[stackTop + 2]; + if (rhs == DBL_MRK) { + rhs = ScriptRuntime.wrapNumber(sDbl[stackTop + 2]); + } + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) { + lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + } + Object value; + Object id = stack[stackTop + 1]; + if (id != DBL_MRK) { + value = ScriptRuntime.setObjectElem(lhs, id, rhs, cx); + } else { + double d = sDbl[stackTop + 1]; + value = ScriptRuntime.setObjectIndex(lhs, d, rhs, cx); + } + stack[stackTop] = value; + continue Loop; + } + case Icode_ELEM_INC_DEC: { + Object rhs = stack[stackTop]; + if (rhs == DBL_MRK) rhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.elemIncrDecr(lhs, rhs, cx, + iCode[frame.pc]); + ++frame.pc; + continue Loop; + } + case Token.GET_REF : { + Ref ref = (Ref)stack[stackTop]; + stack[stackTop] = ScriptRuntime.refGet(ref, cx); + continue Loop; + } + case Token.SET_REF : { + Object value = stack[stackTop]; + if (value == DBL_MRK) value = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Ref ref = (Ref)stack[stackTop]; + stack[stackTop] = ScriptRuntime.refSet(ref, value, cx); + continue Loop; + } + case Token.DEL_REF : { + Ref ref = (Ref)stack[stackTop]; + stack[stackTop] = ScriptRuntime.refDel(ref, cx); + continue Loop; + } + case Icode_REF_INC_DEC : { + Ref ref = (Ref)stack[stackTop]; + stack[stackTop] = ScriptRuntime.refIncrDecr(ref, cx, iCode[frame.pc]); + ++frame.pc; + continue Loop; + } + case Token.LOCAL_LOAD : + ++stackTop; + indexReg += frame.localShift; + stack[stackTop] = stack[indexReg]; + sDbl[stackTop] = sDbl[indexReg]; + continue Loop; + case Icode_LOCAL_CLEAR : + indexReg += frame.localShift; + stack[indexReg] = null; + continue Loop; + case Icode_NAME_AND_THIS : + // stringReg: name + ++stackTop; + stack[stackTop] = ScriptRuntime.getNameFunctionAndThis(stringReg, + cx, frame.scope); + ++stackTop; + stack[stackTop] = ScriptRuntime.lastStoredScriptable(cx); + continue Loop; + case Icode_PROP_AND_THIS: { + Object obj = stack[stackTop]; + if (obj == DBL_MRK) obj = ScriptRuntime.wrapNumber(sDbl[stackTop]); + // stringReg: property + stack[stackTop] = ScriptRuntime.getPropFunctionAndThis(obj, stringReg, + cx); + ++stackTop; + stack[stackTop] = ScriptRuntime.lastStoredScriptable(cx); + continue Loop; + } + case Icode_ELEM_AND_THIS: { + Object obj = stack[stackTop - 1]; + if (obj == DBL_MRK) obj = ScriptRuntime.wrapNumber(sDbl[stackTop - 1]); + Object id = stack[stackTop]; + if (id == DBL_MRK) id = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop - 1] = ScriptRuntime.getElemFunctionAndThis(obj, id, cx); + stack[stackTop] = ScriptRuntime.lastStoredScriptable(cx); + continue Loop; + } + case Icode_VALUE_AND_THIS : { + Object value = stack[stackTop]; + if (value == DBL_MRK) value = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.getValueFunctionAndThis(value, cx); + ++stackTop; + stack[stackTop] = ScriptRuntime.lastStoredScriptable(cx); + continue Loop; + } + case Icode_CALLSPECIAL : { + if (instructionCounting) { + cx.instructionCount += INVOCATION_COST; + } + int callType = iCode[frame.pc] & 0xFF; + boolean isNew = (iCode[frame.pc + 1] != 0); + int sourceLine = getIndex(iCode, frame.pc + 2); + + // indexReg: number of arguments + if (isNew) { + // stack change: function arg0 .. argN -> newResult + stackTop -= indexReg; + + Object function = stack[stackTop]; + if (function == DBL_MRK) + function = ScriptRuntime.wrapNumber(sDbl[stackTop]); + Object[] outArgs = getArgsArray( + stack, sDbl, stackTop + 1, indexReg); + stack[stackTop] = ScriptRuntime.newSpecial( + cx, function, outArgs, frame.scope, callType); + } else { + // stack change: function thisObj arg0 .. argN -> result + stackTop -= 1 + indexReg; + + // Call code generation ensure that stack here + // is ... Callable Scriptable + Scriptable functionThis = (Scriptable)stack[stackTop + 1]; + Callable function = (Callable)stack[stackTop]; + Object[] outArgs = getArgsArray( + stack, sDbl, stackTop + 2, indexReg); + stack[stackTop] = ScriptRuntime.callSpecial( + cx, function, functionThis, outArgs, + frame.scope, frame.thisObj, callType, + frame.idata.itsSourceFile, sourceLine); + } + frame.pc += 4; + continue Loop; + } + case Token.CALL : + case Icode_TAIL_CALL : + case Token.REF_CALL : { + if (instructionCounting) { + cx.instructionCount += INVOCATION_COST; + } + // stack change: function thisObj arg0 .. argN -> result + // indexReg: number of arguments + stackTop -= 1 + indexReg; + + // CALL generation ensures that fun and funThisObj + // are already Scriptable and Callable objects respectively + Callable fun = (Callable)stack[stackTop]; + Scriptable funThisObj = (Scriptable)stack[stackTop + 1]; + if (op == Token.REF_CALL) { + Object[] outArgs = getArgsArray(stack, sDbl, stackTop + 2, + indexReg); + stack[stackTop] = ScriptRuntime.callRef(fun, funThisObj, + outArgs, cx); + continue Loop; + } + Scriptable calleeScope = frame.scope; + if (frame.useActivation) { + calleeScope = ScriptableObject.getTopLevelScope(frame.scope); + } + if (fun instanceof InterpretedFunction) { + InterpretedFunction ifun = (InterpretedFunction)fun; + if (frame.fnOrScript.securityDomain == ifun.securityDomain) { + CallFrame callParentFrame = frame; + CallFrame calleeFrame = new CallFrame(); + if (op == Icode_TAIL_CALL) { + // In principle tail call can re-use the current + // frame and its stack arrays but it is hard to + // do properly. Any exceptions that can legally + // happen during frame re-initialization including + // StackOverflowException during innocent looking + // System.arraycopy may leave the current frame + // data corrupted leading to undefined behaviour + // in the catch code bellow that unwinds JS stack + // on exceptions. Then there is issue about frame release + // end exceptions there. + // To avoid frame allocation a released frame + // can be cached for re-use which would also benefit + // non-tail calls but it is not clear that this caching + // would gain in performance due to potentially + // bad interaction with GC. + callParentFrame = frame.parentFrame; + // Release the current frame. See Bug #344501 to see why + // it is being done here. + exitFrame(cx, frame, null); + } + initFrame(cx, calleeScope, funThisObj, stack, sDbl, + stackTop + 2, indexReg, ifun, callParentFrame, + calleeFrame); + if (op != Icode_TAIL_CALL) { + frame.savedStackTop = stackTop; + frame.savedCallOp = op; + } + frame = calleeFrame; + continue StateLoop; + } + } + + if (fun instanceof Continuation) { + // Jump to the captured continuation + ContinuationJump cjump; + cjump = new ContinuationJump((Continuation)fun, frame); + + // continuation result is the first argument if any + // of contination call + if (indexReg == 0) { + cjump.result = undefined; + } else { + cjump.result = stack[stackTop + 2]; + cjump.resultDbl = sDbl[stackTop + 2]; + } + + // Start the real unwind job + throwable = cjump; + break withoutExceptions; + } + + if (fun instanceof IdFunctionObject) { + IdFunctionObject ifun = (IdFunctionObject)fun; + if (Continuation.isContinuationConstructor(ifun)) { + captureContinuation(cx, frame, stackTop); + continue Loop; + } + // Bug 405654 -- make best effort to keep Function.apply and + // Function.call within this interpreter loop invocation + if(BaseFunction.isApplyOrCall(ifun)) { + Callable applyCallable = ScriptRuntime.getCallable(funThisObj); + if(applyCallable instanceof InterpretedFunction) { + InterpretedFunction iApplyCallable = (InterpretedFunction)applyCallable; + if(frame.fnOrScript.securityDomain == iApplyCallable.securityDomain) { + frame = initFrameForApplyOrCall(cx, frame, indexReg, + stack, sDbl, stackTop, op, calleeScope, ifun, + iApplyCallable); + continue StateLoop; + } + } + } + } + + stack[stackTop] = fun.call(cx, calleeScope, funThisObj, + getArgsArray(stack, sDbl, stackTop + 2, indexReg)); + + continue Loop; + } + case Token.NEW : { + if (instructionCounting) { + cx.instructionCount += INVOCATION_COST; + } + // stack change: function arg0 .. argN -> newResult + // indexReg: number of arguments + stackTop -= indexReg; + + Object lhs = stack[stackTop]; + if (lhs instanceof InterpretedFunction) { + InterpretedFunction f = (InterpretedFunction)lhs; + if (frame.fnOrScript.securityDomain == f.securityDomain) { + Scriptable newInstance = f.createObject(cx, frame.scope); + CallFrame calleeFrame = new CallFrame(); + initFrame(cx, frame.scope, newInstance, stack, sDbl, + stackTop + 1, indexReg, f, frame, + calleeFrame); + + stack[stackTop] = newInstance; + frame.savedStackTop = stackTop; + frame.savedCallOp = op; + frame = calleeFrame; + continue StateLoop; + } + } + if (!(lhs instanceof Function)) { + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + throw ScriptRuntime.notFunctionError(lhs); + } + Function fun = (Function)lhs; + + if (fun instanceof IdFunctionObject) { + IdFunctionObject ifun = (IdFunctionObject)fun; + if (Continuation.isContinuationConstructor(ifun)) { + captureContinuation(cx, frame, stackTop); + continue Loop; + } + } + + Object[] outArgs = getArgsArray(stack, sDbl, stackTop + 1, indexReg); + stack[stackTop] = fun.construct(cx, frame.scope, outArgs); + continue Loop; + } + case Token.TYPEOF : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.typeof(lhs); + continue Loop; + } + case Icode_TYPEOFNAME : + stack[++stackTop] = ScriptRuntime.typeofName(frame.scope, stringReg); + continue Loop; + case Token.STRING : + stack[++stackTop] = stringReg; + continue Loop; + case Icode_SHORTNUMBER : + ++stackTop; + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = getShort(iCode, frame.pc); + frame.pc += 2; + continue Loop; + case Icode_INTNUMBER : + ++stackTop; + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = getInt(iCode, frame.pc); + frame.pc += 4; + continue Loop; + case Token.NUMBER : + ++stackTop; + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = frame.idata.itsDoubleTable[indexReg]; + continue Loop; + case Token.NAME : + stack[++stackTop] = ScriptRuntime.name(cx, frame.scope, stringReg); + continue Loop; + case Icode_NAME_INC_DEC : + stack[++stackTop] = ScriptRuntime.nameIncrDecr(frame.scope, stringReg, + cx, iCode[frame.pc]); + ++frame.pc; + continue Loop; + case Icode_SETCONSTVAR1: + indexReg = iCode[frame.pc++]; + // fallthrough + case Token.SETCONSTVAR : + if (!frame.useActivation) { + if ((varAttributes[indexReg] & ScriptableObject.READONLY) == 0) { + throw Context.reportRuntimeError1("msg.var.redecl", + frame.idata.argNames[indexReg]); + } + if ((varAttributes[indexReg] & ScriptableObject.UNINITIALIZED_CONST) + != 0) + { + vars[indexReg] = stack[stackTop]; + varAttributes[indexReg] &= ~ScriptableObject.UNINITIALIZED_CONST; + varDbls[indexReg] = sDbl[stackTop]; + } + } else { + Object val = stack[stackTop]; + if (val == DBL_MRK) val = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stringReg = frame.idata.argNames[indexReg]; + if (frame.scope instanceof ConstProperties) { + ConstProperties cp = (ConstProperties)frame.scope; + cp.putConst(stringReg, frame.scope, val); + } else + throw Kit.codeBug(); + } + continue Loop; + case Icode_SETVAR1: + indexReg = iCode[frame.pc++]; + // fallthrough + case Token.SETVAR : + if (!frame.useActivation) { + if ((varAttributes[indexReg] & ScriptableObject.READONLY) == 0) { + vars[indexReg] = stack[stackTop]; + varDbls[indexReg] = sDbl[stackTop]; + } + } else { + Object val = stack[stackTop]; + if (val == DBL_MRK) val = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stringReg = frame.idata.argNames[indexReg]; + frame.scope.put(stringReg, frame.scope, val); + } + continue Loop; + case Icode_GETVAR1: + indexReg = iCode[frame.pc++]; + // fallthrough + case Token.GETVAR : + ++stackTop; + if (!frame.useActivation) { + stack[stackTop] = vars[indexReg]; + sDbl[stackTop] = varDbls[indexReg]; + } else { + stringReg = frame.idata.argNames[indexReg]; + stack[stackTop] = frame.scope.get(stringReg, frame.scope); + } + continue Loop; + case Icode_VAR_INC_DEC : { + // indexReg : varindex + ++stackTop; + int incrDecrMask = iCode[frame.pc]; + if (!frame.useActivation) { + stack[stackTop] = DBL_MRK; + Object varValue = vars[indexReg]; + double d; + if (varValue == DBL_MRK) { + d = varDbls[indexReg]; + } else { + d = ScriptRuntime.toNumber(varValue); + vars[indexReg] = DBL_MRK; + } + double d2 = ((incrDecrMask & Node.DECR_FLAG) == 0) + ? d + 1.0 : d - 1.0; + varDbls[indexReg] = d2; + sDbl[stackTop] = ((incrDecrMask & Node.POST_FLAG) == 0) ? d2 : d; + } else { + String varName = frame.idata.argNames[indexReg]; + stack[stackTop] = ScriptRuntime.nameIncrDecr(frame.scope, varName, + cx, incrDecrMask); + } + ++frame.pc; + continue Loop; + } + case Icode_ZERO : + ++stackTop; + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = 0; + continue Loop; + case Icode_ONE : + ++stackTop; + stack[stackTop] = DBL_MRK; + sDbl[stackTop] = 1; + continue Loop; + case Token.NULL : + stack[++stackTop] = null; + continue Loop; + case Token.THIS : + stack[++stackTop] = frame.thisObj; + continue Loop; + case Token.THISFN : + stack[++stackTop] = frame.fnOrScript; + continue Loop; + case Token.FALSE : + stack[++stackTop] = Boolean.FALSE; + continue Loop; + case Token.TRUE : + stack[++stackTop] = Boolean.TRUE; + continue Loop; + case Icode_UNDEF : + stack[++stackTop] = undefined; + continue Loop; + case Token.ENTERWITH : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + frame.scope = ScriptRuntime.enterWith(lhs, cx, frame.scope); + continue Loop; + } + case Token.LEAVEWITH : + frame.scope = ScriptRuntime.leaveWith(frame.scope); + continue Loop; + case Token.CATCH_SCOPE : { + // stack top: exception object + // stringReg: name of exception variable + // indexReg: local for exception scope + --stackTop; + indexReg += frame.localShift; + + boolean afterFirstScope = (frame.idata.itsICode[frame.pc] != 0); + Throwable caughtException = (Throwable)stack[stackTop + 1]; + Scriptable lastCatchScope; + if (!afterFirstScope) { + lastCatchScope = null; + } else { + lastCatchScope = (Scriptable)stack[indexReg]; + } + stack[indexReg] = ScriptRuntime.newCatchScope(caughtException, + lastCatchScope, stringReg, + cx, frame.scope); + ++frame.pc; + continue Loop; + } + case Token.ENUM_INIT_KEYS : + case Token.ENUM_INIT_VALUES : + case Token.ENUM_INIT_ARRAY : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + indexReg += frame.localShift; + int enumType = op == Token.ENUM_INIT_KEYS + ? ScriptRuntime.ENUMERATE_KEYS : + op == Token.ENUM_INIT_VALUES + ? ScriptRuntime.ENUMERATE_VALUES : + ScriptRuntime.ENUMERATE_ARRAY; + stack[indexReg] = ScriptRuntime.enumInit(lhs, cx, enumType); + continue Loop; + } + case Token.ENUM_NEXT : + case Token.ENUM_ID : { + indexReg += frame.localShift; + Object val = stack[indexReg]; + ++stackTop; + stack[stackTop] = (op == Token.ENUM_NEXT) + ? (Object)ScriptRuntime.enumNext(val) + : (Object)ScriptRuntime.enumId(val, cx); + continue Loop; + } + case Token.REF_SPECIAL : { + //stringReg: name of special property + Object obj = stack[stackTop]; + if (obj == DBL_MRK) obj = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.specialRef(obj, stringReg, cx); + continue Loop; + } + case Token.REF_MEMBER: { + //indexReg: flags + Object elem = stack[stackTop]; + if (elem == DBL_MRK) elem = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object obj = stack[stackTop]; + if (obj == DBL_MRK) obj = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.memberRef(obj, elem, cx, indexReg); + continue Loop; + } + case Token.REF_NS_MEMBER: { + //indexReg: flags + Object elem = stack[stackTop]; + if (elem == DBL_MRK) elem = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object ns = stack[stackTop]; + if (ns == DBL_MRK) ns = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object obj = stack[stackTop]; + if (obj == DBL_MRK) obj = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.memberRef(obj, ns, elem, cx, indexReg); + continue Loop; + } + case Token.REF_NAME: { + //indexReg: flags + Object name = stack[stackTop]; + if (name == DBL_MRK) name = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.nameRef(name, cx, frame.scope, + indexReg); + continue Loop; + } + case Token.REF_NS_NAME: { + //indexReg: flags + Object name = stack[stackTop]; + if (name == DBL_MRK) name = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + Object ns = stack[stackTop]; + if (ns == DBL_MRK) ns = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.nameRef(ns, name, cx, frame.scope, + indexReg); + continue Loop; + } + case Icode_SCOPE_LOAD : + indexReg += frame.localShift; + frame.scope = (Scriptable)stack[indexReg]; + continue Loop; + case Icode_SCOPE_SAVE : + indexReg += frame.localShift; + stack[indexReg] = frame.scope; + continue Loop; + case Icode_CLOSURE_EXPR : + stack[++stackTop] = InterpretedFunction.createFunction(cx, frame.scope, + frame.fnOrScript, + indexReg); + continue Loop; + case Icode_CLOSURE_STMT : + initFunction(cx, frame.scope, frame.fnOrScript, indexReg); + continue Loop; + case Token.REGEXP : + stack[++stackTop] = frame.scriptRegExps[indexReg]; + continue Loop; + case Icode_LITERAL_NEW : + // indexReg: number of values in the literal + ++stackTop; + stack[stackTop] = new int[indexReg]; + ++stackTop; + stack[stackTop] = new Object[indexReg]; + sDbl[stackTop] = 0; + continue Loop; + case Icode_LITERAL_SET : { + Object value = stack[stackTop]; + if (value == DBL_MRK) value = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + int i = (int)sDbl[stackTop]; + ((Object[])stack[stackTop])[i] = value; + sDbl[stackTop] = i + 1; + continue Loop; + } + case Icode_LITERAL_GETTER : { + Object value = stack[stackTop]; + --stackTop; + int i = (int)sDbl[stackTop]; + ((Object[])stack[stackTop])[i] = value; + ((int[])stack[stackTop - 1])[i] = -1; + sDbl[stackTop] = i + 1; + continue Loop; + } + case Icode_LITERAL_SETTER : { + Object value = stack[stackTop]; + --stackTop; + int i = (int)sDbl[stackTop]; + ((Object[])stack[stackTop])[i] = value; + ((int[])stack[stackTop - 1])[i] = +1; + sDbl[stackTop] = i + 1; + continue Loop; + } + case Token.ARRAYLIT : + case Icode_SPARE_ARRAYLIT : + case Token.OBJECTLIT : { + Object[] data = (Object[])stack[stackTop]; + --stackTop; + int[] getterSetters = (int[])stack[stackTop]; + Object val; + if (op == Token.OBJECTLIT) { + Object[] ids = (Object[])frame.idata.literalIds[indexReg]; + val = ScriptRuntime.newObjectLiteral(ids, data, getterSetters, cx, + frame.scope); + } else { + int[] skipIndexces = null; + if (op == Icode_SPARE_ARRAYLIT) { + skipIndexces = (int[])frame.idata.literalIds[indexReg]; + } + val = ScriptRuntime.newArrayLiteral(data, skipIndexces, cx, + frame.scope); + } + stack[stackTop] = val; + continue Loop; + } + case Icode_ENTERDQ : { + Object lhs = stack[stackTop]; + if (lhs == DBL_MRK) lhs = ScriptRuntime.wrapNumber(sDbl[stackTop]); + --stackTop; + frame.scope = ScriptRuntime.enterDotQuery(lhs, frame.scope); + continue Loop; + } + case Icode_LEAVEDQ : { + boolean valBln = stack_boolean(frame, stackTop); + Object x = ScriptRuntime.updateDotQuery(valBln, frame.scope); + if (x != null) { + stack[stackTop] = x; + frame.scope = ScriptRuntime.leaveDotQuery(frame.scope); + frame.pc += 2; + continue Loop; + } + // reset stack and PC to code after ENTERDQ + --stackTop; + break jumplessRun; + } + case Token.DEFAULTNAMESPACE : { + Object value = stack[stackTop]; + if (value == DBL_MRK) value = ScriptRuntime.wrapNumber(sDbl[stackTop]); + stack[stackTop] = ScriptRuntime.setDefaultNamespace(value, cx); + continue Loop; + } + case Token.ESCXMLATTR : { + Object value = stack[stackTop]; + if (value != DBL_MRK) { + stack[stackTop] = ScriptRuntime.escapeAttributeValue(value, cx); + } + continue Loop; + } + case Token.ESCXMLTEXT : { + Object value = stack[stackTop]; + if (value != DBL_MRK) { + stack[stackTop] = ScriptRuntime.escapeTextValue(value, cx); + } + continue Loop; + } + case Icode_DEBUGGER: + if (frame.debuggerFrame != null) { + frame.debuggerFrame.onDebuggerStatement(cx); + } + break Loop; + case Icode_LINE : + frame.pcSourceLineStart = frame.pc; + if (frame.debuggerFrame != null) { + int line = getIndex(iCode, frame.pc); + frame.debuggerFrame.onLineChange(cx, line); + } + frame.pc += 2; + continue Loop; + case Icode_REG_IND_C0: + indexReg = 0; + continue Loop; + case Icode_REG_IND_C1: + indexReg = 1; + continue Loop; + case Icode_REG_IND_C2: + indexReg = 2; + continue Loop; + case Icode_REG_IND_C3: + indexReg = 3; + continue Loop; + case Icode_REG_IND_C4: + indexReg = 4; + continue Loop; + case Icode_REG_IND_C5: + indexReg = 5; + continue Loop; + case Icode_REG_IND1: + indexReg = 0xFF & iCode[frame.pc]; + ++frame.pc; + continue Loop; + case Icode_REG_IND2: + indexReg = getIndex(iCode, frame.pc); + frame.pc += 2; + continue Loop; + case Icode_REG_IND4: + indexReg = getInt(iCode, frame.pc); + frame.pc += 4; + continue Loop; + case Icode_REG_STR_C0: + stringReg = strings[0]; + continue Loop; + case Icode_REG_STR_C1: + stringReg = strings[1]; + continue Loop; + case Icode_REG_STR_C2: + stringReg = strings[2]; + continue Loop; + case Icode_REG_STR_C3: + stringReg = strings[3]; + continue Loop; + case Icode_REG_STR1: + stringReg = strings[0xFF & iCode[frame.pc]]; + ++frame.pc; + continue Loop; + case Icode_REG_STR2: + stringReg = strings[getIndex(iCode, frame.pc)]; + frame.pc += 2; + continue Loop; + case Icode_REG_STR4: + stringReg = strings[getInt(iCode, frame.pc)]; + frame.pc += 4; + continue Loop; + default : + dumpICode(frame.idata); + throw new RuntimeException( + "Unknown icode : "+op+" @ pc : "+(frame.pc-1)); +} // end of interpreter switch + + } // end of jumplessRun label block + + // This should be reachable only for jump implementation + // when pc points to encoded target offset + if (instructionCounting) { + addInstructionCount(cx, frame, 2); + } + int offset = getShort(iCode, frame.pc); + if (offset != 0) { + // -1 accounts for pc pointing to jump opcode + 1 + frame.pc += offset - 1; + } else { + frame.pc = frame.idata.longJumps. + getExistingInt(frame.pc); + } + if (instructionCounting) { + frame.pcPrevBranch = frame.pc; + } + continue Loop; + + } // end of Loop: for + + exitFrame(cx, frame, null); + interpreterResult = frame.result; + interpreterResultDbl = frame.resultDbl; + if (frame.parentFrame != null) { + frame = frame.parentFrame; + if (frame.frozen) { + frame = frame.cloneFrozen(); + } + setCallResult( + frame, interpreterResult, interpreterResultDbl); + interpreterResult = null; // Help GC + continue StateLoop; + } + break StateLoop; + + } // end of interpreter withoutExceptions: try + catch (Throwable ex) { + if (throwable != null) { + // This is serious bug and it is better to track it ASAP + ex.printStackTrace(System.err); + throw new IllegalStateException(); + } + throwable = ex; + } + + // This should be reachable only after above catch or from + // finally when it needs to propagate exception or from + // explicit throw + if (throwable == null) Kit.codeBug(); + + // Exception type + final int EX_CATCH_STATE = 2; // Can execute JS catch + final int EX_FINALLY_STATE = 1; // Can execute JS finally + final int EX_NO_JS_STATE = 0; // Terminate JS execution + + int exState; + ContinuationJump cjump = null; + + if (generatorState != null && + generatorState.operation == NativeGenerator.GENERATOR_CLOSE && + throwable == generatorState.value) + { + exState = EX_FINALLY_STATE; + } else if (throwable instanceof JavaScriptException) { + exState = EX_CATCH_STATE; + } else if (throwable instanceof EcmaError) { + // an offical ECMA error object, + exState = EX_CATCH_STATE; + } else if (throwable instanceof EvaluatorException) { + exState = EX_CATCH_STATE; + } else if (throwable instanceof RuntimeException) { + exState = cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS) + ? EX_CATCH_STATE + : EX_FINALLY_STATE; + } else if (throwable instanceof Error) { + exState = cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS) + ? EX_CATCH_STATE + : EX_NO_JS_STATE; + } else if (throwable instanceof ContinuationJump) { + // It must be ContinuationJump + exState = EX_FINALLY_STATE; + cjump = (ContinuationJump)throwable; + } else { + exState = cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS) + ? EX_CATCH_STATE + : EX_FINALLY_STATE; + } + + if (instructionCounting) { + try { + addInstructionCount(cx, frame, EXCEPTION_COST); + } catch (RuntimeException ex) { + throwable = ex; + exState = EX_FINALLY_STATE; + } catch (Error ex) { + // Error from instruction counting + // => unconditionally terminate JS + throwable = ex; + cjump = null; + exState = EX_NO_JS_STATE; + } + } + if (frame.debuggerFrame != null + && throwable instanceof RuntimeException) + { + // Call debugger only for RuntimeException + RuntimeException rex = (RuntimeException)throwable; + try { + frame.debuggerFrame.onExceptionThrown(cx, rex); + } catch (Throwable ex) { + // Any exception from debugger + // => unconditionally terminate JS + throwable = ex; + cjump = null; + exState = EX_NO_JS_STATE; + } + } + + for (;;) { + if (exState != EX_NO_JS_STATE) { + boolean onlyFinally = (exState != EX_CATCH_STATE); + indexReg = getExceptionHandler(frame, onlyFinally); + if (indexReg >= 0) { + // We caught an exception, restart the loop + // with exception pending the processing at the loop + // start + continue StateLoop; + } + } + // No allowed exception handlers in this frame, unwind + // to parent and try to look there + + exitFrame(cx, frame, throwable); + + frame = frame.parentFrame; + if (frame == null) { break; } + if (cjump != null && cjump.branchFrame == frame) { + // Continuation branch point was hit, + // restart the state loop to reenter continuation + indexReg = -1; + continue StateLoop; + } + } + + // No more frames, rethrow the exception or deal with continuation + if (cjump != null) { + if (cjump.branchFrame != null) { + // The above loop should locate the top frame + Kit.codeBug(); + } + if (cjump.capturedFrame != null) { + // Restarting detached continuation + indexReg = -1; + continue StateLoop; + } + // Return continuation result to the caller + interpreterResult = cjump.result; + interpreterResultDbl = cjump.resultDbl; + throwable = null; + } + break StateLoop; + + } // end of StateLoop: for(;;) + + // Do cleanups/restorations before the final return or throw + + if (cx.previousInterpreterInvocations != null + && cx.previousInterpreterInvocations.size() != 0) + { + cx.lastInterpreterFrame + = cx.previousInterpreterInvocations.pop(); + } else { + // It was the last interpreter frame on the stack + cx.lastInterpreterFrame = null; + // Force GC of the value cx.previousInterpreterInvocations + cx.previousInterpreterInvocations = null; + } + + if (throwable != null) { + if (throwable instanceof RuntimeException) { + throw (RuntimeException)throwable; + } else { + // Must be instance of Error or code bug + throw (Error)throwable; + } + } + + return (interpreterResult != DBL_MRK) + ? interpreterResult + : ScriptRuntime.wrapNumber(interpreterResultDbl); + } + + private static CallFrame processThrowable(Context cx, Object throwable, + CallFrame frame, int indexReg, + boolean instructionCounting) + { + // Recovering from exception, indexReg contains + // the index of handler + + if (indexReg >= 0) { + // Normal exception handler, transfer + // control appropriately + + if (frame.frozen) { + // XXX Deal with exceptios!!! + frame = frame.cloneFrozen(); + } + + int[] table = frame.idata.itsExceptionTable; + + frame.pc = table[indexReg + EXCEPTION_HANDLER_SLOT]; + if (instructionCounting) { + frame.pcPrevBranch = frame.pc; + } + + frame.savedStackTop = frame.emptyStackTop; + int scopeLocal = frame.localShift + + table[indexReg + + EXCEPTION_SCOPE_SLOT]; + int exLocal = frame.localShift + + table[indexReg + + EXCEPTION_LOCAL_SLOT]; + frame.scope = (Scriptable)frame.stack[scopeLocal]; + frame.stack[exLocal] = throwable; + + throwable = null; + } else { + // Continuation restoration + ContinuationJump cjump = (ContinuationJump)throwable; + + // Clear throwable to indicate that exceptions are OK + throwable = null; + + if (cjump.branchFrame != frame) Kit.codeBug(); + + // Check that we have at least one frozen frame + // in the case of detached continuation restoration: + // unwind code ensure that + if (cjump.capturedFrame == null) Kit.codeBug(); + + // Need to rewind branchFrame, capturedFrame + // and all frames in between + int rewindCount = cjump.capturedFrame.frameIndex + 1; + if (cjump.branchFrame != null) { + rewindCount -= cjump.branchFrame.frameIndex; + } + + int enterCount = 0; + CallFrame[] enterFrames = null; + + CallFrame x = cjump.capturedFrame; + for (int i = 0; i != rewindCount; ++i) { + if (!x.frozen) Kit.codeBug(); + if (isFrameEnterExitRequired(x)) { + if (enterFrames == null) { + // Allocate enough space to store the rest + // of rewind frames in case all of them + // would require to enter + enterFrames = new CallFrame[rewindCount + - i]; + } + enterFrames[enterCount] = x; + ++enterCount; + } + x = x.parentFrame; + } + + while (enterCount != 0) { + // execute enter: walk enterFrames in the reverse + // order since they were stored starting from + // the capturedFrame, not branchFrame + --enterCount; + x = enterFrames[enterCount]; + enterFrame(cx, x, ScriptRuntime.emptyArgs, true); + } + + // Continuation jump is almost done: capturedFrame + // points to the call to the function that captured + // continuation, so clone capturedFrame and + // emulate return that function with the suplied result + frame = cjump.capturedFrame.cloneFrozen(); + setCallResult(frame, cjump.result, cjump.resultDbl); + // restart the execution + } + frame.throwable = throwable; + return frame; + } + + private static Object freezeGenerator(Context cx, CallFrame frame, + int stackTop, + GeneratorState generatorState) + { + if (generatorState.operation == NativeGenerator.GENERATOR_CLOSE) { + // Error: no yields when generator is closing + throw ScriptRuntime.typeError0("msg.yield.closing"); + } + // return to our caller (which should be a method of NativeGenerator) + frame.frozen = true; + frame.result = frame.stack[stackTop]; + frame.resultDbl = frame.sDbl[stackTop]; + frame.savedStackTop = stackTop; + frame.pc--; // we want to come back here when we resume + ScriptRuntime.exitActivationFunction(cx); + return (frame.result != UniqueTag.DOUBLE_MARK) + ? frame.result + : ScriptRuntime.wrapNumber(frame.resultDbl); + } + + private static Object thawGenerator(CallFrame frame, int stackTop, + GeneratorState generatorState, int op) + { + // we are resuming execution + frame.frozen = false; + int sourceLine = getIndex(frame.idata.itsICode, frame.pc); + frame.pc += 2; // skip line number data + if (generatorState.operation == NativeGenerator.GENERATOR_THROW) { + // processing a call to <generator>.throw(exception): must + // act as if exception was thrown from resumption point + return new JavaScriptException(generatorState.value, + frame.idata.itsSourceFile, + sourceLine); + } + if (generatorState.operation == NativeGenerator.GENERATOR_CLOSE) { + return generatorState.value; + } + if (generatorState.operation != NativeGenerator.GENERATOR_SEND) + throw Kit.codeBug(); + if (op == Token.YIELD) + frame.stack[stackTop] = generatorState.value; + return Scriptable.NOT_FOUND; + } + + private static CallFrame initFrameForApplyOrCall(Context cx, CallFrame frame, + int indexReg, Object[] stack, double[] sDbl, int stackTop, int op, + Scriptable calleeScope, IdFunctionObject ifun, + InterpretedFunction iApplyCallable) + { + Scriptable applyThis; + if (indexReg != 0) { + applyThis = ScriptRuntime.toObjectOrNull(cx, stack[stackTop + 2]); + } + else { + applyThis = null; + } + if (applyThis == null) { + // This covers the case of args[0] == (null|undefined) as well. + applyThis = ScriptRuntime.getTopCallScope(cx); + } + if(op == Icode_TAIL_CALL) { + exitFrame(cx, frame, null); + frame = frame.parentFrame; + } + else { + frame.savedStackTop = stackTop; + frame.savedCallOp = op; + } + CallFrame calleeFrame = new CallFrame(); + if(BaseFunction.isApply(ifun)) { + Object[] callArgs = indexReg < 2 ? ScriptRuntime.emptyArgs : + ScriptRuntime.getApplyArguments(cx, stack[stackTop + 3]); + initFrame(cx, calleeScope, applyThis, callArgs, null, 0, + callArgs.length, iApplyCallable, frame, calleeFrame); + } + else { + // Shift args left + for(int i = 1; i < indexReg; ++i) { + stack[stackTop + 1 + i] = stack[stackTop + 2 + i]; + sDbl[stackTop + 1 + i] = sDbl[stackTop + 2 + i]; + } + int argCount = indexReg < 2 ? 0 : indexReg - 1; + initFrame(cx, calleeScope, applyThis, stack, sDbl, stackTop + 2, + argCount, iApplyCallable, frame, calleeFrame); + } + + frame = calleeFrame; + return frame; + } + + private static void initFrame(Context cx, Scriptable callerScope, + Scriptable thisObj, + Object[] args, double[] argsDbl, + int argShift, int argCount, + InterpretedFunction fnOrScript, + CallFrame parentFrame, CallFrame frame) + { + InterpreterData idata = fnOrScript.idata; + + boolean useActivation = idata.itsNeedsActivation; + DebugFrame debuggerFrame = null; + if (cx.debugger != null) { + debuggerFrame = cx.debugger.getFrame(cx, idata); + if (debuggerFrame != null) { + useActivation = true; + } + } + + if (useActivation) { + // Copy args to new array to pass to enterActivationFunction + // or debuggerFrame.onEnter + if (argsDbl != null) { + args = getArgsArray(args, argsDbl, argShift, argCount); + } + argShift = 0; + argsDbl = null; + } + + Scriptable scope; + if (idata.itsFunctionType != 0) { + if (!idata.useDynamicScope) { + scope = fnOrScript.getParentScope(); + } else { + scope = callerScope; + } + + if (useActivation) { + scope = ScriptRuntime.createFunctionActivation( + fnOrScript, scope, args); + } + } else { + scope = callerScope; + ScriptRuntime.initScript(fnOrScript, thisObj, cx, scope, + fnOrScript.idata.evalScriptFlag); + } + + if (idata.itsNestedFunctions != null) { + if (idata.itsFunctionType != 0 && !idata.itsNeedsActivation) + Kit.codeBug(); + for (int i = 0; i < idata.itsNestedFunctions.length; i++) { + InterpreterData fdata = idata.itsNestedFunctions[i]; + if (fdata.itsFunctionType == FunctionNode.FUNCTION_STATEMENT) { + initFunction(cx, scope, fnOrScript, i); + } + } + } + + Scriptable[] scriptRegExps = null; + if (idata.itsRegExpLiterals != null) { + // Wrapped regexps for functions are stored in + // InterpretedFunction + // but for script which should not contain references to scope + // the regexps re-wrapped during each script execution + if (idata.itsFunctionType != 0) { + scriptRegExps = fnOrScript.functionRegExps; + } else { + scriptRegExps = fnOrScript.createRegExpWraps(cx, scope); + } + } + + // Initialize args, vars, locals and stack + + int emptyStackTop = idata.itsMaxVars + idata.itsMaxLocals - 1; + int maxFrameArray = idata.itsMaxFrameArray; + if (maxFrameArray != emptyStackTop + idata.itsMaxStack + 1) + Kit.codeBug(); + + Object[] stack; + int[] stackAttributes; + double[] sDbl; + boolean stackReuse; + if (frame.stack != null && maxFrameArray <= frame.stack.length) { + // Reuse stacks from old frame + stackReuse = true; + stack = frame.stack; + stackAttributes = frame.stackAttributes; + sDbl = frame.sDbl; + } else { + stackReuse = false; + stack = new Object[maxFrameArray]; + stackAttributes = new int[maxFrameArray]; + sDbl = new double[maxFrameArray]; + } + + int varCount = idata.getParamAndVarCount(); + for (int i = 0; i < varCount; i++) { + if (idata.getParamOrVarConst(i)) + stackAttributes[i] = ScriptableObject.CONST; + } + int definedArgs = idata.argCount; + if (definedArgs > argCount) { definedArgs = argCount; } + + // Fill the frame structure + + frame.parentFrame = parentFrame; + frame.frameIndex = (parentFrame == null) + ? 0 : parentFrame.frameIndex + 1; + if(frame.frameIndex > cx.getMaximumInterpreterStackDepth()) + { + throw Context.reportRuntimeError("Exceeded maximum stack depth"); + } + frame.frozen = false; + + frame.fnOrScript = fnOrScript; + frame.idata = idata; + + frame.stack = stack; + frame.stackAttributes = stackAttributes; + frame.sDbl = sDbl; + frame.varSource = frame; + frame.localShift = idata.itsMaxVars; + frame.emptyStackTop = emptyStackTop; + + frame.debuggerFrame = debuggerFrame; + frame.useActivation = useActivation; + + frame.thisObj = thisObj; + frame.scriptRegExps = scriptRegExps; + + // Initialize initial values of variables that change during + // interpretation. + frame.result = Undefined.instance; + frame.pc = 0; + frame.pcPrevBranch = 0; + frame.pcSourceLineStart = idata.firstLinePC; + frame.scope = scope; + + frame.savedStackTop = emptyStackTop; + frame.savedCallOp = 0; + + System.arraycopy(args, argShift, stack, 0, definedArgs); + if (argsDbl != null) { + System.arraycopy(argsDbl, argShift, sDbl, 0, definedArgs); + } + for (int i = definedArgs; i != idata.itsMaxVars; ++i) { + stack[i] = Undefined.instance; + } + if (stackReuse) { + // Clean the stack part and space beyond stack if any + // of the old array to allow to GC objects there + for (int i = emptyStackTop + 1; i != stack.length; ++i) { + stack[i] = null; + } + } + + enterFrame(cx, frame, args, false); + } + + private static boolean isFrameEnterExitRequired(CallFrame frame) + { + return frame.debuggerFrame != null || frame.idata.itsNeedsActivation; + } + + private static void enterFrame(Context cx, CallFrame frame, Object[] args, + boolean continuationRestart) + { + boolean usesActivation = frame.idata.itsNeedsActivation; + boolean isDebugged = frame.debuggerFrame != null; + if(usesActivation || isDebugged) { + Scriptable scope = frame.scope; + if(scope == null) { + Kit.codeBug(); + } else if (continuationRestart) { + // Walk the parent chain of frame.scope until a NativeCall is + // found. Normally, frame.scope is a NativeCall when called + // from initFrame() for a debugged or activatable function. + // However, when called from interpretLoop() as part of + // restarting a continuation, it can also be a NativeWith if + // the continuation was captured within a "with" or "catch" + // block ("catch" implicitly uses NativeWith to create a scope + // to expose the exception variable). + for(;;) { + if(scope instanceof NativeWith) { + scope = scope.getParentScope(); + if (scope == null || (frame.parentFrame != null && + frame.parentFrame.scope == scope)) + { + // If we get here, we didn't find a NativeCall in + // the call chain before reaching parent frame's + // scope. This should not be possible. + Kit.codeBug(); + break; // Never reached, but keeps the static analyzer happy about "scope" not being null 5 lines above. + } + } + else { + break; + } + } + } + if (isDebugged) { + frame.debuggerFrame.onEnter(cx, scope, frame.thisObj, args); + } + // Enter activation only when itsNeedsActivation true, + // since debugger should not interfere with activation + // chaining + if (usesActivation) { + ScriptRuntime.enterActivationFunction(cx, scope); + } + } + } + + private static void exitFrame(Context cx, CallFrame frame, + Object throwable) + { + if (frame.idata.itsNeedsActivation) { + ScriptRuntime.exitActivationFunction(cx); + } + + if (frame.debuggerFrame != null) { + try { + if (throwable instanceof Throwable) { + frame.debuggerFrame.onExit(cx, true, throwable); + } else { + Object result; + ContinuationJump cjump = (ContinuationJump)throwable; + if (cjump == null) { + result = frame.result; + } else { + result = cjump.result; + } + if (result == UniqueTag.DOUBLE_MARK) { + double resultDbl; + if (cjump == null) { + resultDbl = frame.resultDbl; + } else { + resultDbl = cjump.resultDbl; + } + result = ScriptRuntime.wrapNumber(resultDbl); + } + frame.debuggerFrame.onExit(cx, false, result); + } + } catch (Throwable ex) { + System.err.println( +"RHINO USAGE WARNING: onExit terminated with exception"); + ex.printStackTrace(System.err); + } + } + } + + private static void setCallResult(CallFrame frame, + Object callResult, + double callResultDbl) + { + if (frame.savedCallOp == Token.CALL) { + frame.stack[frame.savedStackTop] = callResult; + frame.sDbl[frame.savedStackTop] = callResultDbl; + } else if (frame.savedCallOp == Token.NEW) { + // If construct returns scriptable, + // then it replaces on stack top saved original instance + // of the object. + if (callResult instanceof Scriptable) { + frame.stack[frame.savedStackTop] = callResult; + } + } else { + Kit.codeBug(); + } + frame.savedCallOp = 0; + } + + private static void captureContinuation(Context cx, CallFrame frame, + int stackTop) + { + Continuation c = new Continuation(); + ScriptRuntime.setObjectProtoAndParent( + c, ScriptRuntime.getTopCallScope(cx)); + + // Make sure that all frames upstack frames are frozen + CallFrame x = frame.parentFrame; + while (x != null && !x.frozen) { + x.frozen = true; + // Allow to GC unused stack space + for (int i = x.savedStackTop + 1; i != x.stack.length; ++i) { + // Allow to GC unused stack space + x.stack[i] = null; + x.stackAttributes[i] = ScriptableObject.EMPTY; + } + if (x.savedCallOp == Token.CALL) { + // the call will always overwrite the stack top with the result + x.stack[x.savedStackTop] = null; + } else { + if (x.savedCallOp != Token.NEW) Kit.codeBug(); + // the new operator uses stack top to store the constructed + // object so it shall not be cleared: see comments in + // setCallResult + } + x = x.parentFrame; + } + + c.initImplementation(frame.parentFrame); + frame.stack[stackTop] = c; + } + + private static int stack_int32(CallFrame frame, int i) + { + Object x = frame.stack[i]; + double value; + if (x == UniqueTag.DOUBLE_MARK) { + value = frame.sDbl[i]; + } else { + value = ScriptRuntime.toNumber(x); + } + return ScriptRuntime.toInt32(value); + } + + private static double stack_double(CallFrame frame, int i) + { + Object x = frame.stack[i]; + if (x != UniqueTag.DOUBLE_MARK) { + return ScriptRuntime.toNumber(x); + } else { + return frame.sDbl[i]; + } + } + + private static boolean stack_boolean(CallFrame frame, int i) + { + Object x = frame.stack[i]; + if (x == Boolean.TRUE) { + return true; + } else if (x == Boolean.FALSE) { + return false; + } else if (x == UniqueTag.DOUBLE_MARK) { + double d = frame.sDbl[i]; + return d == d && d != 0.0; + } else if (x == null || x == Undefined.instance) { + return false; + } else if (x instanceof Number) { + double d = ((Number)x).doubleValue(); + return (d == d && d != 0.0); + } else if (x instanceof Boolean) { + return ((Boolean)x).booleanValue(); + } else { + return ScriptRuntime.toBoolean(x); + } + } + + private static void do_add(Object[] stack, double[] sDbl, int stackTop, + Context cx) + { + Object rhs = stack[stackTop + 1]; + Object lhs = stack[stackTop]; + double d; + boolean leftRightOrder; + if (rhs == UniqueTag.DOUBLE_MARK) { + d = sDbl[stackTop + 1]; + if (lhs == UniqueTag.DOUBLE_MARK) { + sDbl[stackTop] += d; + return; + } + leftRightOrder = true; + // fallthrough to object + number code + } else if (lhs == UniqueTag.DOUBLE_MARK) { + d = sDbl[stackTop]; + lhs = rhs; + leftRightOrder = false; + // fallthrough to object + number code + } else { + if (lhs instanceof Scriptable || rhs instanceof Scriptable) { + stack[stackTop] = ScriptRuntime.add(lhs, rhs, cx); + } else if (lhs instanceof String) { + String lstr = (String)lhs; + String rstr = ScriptRuntime.toString(rhs); + stack[stackTop] = lstr.concat(rstr); + } else if (rhs instanceof String) { + String lstr = ScriptRuntime.toString(lhs); + String rstr = (String)rhs; + stack[stackTop] = lstr.concat(rstr); + } else { + double lDbl = (lhs instanceof Number) + ? ((Number)lhs).doubleValue() : ScriptRuntime.toNumber(lhs); + double rDbl = (rhs instanceof Number) + ? ((Number)rhs).doubleValue() : ScriptRuntime.toNumber(rhs); + stack[stackTop] = UniqueTag.DOUBLE_MARK; + sDbl[stackTop] = lDbl + rDbl; + } + return; + } + + // handle object(lhs) + number(d) code + if (lhs instanceof Scriptable) { + rhs = ScriptRuntime.wrapNumber(d); + if (!leftRightOrder) { + Object tmp = lhs; + lhs = rhs; + rhs = tmp; + } + stack[stackTop] = ScriptRuntime.add(lhs, rhs, cx); + } else if (lhs instanceof String) { + String lstr = (String)lhs; + String rstr = ScriptRuntime.toString(d); + if (leftRightOrder) { + stack[stackTop] = lstr.concat(rstr); + } else { + stack[stackTop] = rstr.concat(lstr); + } + } else { + double lDbl = (lhs instanceof Number) + ? ((Number)lhs).doubleValue() : ScriptRuntime.toNumber(lhs); + stack[stackTop] = UniqueTag.DOUBLE_MARK; + sDbl[stackTop] = lDbl + d; + } + } + + private static Object[] getArgsArray(Object[] stack, double[] sDbl, + int shift, int count) + { + if (count == 0) { + return ScriptRuntime.emptyArgs; + } + Object[] args = new Object[count]; + for (int i = 0; i != count; ++i, ++shift) { + Object val = stack[shift]; + if (val == UniqueTag.DOUBLE_MARK) { + val = ScriptRuntime.wrapNumber(sDbl[shift]); + } + args[i] = val; + } + return args; + } + + private static void addInstructionCount(Context cx, CallFrame frame, + int extra) + { + cx.instructionCount += frame.pc - frame.pcPrevBranch + extra; + if (cx.instructionCount > cx.instructionThreshold) { + cx.observeInstructionCount(cx.instructionCount); + cx.instructionCount = 0; + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpreterData.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpreterData.java new file mode 100644 index 0000000..7435b10 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/InterpreterData.java @@ -0,0 +1,192 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Bob Jervis + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; + +import org.mozilla.javascript.debug.DebuggableScript; + +final class InterpreterData implements Serializable, DebuggableScript +{ + static final long serialVersionUID = 5067677351589230234L; + + static final int INITIAL_MAX_ICODE_LENGTH = 1024; + static final int INITIAL_STRINGTABLE_SIZE = 64; + static final int INITIAL_NUMBERTABLE_SIZE = 64; + + InterpreterData(int languageVersion, + String sourceFile, String encodedSource) + { + this.languageVersion = languageVersion; + this.itsSourceFile = sourceFile; + this.encodedSource = encodedSource; + + init(); + } + + InterpreterData(InterpreterData parent) + { + this.parentData = parent; + this.languageVersion = parent.languageVersion; + this.itsSourceFile = parent.itsSourceFile; + this.encodedSource = parent.encodedSource; + + init(); + } + + private void init() + { + itsICode = new byte[INITIAL_MAX_ICODE_LENGTH]; + itsStringTable = new String[INITIAL_STRINGTABLE_SIZE]; + } + + String itsName; + String itsSourceFile; + boolean itsNeedsActivation; + int itsFunctionType; + + String[] itsStringTable; + double[] itsDoubleTable; + InterpreterData[] itsNestedFunctions; + Object[] itsRegExpLiterals; + + byte[] itsICode; + + int[] itsExceptionTable; + + int itsMaxVars; + int itsMaxLocals; + int itsMaxStack; + int itsMaxFrameArray; + + // see comments in NativeFuncion for definition of argNames and argCount + String[] argNames; + boolean[] argIsConst; + int argCount; + + int itsMaxCalleeArgs; + + String encodedSource; + int encodedSourceStart; + int encodedSourceEnd; + + int languageVersion; + + boolean useDynamicScope; + + boolean topLevel; + + Object[] literalIds; + + UintMap longJumps; + + int firstLinePC = -1; // PC for the first LINE icode + + InterpreterData parentData; + + boolean evalScriptFlag; // true if script corresponds to eval() code + + public boolean isTopLevel() + { + return topLevel; + } + + public boolean isFunction() + { + return itsFunctionType != 0; + } + + public String getFunctionName() + { + return itsName; + } + + public int getParamCount() + { + return argCount; + } + + public int getParamAndVarCount() + { + return argNames.length; + } + + public String getParamOrVarName(int index) + { + return argNames[index]; + } + + public boolean getParamOrVarConst(int index) + { + return argIsConst[index]; + } + + public String getSourceName() + { + return itsSourceFile; + } + + public boolean isGeneratedScript() + { + return ScriptRuntime.isGeneratedScript(itsSourceFile); + } + + public int[] getLineNumbers() + { + return Interpreter.getLineNumbers(this); + } + + public int getFunctionCount() + { + return (itsNestedFunctions == null) ? 0 : itsNestedFunctions.length; + } + + public DebuggableScript getFunction(int index) + { + return itsNestedFunctions[index]; + } + + public DebuggableScript getParent() + { + return parentData; + } + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaAdapter.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaAdapter.java new file mode 100644 index 0000000..6e0a827 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaAdapter.java @@ -0,0 +1,1129 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Patrick Beard + * Norris Boyd + * Igor Bukanov + * Mike McCabe + * Matthias Radestock + * Andi Vajda + * Andrew Wason + * Kemal Bayram + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import org.mozilla.classfile.*; +import java.lang.reflect.*; +import java.io.*; +import java.security.*; +import java.util.*; + +public final class JavaAdapter implements IdFunctionCall +{ + /** + * Provides a key with which to distinguish previously generated + * adapter classes stored in a hash table. + */ + static class JavaAdapterSignature + { + Class superClass; + Class[] interfaces; + ObjToIntMap names; + + JavaAdapterSignature(Class superClass, Class[] interfaces, + ObjToIntMap names) + { + this.superClass = superClass; + this.interfaces = interfaces; + this.names = names; + } + + public boolean equals(Object obj) + { + if (!(obj instanceof JavaAdapterSignature)) + return false; + JavaAdapterSignature sig = (JavaAdapterSignature) obj; + if (superClass != sig.superClass) + return false; + if (interfaces != sig.interfaces) { + if (interfaces.length != sig.interfaces.length) + return false; + for (int i=0; i < interfaces.length; i++) + if (interfaces[i] != sig.interfaces[i]) + return false; + } + if (names.size() != sig.names.size()) + return false; + ObjToIntMap.Iterator iter = new ObjToIntMap.Iterator(names); + for (iter.start(); !iter.done(); iter.next()) { + String name = (String)iter.getKey(); + int arity = iter.getValue(); + if (arity != names.get(name, arity + 1)) + return false; + } + return true; + } + + public int hashCode() + { + return superClass.hashCode() + | (0x9e3779b9 * (names.size() | (interfaces.length << 16))); + } + } + + public static void init(Context cx, Scriptable scope, boolean sealed) + { + JavaAdapter obj = new JavaAdapter(); + IdFunctionObject ctor = new IdFunctionObject(obj, FTAG, Id_JavaAdapter, + "JavaAdapter", 1, scope); + ctor.markAsConstructor(null); + if (sealed) { + ctor.sealObject(); + } + ctor.exportAsScopeProperty(); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (f.hasTag(FTAG)) { + if (f.methodId() == Id_JavaAdapter) { + return js_createAdapter(cx, scope, args); + } + } + throw f.unknown(); + } + + public static Object convertResult(Object result, Class c) + { + if (result == Undefined.instance && + (c != ScriptRuntime.ObjectClass && + c != ScriptRuntime.StringClass)) + { + // Avoid an error for an undefined value; return null instead. + return null; + } + return Context.jsToJava(result, c); + } + + public static Scriptable createAdapterWrapper(Scriptable obj, + Object adapter) + { + Scriptable scope = ScriptableObject.getTopLevelScope(obj); + NativeJavaObject res = new NativeJavaObject(scope, adapter, null, true); + res.setPrototype(obj); + return res; + } + + public static Object getAdapterSelf(Class adapterClass, Object adapter) + throws NoSuchFieldException, IllegalAccessException + { + Field self = adapterClass.getDeclaredField("self"); + return self.get(adapter); + } + + static Object js_createAdapter(Context cx, Scriptable scope, Object[] args) + { + int N = args.length; + if (N == 0) { + throw ScriptRuntime.typeError0("msg.adapter.zero.args"); + } + + Class superClass = null; + Class[] intfs = new Class[N - 1]; + int interfaceCount = 0; + for (int i = 0; i != N - 1; ++i) { + Object arg = args[i]; + if (!(arg instanceof NativeJavaClass)) { + throw ScriptRuntime.typeError2("msg.not.java.class.arg", + String.valueOf(i), + ScriptRuntime.toString(arg)); + } + Class c = ((NativeJavaClass) arg).getClassObject(); + if (!c.isInterface()) { + if (superClass != null) { + throw ScriptRuntime.typeError2("msg.only.one.super", + superClass.getName(), c.getName()); + } + superClass = c; + } else { + intfs[interfaceCount++] = c; + } + } + + if (superClass == null) + superClass = ScriptRuntime.ObjectClass; + + Class[] interfaces = new Class[interfaceCount]; + System.arraycopy(intfs, 0, interfaces, 0, interfaceCount); + Scriptable obj = ScriptRuntime.toObject(cx, scope, args[N - 1]); + + Class adapterClass = getAdapterClass(scope, superClass, interfaces, + obj); + + Class[] ctorParms = { + ScriptRuntime.ContextFactoryClass, + ScriptRuntime.ScriptableClass + }; + Object[] ctorArgs = { cx.getFactory(), obj }; + try { + Object adapter = adapterClass.getConstructor(ctorParms). + newInstance(ctorArgs); + return getAdapterSelf(adapterClass, adapter); + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } + + // Needed by NativeJavaObject serializer + public static void writeAdapterObject(Object javaObject, + ObjectOutputStream out) + throws IOException + { + Class cl = javaObject.getClass(); + out.writeObject(cl.getSuperclass().getName()); + + Class[] interfaces = cl.getInterfaces(); + String[] interfaceNames = new String[interfaces.length]; + + for (int i=0; i < interfaces.length; i++) + interfaceNames[i] = interfaces[i].getName(); + + out.writeObject(interfaceNames); + + try { + Object delegee = cl.getField("delegee").get(javaObject); + out.writeObject(delegee); + return; + } catch (IllegalAccessException e) { + } catch (NoSuchFieldException e) { + } + throw new IOException(); + } + + // Needed by NativeJavaObject de-serializer + public static Object readAdapterObject(Scriptable self, + ObjectInputStream in) + throws IOException, ClassNotFoundException + { + ContextFactory factory; + Context cx = Context.getCurrentContext(); + if (cx != null) { + factory = cx.getFactory(); + } else { + factory = null; + } + + Class superClass = Class.forName((String)in.readObject()); + + String[] interfaceNames = (String[])in.readObject(); + Class[] interfaces = new Class[interfaceNames.length]; + + for (int i=0; i < interfaceNames.length; i++) + interfaces[i] = Class.forName(interfaceNames[i]); + + Scriptable delegee = (Scriptable)in.readObject(); + + Class adapterClass = getAdapterClass(self, superClass, interfaces, + delegee); + + Class[] ctorParms = { + ScriptRuntime.ContextFactoryClass, + ScriptRuntime.ScriptableClass, + ScriptRuntime.ScriptableClass + }; + Object[] ctorArgs = { factory, delegee, self }; + try { + return adapterClass.getConstructor(ctorParms).newInstance(ctorArgs); + } catch(InstantiationException e) { + } catch(IllegalAccessException e) { + } catch(InvocationTargetException e) { + } catch(NoSuchMethodException e) { + } + + throw new ClassNotFoundException("adapter"); + } + + private static ObjToIntMap getObjectFunctionNames(Scriptable obj) + { + Object[] ids = ScriptableObject.getPropertyIds(obj); + ObjToIntMap map = new ObjToIntMap(ids.length); + for (int i = 0; i != ids.length; ++i) { + if (!(ids[i] instanceof String)) + continue; + String id = (String) ids[i]; + Object value = ScriptableObject.getProperty(obj, id); + if (value instanceof Function) { + Function f = (Function)value; + int length = ScriptRuntime.toInt32( + ScriptableObject.getProperty(f, "length")); + if (length < 0) { + length = 0; + } + map.put(id, length); + } + } + return map; + } + + private static Class getAdapterClass(Scriptable scope, Class superClass, + Class[] interfaces, Scriptable obj) + { + ClassCache cache = ClassCache.get(scope); + Map<JavaAdapterSignature,Class<?>> generated + = cache.getInterfaceAdapterCacheMap(); + + ObjToIntMap names = getObjectFunctionNames(obj); + JavaAdapterSignature sig; + sig = new JavaAdapterSignature(superClass, interfaces, names); + Class<?> adapterClass = generated.get(sig); + if (adapterClass == null) { + String adapterName = "adapter" + + cache.newClassSerialNumber(); + byte[] code = createAdapterCode(names, adapterName, + superClass, interfaces, null); + + adapterClass = loadAdapterClass(adapterName, code); + if (cache.isCachingEnabled()) { + generated.put(sig, adapterClass); + } + } + return adapterClass; + } + + public static byte[] createAdapterCode(ObjToIntMap functionNames, + String adapterName, + Class superClass, + Class[] interfaces, + String scriptClassName) + { + ClassFileWriter cfw = new ClassFileWriter(adapterName, + superClass.getName(), + "<adapter>"); + cfw.addField("factory", "Lorg/mozilla/javascript/ContextFactory;", + (short) (ClassFileWriter.ACC_PUBLIC | + ClassFileWriter.ACC_FINAL)); + cfw.addField("delegee", "Lorg/mozilla/javascript/Scriptable;", + (short) (ClassFileWriter.ACC_PUBLIC | + ClassFileWriter.ACC_FINAL)); + cfw.addField("self", "Lorg/mozilla/javascript/Scriptable;", + (short) (ClassFileWriter.ACC_PUBLIC | + ClassFileWriter.ACC_FINAL)); + int interfacesCount = interfaces == null ? 0 : interfaces.length; + for (int i=0; i < interfacesCount; i++) { + if (interfaces[i] != null) + cfw.addInterface(interfaces[i].getName()); + } + + String superName = superClass.getName().replace('.', '/'); + generateCtor(cfw, adapterName, superName); + generateSerialCtor(cfw, adapterName, superName); + if (scriptClassName != null) + generateEmptyCtor(cfw, adapterName, superName, scriptClassName); + + ObjToIntMap generatedOverrides = new ObjToIntMap(); + ObjToIntMap generatedMethods = new ObjToIntMap(); + + // generate methods to satisfy all specified interfaces. + for (int i = 0; i < interfacesCount; i++) { + Method[] methods = interfaces[i].getMethods(); + for (int j = 0; j < methods.length; j++) { + Method method = methods[j]; + int mods = method.getModifiers(); + if (Modifier.isStatic(mods) || Modifier.isFinal(mods)) { + continue; + } + String methodName = method.getName(); + Class[] argTypes = method.getParameterTypes(); + if (!functionNames.has(methodName)) { + try { + superClass.getMethod(methodName, argTypes); + // The class we're extending implements this method and + // the JavaScript object doesn't have an override. See + // bug 61226. + continue; + } catch (NoSuchMethodException e) { + // Not implemented by superclass; fall through + } + } + // make sure to generate only one instance of a particular + // method/signature. + String methodSignature = getMethodSignature(method, argTypes); + String methodKey = methodName + methodSignature; + if (! generatedOverrides.has(methodKey)) { + generateMethod(cfw, adapterName, methodName, + argTypes, method.getReturnType()); + generatedOverrides.put(methodKey, 0); + generatedMethods.put(methodName, 0); + } + } + } + + // Now, go through the superclass's methods, checking for abstract + // methods or additional methods to override. + + // generate any additional overrides that the object might contain. + Method[] methods = getOverridableMethods(superClass); + for (int j = 0; j < methods.length; j++) { + Method method = methods[j]; + int mods = method.getModifiers(); + // if a method is marked abstract, must implement it or the + // resulting class won't be instantiable. otherwise, if the object + // has a property of the same name, then an override is intended. + boolean isAbstractMethod = Modifier.isAbstract(mods); + String methodName = method.getName(); + if (isAbstractMethod || functionNames.has(methodName)) { + // make sure to generate only one instance of a particular + // method/signature. + Class[] argTypes = method.getParameterTypes(); + String methodSignature = getMethodSignature(method, argTypes); + String methodKey = methodName + methodSignature; + if (! generatedOverrides.has(methodKey)) { + generateMethod(cfw, adapterName, methodName, + argTypes, method.getReturnType()); + generatedOverrides.put(methodKey, 0); + generatedMethods.put(methodName, 0); + + // if a method was overridden, generate a "super$method" + // which lets the delegate call the superclass' version. + if (!isAbstractMethod) { + generateSuper(cfw, adapterName, superName, + methodName, methodSignature, + argTypes, method.getReturnType()); + } + } + } + } + + // Generate Java methods for remaining properties that are not + // overrides. + ObjToIntMap.Iterator iter = new ObjToIntMap.Iterator(functionNames); + for (iter.start(); !iter.done(); iter.next()) { + String functionName = (String)iter.getKey(); + if (generatedMethods.has(functionName)) + continue; + int length = iter.getValue(); + Class[] parms = new Class[length]; + for (int k=0; k < length; k++) + parms[k] = ScriptRuntime.ObjectClass; + generateMethod(cfw, adapterName, functionName, parms, + ScriptRuntime.ObjectClass); + } + return cfw.toByteArray(); + } + + static Method[] getOverridableMethods(Class c) + { + ArrayList<Method> list = new ArrayList<Method>(); + HashSet<String> skip = new HashSet<String>(); + while (c != null) { + Method[] methods = c.getDeclaredMethods(); + for (int i = 0; i < methods.length; i++) { + String methodKey = methods[i].getName() + + getMethodSignature(methods[i], + methods[i].getParameterTypes()); + if (skip.contains(methodKey)) + continue; // skip this method + int mods = methods[i].getModifiers(); + if (Modifier.isStatic(mods)) + continue; + if (Modifier.isFinal(mods)) { + // Make sure we don't add a final method to the list + // of overridable methods. + skip.add(methodKey); + continue; + } + if (Modifier.isPublic(mods) || Modifier.isProtected(mods)) { + list.add(methods[i]); + skip.add(methodKey); + } + } + c = c.getSuperclass(); + } + return list.toArray(new Method[list.size()]); + } + + static Class loadAdapterClass(String className, byte[] classBytes) + { + Object staticDomain; + Class domainClass = SecurityController.getStaticSecurityDomainClass(); + if(domainClass == CodeSource.class || domainClass == ProtectionDomain.class) { + ProtectionDomain protectionDomain = JavaAdapter.class.getProtectionDomain(); + if(domainClass == CodeSource.class) { + staticDomain = protectionDomain == null ? null : protectionDomain.getCodeSource(); + } + else { + staticDomain = protectionDomain; + } + } + else { + staticDomain = null; + } + GeneratedClassLoader loader = SecurityController.createLoader(null, + staticDomain); + Class result = loader.defineClass(className, classBytes); + loader.linkClass(result); + return result; + } + + public static Function getFunction(Scriptable obj, String functionName) + { + Object x = ScriptableObject.getProperty(obj, functionName); + if (x == Scriptable.NOT_FOUND) { + // This method used to swallow the exception from calling + // an undefined method. People have come to depend on this + // somewhat dubious behavior. It allows people to avoid + // implementing listener methods that they don't care about, + // for instance. + return null; + } + if (!(x instanceof Function)) + throw ScriptRuntime.notFunctionError(x, functionName); + + return (Function)x; + } + + /** + * Utility method which dynamically binds a Context to the current thread, + * if none already exists. + */ + public static Object callMethod(ContextFactory factory, + final Scriptable thisObj, + final Function f, final Object[] args, + final long argsToWrap) + { + if (f == null) { + // See comments in getFunction + return Undefined.instance; + } + if (factory == null) { + factory = ContextFactory.getGlobal(); + } + + final Scriptable scope = f.getParentScope(); + if (argsToWrap == 0) { + return Context.call(factory, f, scope, thisObj, args); + } + + Context cx = Context.getCurrentContext(); + if (cx != null) { + return doCall(cx, scope, thisObj, f, args, argsToWrap); + } else { + return factory.call(new ContextAction() { + public Object run(Context cx) + { + return doCall(cx, scope, thisObj, f, args, argsToWrap); + } + }); + } + } + + private static Object doCall(Context cx, Scriptable scope, + Scriptable thisObj, Function f, + Object[] args, long argsToWrap) + { + // Wrap the rest of objects + for (int i = 0; i != args.length; ++i) { + if (0 != (argsToWrap & (1 << i))) { + Object arg = args[i]; + if (!(arg instanceof Scriptable)) { + args[i] = cx.getWrapFactory().wrap(cx, scope, arg, + null); + } + } + } + return f.call(cx, scope, thisObj, args); + } + + public static Scriptable runScript(final Script script) + { + return (Scriptable)Context.call(new ContextAction() { + public Object run(Context cx) + { + ScriptableObject global = ScriptRuntime.getGlobal(cx); + script.exec(cx, global); + return global; + } + }); + } + + private static void generateCtor(ClassFileWriter cfw, String adapterName, + String superName) + { + cfw.startMethod("<init>", + "(Lorg/mozilla/javascript/ContextFactory;" + +"Lorg/mozilla/javascript/Scriptable;)V", + ClassFileWriter.ACC_PUBLIC); + + // Invoke base class constructor + cfw.add(ByteCode.ALOAD_0); // this + cfw.addInvoke(ByteCode.INVOKESPECIAL, superName, "<init>", "()V"); + + // Save parameter in instance variable "factory" + cfw.add(ByteCode.ALOAD_0); // this + cfw.add(ByteCode.ALOAD_1); // first arg: ContextFactory instance + cfw.add(ByteCode.PUTFIELD, adapterName, "factory", + "Lorg/mozilla/javascript/ContextFactory;"); + + // Save parameter in instance variable "delegee" + cfw.add(ByteCode.ALOAD_0); // this + cfw.add(ByteCode.ALOAD_2); // second arg: Scriptable delegee + cfw.add(ByteCode.PUTFIELD, adapterName, "delegee", + "Lorg/mozilla/javascript/Scriptable;"); + + cfw.add(ByteCode.ALOAD_0); // this for the following PUTFIELD for self + // create a wrapper object to be used as "this" in method calls + cfw.add(ByteCode.ALOAD_2); // the Scriptable delegee + cfw.add(ByteCode.ALOAD_0); // this + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/JavaAdapter", + "createAdapterWrapper", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.add(ByteCode.PUTFIELD, adapterName, "self", + "Lorg/mozilla/javascript/Scriptable;"); + + cfw.add(ByteCode.RETURN); + cfw.stopMethod((short)3); // 3: this + factory + delegee + } + + private static void generateSerialCtor(ClassFileWriter cfw, + String adapterName, + String superName) + { + cfw.startMethod("<init>", + "(Lorg/mozilla/javascript/ContextFactory;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;" + +")V", + ClassFileWriter.ACC_PUBLIC); + + // Invoke base class constructor + cfw.add(ByteCode.ALOAD_0); // this + cfw.addInvoke(ByteCode.INVOKESPECIAL, superName, "<init>", "()V"); + + // Save parameter in instance variable "factory" + cfw.add(ByteCode.ALOAD_0); // this + cfw.add(ByteCode.ALOAD_1); // first arg: ContextFactory instance + cfw.add(ByteCode.PUTFIELD, adapterName, "factory", + "Lorg/mozilla/javascript/ContextFactory;"); + + // Save parameter in instance variable "delegee" + cfw.add(ByteCode.ALOAD_0); // this + cfw.add(ByteCode.ALOAD_2); // second arg: Scriptable delegee + cfw.add(ByteCode.PUTFIELD, adapterName, "delegee", + "Lorg/mozilla/javascript/Scriptable;"); + // save self + cfw.add(ByteCode.ALOAD_0); // this + cfw.add(ByteCode.ALOAD_3); // second arg: Scriptable self + cfw.add(ByteCode.PUTFIELD, adapterName, "self", + "Lorg/mozilla/javascript/Scriptable;"); + + cfw.add(ByteCode.RETURN); + cfw.stopMethod((short)4); // 4: this + factory + delegee + self + } + + private static void generateEmptyCtor(ClassFileWriter cfw, + String adapterName, + String superName, + String scriptClassName) + { + cfw.startMethod("<init>", "()V", ClassFileWriter.ACC_PUBLIC); + + // Invoke base class constructor + cfw.add(ByteCode.ALOAD_0); // this + cfw.addInvoke(ByteCode.INVOKESPECIAL, superName, "<init>", "()V"); + + // Set factory to null to use current global when necessary + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.ACONST_NULL); + cfw.add(ByteCode.PUTFIELD, adapterName, "factory", + "Lorg/mozilla/javascript/ContextFactory;"); + + // Load script class + cfw.add(ByteCode.NEW, scriptClassName); + cfw.add(ByteCode.DUP); + cfw.addInvoke(ByteCode.INVOKESPECIAL, scriptClassName, "<init>", "()V"); + + // Run script and save resulting scope + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/JavaAdapter", + "runScript", + "(Lorg/mozilla/javascript/Script;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.add(ByteCode.ASTORE_1); + + // Save the Scriptable in instance variable "delegee" + cfw.add(ByteCode.ALOAD_0); // this + cfw.add(ByteCode.ALOAD_1); // the Scriptable + cfw.add(ByteCode.PUTFIELD, adapterName, "delegee", + "Lorg/mozilla/javascript/Scriptable;"); + + cfw.add(ByteCode.ALOAD_0); // this for the following PUTFIELD for self + // create a wrapper object to be used as "this" in method calls + cfw.add(ByteCode.ALOAD_1); // the Scriptable + cfw.add(ByteCode.ALOAD_0); // this + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/JavaAdapter", + "createAdapterWrapper", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.add(ByteCode.PUTFIELD, adapterName, "self", + "Lorg/mozilla/javascript/Scriptable;"); + + cfw.add(ByteCode.RETURN); + cfw.stopMethod((short)2); // this + delegee + } + + /** + * Generates code to wrap Java arguments into Object[]. + * Non-primitive Java types are left as-is pending conversion + * in the helper method. Leaves the array object on the top of the stack. + */ + static void generatePushWrappedArgs(ClassFileWriter cfw, + Class[] argTypes, + int arrayLength) + { + // push arguments + cfw.addPush(arrayLength); + cfw.add(ByteCode.ANEWARRAY, "java/lang/Object"); + int paramOffset = 1; + for (int i = 0; i != argTypes.length; ++i) { + cfw.add(ByteCode.DUP); // duplicate array reference + cfw.addPush(i); + paramOffset += generateWrapArg(cfw, paramOffset, argTypes[i]); + cfw.add(ByteCode.AASTORE); + } + } + + /** + * Generates code to wrap Java argument into Object. + * Non-primitive Java types are left unconverted pending conversion + * in the helper method. Leaves the wrapper object on the top of the stack. + */ + private static int generateWrapArg(ClassFileWriter cfw, int paramOffset, + Class argType) + { + int size = 1; + if (!argType.isPrimitive()) { + cfw.add(ByteCode.ALOAD, paramOffset); + + } else if (argType == Boolean.TYPE) { + // wrap boolean values with java.lang.Boolean. + cfw.add(ByteCode.NEW, "java/lang/Boolean"); + cfw.add(ByteCode.DUP); + cfw.add(ByteCode.ILOAD, paramOffset); + cfw.addInvoke(ByteCode.INVOKESPECIAL, "java/lang/Boolean", + "<init>", "(Z)V"); + + } else if (argType == Character.TYPE) { + // Create a string of length 1 using the character parameter. + cfw.add(ByteCode.ILOAD, paramOffset); + cfw.addInvoke(ByteCode.INVOKESTATIC, "java/lang/String", + "valueOf", "(C)Ljava/lang/String;"); + + } else { + // convert all numeric values to java.lang.Double. + cfw.add(ByteCode.NEW, "java/lang/Double"); + cfw.add(ByteCode.DUP); + String typeName = argType.getName(); + switch (typeName.charAt(0)) { + case 'b': + case 's': + case 'i': + // load an int value, convert to double. + cfw.add(ByteCode.ILOAD, paramOffset); + cfw.add(ByteCode.I2D); + break; + case 'l': + // load a long, convert to double. + cfw.add(ByteCode.LLOAD, paramOffset); + cfw.add(ByteCode.L2D); + size = 2; + break; + case 'f': + // load a float, convert to double. + cfw.add(ByteCode.FLOAD, paramOffset); + cfw.add(ByteCode.F2D); + break; + case 'd': + cfw.add(ByteCode.DLOAD, paramOffset); + size = 2; + break; + } + cfw.addInvoke(ByteCode.INVOKESPECIAL, "java/lang/Double", + "<init>", "(D)V"); + } + return size; + } + + /** + * Generates code to convert a wrapped value type to a primitive type. + * Handles unwrapping java.lang.Boolean, and java.lang.Number types. + * Generates the appropriate RETURN bytecode. + */ + static void generateReturnResult(ClassFileWriter cfw, Class retType, + boolean callConvertResult) + { + // wrap boolean values with java.lang.Boolean, convert all other + // primitive values to java.lang.Double. + if (retType == Void.TYPE) { + cfw.add(ByteCode.POP); + cfw.add(ByteCode.RETURN); + + } else if (retType == Boolean.TYPE) { + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/Context", + "toBoolean", "(Ljava/lang/Object;)Z"); + cfw.add(ByteCode.IRETURN); + + } else if (retType == Character.TYPE) { + // characters are represented as strings in JavaScript. + // return the first character. + // first convert the value to a string if possible. + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/Context", + "toString", + "(Ljava/lang/Object;)Ljava/lang/String;"); + cfw.add(ByteCode.ICONST_0); + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, "java/lang/String", + "charAt", "(I)C"); + cfw.add(ByteCode.IRETURN); + + } else if (retType.isPrimitive()) { + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/Context", + "toNumber", "(Ljava/lang/Object;)D"); + String typeName = retType.getName(); + switch (typeName.charAt(0)) { + case 'b': + case 's': + case 'i': + cfw.add(ByteCode.D2I); + cfw.add(ByteCode.IRETURN); + break; + case 'l': + cfw.add(ByteCode.D2L); + cfw.add(ByteCode.LRETURN); + break; + case 'f': + cfw.add(ByteCode.D2F); + cfw.add(ByteCode.FRETURN); + break; + case 'd': + cfw.add(ByteCode.DRETURN); + break; + default: + throw new RuntimeException("Unexpected return type " + + retType.toString()); + } + + } else { + String retTypeStr = retType.getName(); + if (callConvertResult) { + cfw.addLoadConstant(retTypeStr); + cfw.addInvoke(ByteCode.INVOKESTATIC, + "java/lang/Class", + "forName", + "(Ljava/lang/String;)Ljava/lang/Class;"); + + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/JavaAdapter", + "convertResult", + "(Ljava/lang/Object;" + +"Ljava/lang/Class;" + +")Ljava/lang/Object;"); + } + // Now cast to return type + cfw.add(ByteCode.CHECKCAST, retTypeStr); + cfw.add(ByteCode.ARETURN); + } + } + + private static void generateMethod(ClassFileWriter cfw, String genName, + String methodName, Class[] parms, + Class returnType) + { + StringBuffer sb = new StringBuffer(); + int paramsEnd = appendMethodSignature(parms, returnType, sb); + String methodSignature = sb.toString(); + cfw.startMethod(methodName, methodSignature, + ClassFileWriter.ACC_PUBLIC); + + // Prepare stack to call method + + // push factory + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, genName, "factory", + "Lorg/mozilla/javascript/ContextFactory;"); + + // push self + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, genName, "self", + "Lorg/mozilla/javascript/Scriptable;"); + + // push function + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, genName, "delegee", + "Lorg/mozilla/javascript/Scriptable;"); + cfw.addPush(methodName); + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/JavaAdapter", + "getFunction", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +")Lorg/mozilla/javascript/Function;"); + + // push arguments + generatePushWrappedArgs(cfw, parms, parms.length); + + // push bits to indicate which parameters should be wrapped + if (parms.length > 64) { + // If it will be an issue, then passing a static boolean array + // can be an option, but for now using simple bitmask + throw Context.reportRuntimeError0( + "JavaAdapter can not subclass methods with more then" + +" 64 arguments."); + } + long convertionMask = 0; + for (int i = 0; i != parms.length; ++i) { + if (!parms[i].isPrimitive()) { + convertionMask |= (1 << i); + } + } + cfw.addPush(convertionMask); + + // go through utility method, which creates a Context to run the + // method in. + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/JavaAdapter", + "callMethod", + "(Lorg/mozilla/javascript/ContextFactory;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Function;" + +"[Ljava/lang/Object;" + +"J" + +")Ljava/lang/Object;"); + + generateReturnResult(cfw, returnType, true); + + cfw.stopMethod((short)paramsEnd); + } + + /** + * Generates code to push typed parameters onto the operand stack + * prior to a direct Java method call. + */ + private static int generatePushParam(ClassFileWriter cfw, int paramOffset, + Class paramType) + { + if (!paramType.isPrimitive()) { + cfw.addALoad(paramOffset); + return 1; + } + String typeName = paramType.getName(); + switch (typeName.charAt(0)) { + case 'z': + case 'b': + case 'c': + case 's': + case 'i': + // load an int value, convert to double. + cfw.addILoad(paramOffset); + return 1; + case 'l': + // load a long, convert to double. + cfw.addLLoad(paramOffset); + return 2; + case 'f': + // load a float, convert to double. + cfw.addFLoad(paramOffset); + return 1; + case 'd': + cfw.addDLoad(paramOffset); + return 2; + } + throw Kit.codeBug(); + } + + /** + * Generates code to return a Java type, after calling a Java method + * that returns the same type. + * Generates the appropriate RETURN bytecode. + */ + private static void generatePopResult(ClassFileWriter cfw, + Class retType) + { + if (retType.isPrimitive()) { + String typeName = retType.getName(); + switch (typeName.charAt(0)) { + case 'b': + case 'c': + case 's': + case 'i': + case 'z': + cfw.add(ByteCode.IRETURN); + break; + case 'l': + cfw.add(ByteCode.LRETURN); + break; + case 'f': + cfw.add(ByteCode.FRETURN); + break; + case 'd': + cfw.add(ByteCode.DRETURN); + break; + } + } else { + cfw.add(ByteCode.ARETURN); + } + } + + /** + * Generates a method called "super$methodName()" which can be called + * from JavaScript that is equivalent to calling "super.methodName()" + * from Java. Eventually, this may be supported directly in JavaScript. + */ + private static void generateSuper(ClassFileWriter cfw, + String genName, String superName, + String methodName, String methodSignature, + Class[] parms, Class returnType) + { + cfw.startMethod("super$" + methodName, methodSignature, + ClassFileWriter.ACC_PUBLIC); + + // push "this" + cfw.add(ByteCode.ALOAD, 0); + + // push the rest of the parameters. + int paramOffset = 1; + for (int i = 0; i < parms.length; i++) { + paramOffset += generatePushParam(cfw, paramOffset, parms[i]); + } + + // call the superclass implementation of the method. + cfw.addInvoke(ByteCode.INVOKESPECIAL, + superName, + methodName, + methodSignature); + + // now, handle the return type appropriately. + Class retType = returnType; + if (!retType.equals(Void.TYPE)) { + generatePopResult(cfw, retType); + } else { + cfw.add(ByteCode.RETURN); + } + cfw.stopMethod((short)(paramOffset + 1)); + } + + /** + * Returns a fully qualified method name concatenated with its signature. + */ + private static String getMethodSignature(Method method, Class[] argTypes) + { + StringBuffer sb = new StringBuffer(); + appendMethodSignature(argTypes, method.getReturnType(), sb); + return sb.toString(); + } + + static int appendMethodSignature(Class[] argTypes, + Class returnType, + StringBuffer sb) + { + sb.append('('); + int firstLocal = 1 + argTypes.length; // includes this. + for (int i = 0; i < argTypes.length; i++) { + Class type = argTypes[i]; + appendTypeString(sb, type); + if (type == Long.TYPE || type == Double.TYPE) { + // adjust for duble slot + ++firstLocal; + } + } + sb.append(')'); + appendTypeString(sb, returnType); + return firstLocal; + } + + private static StringBuffer appendTypeString(StringBuffer sb, Class type) + { + while (type.isArray()) { + sb.append('['); + type = type.getComponentType(); + } + if (type.isPrimitive()) { + char typeLetter; + if (type == Boolean.TYPE) { + typeLetter = 'Z'; + } else if (type == Long.TYPE) { + typeLetter = 'J'; + } else { + String typeName = type.getName(); + typeLetter = Character.toUpperCase(typeName.charAt(0)); + } + sb.append(typeLetter); + } else { + sb.append('L'); + sb.append(type.getName().replace('.', '/')); + sb.append(';'); + } + return sb; + } + + static int[] getArgsToConvert(Class[] argTypes) + { + int count = 0; + for (int i = 0; i != argTypes.length; ++i) { + if (!argTypes[i].isPrimitive()) + ++count; + } + if (count == 0) + return null; + int[] array = new int[count]; + count = 0; + for (int i = 0; i != argTypes.length; ++i) { + if (!argTypes[i].isPrimitive()) + array[count++] = i; + } + return array; + } + + private static final Object FTAG = new Object(); + private static final int Id_JavaAdapter = 1; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaMembers.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaMembers.java new file mode 100644 index 0000000..84ef2d4 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaMembers.java @@ -0,0 +1,935 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Cameron McCormack + * Frank Mitchell + * Mike Shaver + * Kurt Westerfeld + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.*; +import java.util.*; + +/** + * + * @author Mike Shaver + * @author Norris Boyd + * @see NativeJavaObject + * @see NativeJavaClass + */ +class JavaMembers +{ + JavaMembers(Scriptable scope, Class cl) + { + this(scope, cl, false); + } + + JavaMembers(Scriptable scope, Class cl, boolean includeProtected) + { + try { + Context cx = ContextFactory.getGlobal().enterContext(); + ClassShutter shutter = cx.getClassShutter(); + if (shutter != null && !shutter.visibleToScripts(cl.getName())) { + throw Context.reportRuntimeError1("msg.access.prohibited", + cl.getName()); + } + this.includePrivate = cx.hasFeature( + Context.FEATURE_ENHANCED_JAVA_ACCESS); + this.members = new Hashtable(23); + this.staticMembers = new Hashtable(7); + this.cl = cl; + reflect(scope, includeProtected); + } finally { + Context.exit(); + } + } + + boolean has(String name, boolean isStatic) + { + Hashtable ht = isStatic ? staticMembers : members; + Object obj = ht.get(name); + if (obj != null) { + return true; + } + return findExplicitFunction(name, isStatic) != null; + } + + Object get(Scriptable scope, String name, Object javaObject, + boolean isStatic) + { + Hashtable ht = isStatic ? staticMembers : members; + Object member = ht.get(name); + if (!isStatic && member == null) { + // Try to get static member from instance (LC3) + member = staticMembers.get(name); + } + if (member == null) { + member = this.getExplicitFunction(scope, name, + javaObject, isStatic); + if (member == null) + return Scriptable.NOT_FOUND; + } + if (member instanceof Scriptable) { + return member; + } + Context cx = Context.getContext(); + Object rval; + Class type; + try { + if (member instanceof BeanProperty) { + BeanProperty bp = (BeanProperty) member; + if (bp.getter == null) + return Scriptable.NOT_FOUND; + rval = bp.getter.invoke(javaObject, Context.emptyArgs); + type = bp.getter.method().getReturnType(); + } else { + Field field = (Field) member; + rval = field.get(isStatic ? null : javaObject); + type = field.getType(); + } + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + // Need to wrap the object before we return it. + scope = ScriptableObject.getTopLevelScope(scope); + return cx.getWrapFactory().wrap(cx, scope, rval, type); + } + + void put(Scriptable scope, String name, Object javaObject, + Object value, boolean isStatic) + { + Hashtable ht = isStatic ? staticMembers : members; + Object member = ht.get(name); + if (!isStatic && member == null) { + // Try to get static member from instance (LC3) + member = staticMembers.get(name); + } + if (member == null) + throw reportMemberNotFound(name); + if (member instanceof FieldAndMethods) { + FieldAndMethods fam = (FieldAndMethods) ht.get(name); + member = fam.field; + } + + // Is this a bean property "set"? + if (member instanceof BeanProperty) { + BeanProperty bp = (BeanProperty)member; + if (bp.setter == null) { + throw reportMemberNotFound(name); + } + // If there's only one setter or if the value is null, use the + // main setter. Otherwise, let the NativeJavaMethod decide which + // setter to use: + if (bp.setters == null || value == null) { + Class setType = bp.setter.argTypes[0]; + Object[] args = { Context.jsToJava(value, setType) }; + try { + bp.setter.invoke(javaObject, args); + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } else { + Object[] args = { value }; + bp.setters.call(Context.getContext(), + ScriptableObject.getTopLevelScope(scope), + scope, args); + } + } + else { + if (!(member instanceof Field)) { + String str = (member == null) ? "msg.java.internal.private" + : "msg.java.method.assign"; + throw Context.reportRuntimeError1(str, name); + } + Field field = (Field)member; + Object javaValue = Context.jsToJava(value, field.getType()); + try { + field.set(javaObject, javaValue); + } catch (IllegalAccessException accessEx) { + if ((field.getModifiers() & Modifier.FINAL) != 0) { + // treat Java final the same as JavaScript [[READONLY]] + return; + } + throw Context.throwAsScriptRuntimeEx(accessEx); + } catch (IllegalArgumentException argEx) { + throw Context.reportRuntimeError3( + "msg.java.internal.field.type", + value.getClass().getName(), field, + javaObject.getClass().getName()); + } + } + } + + Object[] getIds(boolean isStatic) + { + Hashtable ht = isStatic ? staticMembers : members; + int len = ht.size(); + Object[] result = new Object[len]; + Enumeration keys = ht.keys(); + for (int i=0; i < len; i++) + result[i] = keys.nextElement(); + return result; + } + + static String javaSignature(Class type) + { + if (!type.isArray()) { + return type.getName(); + } else { + int arrayDimension = 0; + do { + ++arrayDimension; + type = type.getComponentType(); + } while (type.isArray()); + String name = type.getName(); + String suffix = "[]"; + if (arrayDimension == 1) { + return name.concat(suffix); + } else { + int length = name.length() + arrayDimension * suffix.length(); + StringBuffer sb = new StringBuffer(length); + sb.append(name); + while (arrayDimension != 0) { + --arrayDimension; + sb.append(suffix); + } + return sb.toString(); + } + } + } + + static String liveConnectSignature(Class[] argTypes) + { + int N = argTypes.length; + if (N == 0) { return "()"; } + StringBuffer sb = new StringBuffer(); + sb.append('('); + for (int i = 0; i != N; ++i) { + if (i != 0) { + sb.append(','); + } + sb.append(javaSignature(argTypes[i])); + } + sb.append(')'); + return sb.toString(); + } + + private MemberBox findExplicitFunction(String name, boolean isStatic) + { + int sigStart = name.indexOf('('); + if (sigStart < 0) { return null; } + + Hashtable ht = isStatic ? staticMembers : members; + MemberBox[] methodsOrCtors = null; + boolean isCtor = (isStatic && sigStart == 0); + + if (isCtor) { + // Explicit request for an overloaded constructor + methodsOrCtors = ctors; + } else { + // Explicit request for an overloaded method + String trueName = name.substring(0,sigStart); + Object obj = ht.get(trueName); + if (!isStatic && obj == null) { + // Try to get static member from instance (LC3) + obj = staticMembers.get(trueName); + } + if (obj instanceof NativeJavaMethod) { + NativeJavaMethod njm = (NativeJavaMethod)obj; + methodsOrCtors = njm.methods; + } + } + + if (methodsOrCtors != null) { + for (int i = 0; i < methodsOrCtors.length; i++) { + Class[] type = methodsOrCtors[i].argTypes; + String sig = liveConnectSignature(type); + if (sigStart + sig.length() == name.length() + && name.regionMatches(sigStart, sig, 0, sig.length())) + { + return methodsOrCtors[i]; + } + } + } + + return null; + } + + private Object getExplicitFunction(Scriptable scope, String name, + Object javaObject, boolean isStatic) + { + Hashtable ht = isStatic ? staticMembers : members; + Object member = null; + MemberBox methodOrCtor = findExplicitFunction(name, isStatic); + + if (methodOrCtor != null) { + Scriptable prototype = + ScriptableObject.getFunctionPrototype(scope); + + if (methodOrCtor.isCtor()) { + NativeJavaConstructor fun = + new NativeJavaConstructor(methodOrCtor); + fun.setPrototype(prototype); + member = fun; + ht.put(name, fun); + } else { + String trueName = methodOrCtor.getName(); + member = ht.get(trueName); + + if (member instanceof NativeJavaMethod && + ((NativeJavaMethod)member).methods.length > 1 ) { + NativeJavaMethod fun = + new NativeJavaMethod(methodOrCtor, name); + fun.setPrototype(prototype); + ht.put(name, fun); + member = fun; + } + } + } + + return member; + } + + /** + * Retrieves mapping of methods to accessible methods for a class. + * In case the class is not public, retrieves methods with same + * signature as its public methods from public superclasses and + * interfaces (if they exist). Basically upcasts every method to the + * nearest accessible method. + */ + private static Method[] discoverAccessibleMethods(Class clazz, + boolean includeProtected, + boolean includePrivate) + { + Map map = new HashMap(); + discoverAccessibleMethods(clazz, map, includeProtected, includePrivate); + return (Method[])map.values().toArray(new Method[map.size()]); + } + + private static void discoverAccessibleMethods(Class clazz, Map map, + boolean includeProtected, + boolean includePrivate) + { + if (Modifier.isPublic(clazz.getModifiers()) || includePrivate) { + try { + if (includeProtected || includePrivate) { + while (clazz != null) { + try { + Method[] methods = clazz.getDeclaredMethods(); + for (int i = 0; i < methods.length; i++) { + Method method = methods[i]; + int mods = method.getModifiers(); + + if (Modifier.isPublic(mods) || + Modifier.isProtected(mods) || + includePrivate) + { + if (includePrivate) + method.setAccessible(true); + map.put(new MethodSignature(method), method); + } + } + clazz = clazz.getSuperclass(); + } catch (SecurityException e) { + // Some security settings (i.e., applets) disallow + // access to Class.getDeclaredMethods. Fall back to + // Class.getMethods. + Method[] methods = clazz.getMethods(); + for (int i = 0; i < methods.length; i++) { + Method method = methods[i]; + MethodSignature sig + = new MethodSignature(method); + if (map.get(sig) == null) + map.put(sig, method); + } + break; // getMethods gets superclass methods, no + // need to loop any more + } + } + } else { + Method[] methods = clazz.getMethods(); + for (int i = 0; i < methods.length; i++) { + Method method = methods[i]; + MethodSignature sig = new MethodSignature(method); + map.put(sig, method); + } + } + return; + } catch (SecurityException e) { + Context.reportWarning( + "Could not discover accessible methods of class " + + clazz.getName() + " due to lack of privileges, " + + "attemping superclasses/interfaces."); + // Fall through and attempt to discover superclass/interface + // methods + } + } + + Class[] interfaces = clazz.getInterfaces(); + for (int i = 0; i < interfaces.length; i++) { + discoverAccessibleMethods(interfaces[i], map, includeProtected, + includePrivate); + } + Class superclass = clazz.getSuperclass(); + if (superclass != null) { + discoverAccessibleMethods(superclass, map, includeProtected, + includePrivate); + } + } + + private static final class MethodSignature + { + private final String name; + private final Class[] args; + + private MethodSignature(String name, Class[] args) + { + this.name = name; + this.args = args; + } + + MethodSignature(Method method) + { + this(method.getName(), method.getParameterTypes()); + } + + public boolean equals(Object o) + { + if(o instanceof MethodSignature) + { + MethodSignature ms = (MethodSignature)o; + return ms.name.equals(name) && Arrays.equals(args, ms.args); + } + return false; + } + + public int hashCode() + { + return name.hashCode() ^ args.length; + } + } + + private void reflect(Scriptable scope, boolean includeProtected) + { + // We reflect methods first, because we want overloaded field/method + // names to be allocated to the NativeJavaMethod before the field + // gets in the way. + + Method[] methods = discoverAccessibleMethods(cl, includeProtected, + includePrivate); + for (int i = 0; i < methods.length; i++) { + Method method = methods[i]; + int mods = method.getModifiers(); + boolean isStatic = Modifier.isStatic(mods); + Hashtable ht = isStatic ? staticMembers : members; + String name = method.getName(); + Object value = ht.get(name); + if (value == null) { + ht.put(name, method); + } else { + ObjArray overloadedMethods; + if (value instanceof ObjArray) { + overloadedMethods = (ObjArray)value; + } else { + if (!(value instanceof Method)) Kit.codeBug(); + // value should be instance of Method as at this stage + // staticMembers and members can only contain methods + overloadedMethods = new ObjArray(); + overloadedMethods.add(value); + ht.put(name, overloadedMethods); + } + overloadedMethods.add(method); + } + } + + // replace Method instances by wrapped NativeJavaMethod objects + // first in staticMembers and then in members + for (int tableCursor = 0; tableCursor != 2; ++tableCursor) { + boolean isStatic = (tableCursor == 0); + Hashtable ht = (isStatic) ? staticMembers : members; + Enumeration e = ht.keys(); + while (e.hasMoreElements()) { + String name = (String)e.nextElement(); + MemberBox[] methodBoxes; + Object value = ht.get(name); + if (value instanceof Method) { + methodBoxes = new MemberBox[1]; + methodBoxes[0] = new MemberBox((Method)value); + } else { + ObjArray overloadedMethods = (ObjArray)value; + int N = overloadedMethods.size(); + if (N < 2) Kit.codeBug(); + methodBoxes = new MemberBox[N]; + for (int i = 0; i != N; ++i) { + Method method = (Method)overloadedMethods.get(i); + methodBoxes[i] = new MemberBox(method); + } + } + NativeJavaMethod fun = new NativeJavaMethod(methodBoxes); + if (scope != null) { + ScriptRuntime.setFunctionProtoAndParent(fun, scope); + } + ht.put(name, fun); + } + } + + // Reflect fields. + Field[] fields = getAccessibleFields(); + for (int i = 0; i < fields.length; i++) { + Field field = fields[i]; + String name = field.getName(); + int mods = field.getModifiers(); + if (!includePrivate && !Modifier.isPublic(mods)) { + continue; + } + try { + boolean isStatic = Modifier.isStatic(mods); + Hashtable ht = isStatic ? staticMembers : members; + Object member = ht.get(name); + if (member == null) { + ht.put(name, field); + } else if (member instanceof NativeJavaMethod) { + NativeJavaMethod method = (NativeJavaMethod) member; + FieldAndMethods fam + = new FieldAndMethods(scope, method.methods, field); + Hashtable fmht = isStatic ? staticFieldAndMethods + : fieldAndMethods; + if (fmht == null) { + fmht = new Hashtable(4); + if (isStatic) { + staticFieldAndMethods = fmht; + } else { + fieldAndMethods = fmht; + } + } + fmht.put(name, fam); + ht.put(name, fam); + } else if (member instanceof Field) { + Field oldField = (Field) member; + // If this newly reflected field shadows an inherited field, + // then replace it. Otherwise, since access to the field + // would be ambiguous from Java, no field should be + // reflected. + // For now, the first field found wins, unless another field + // explicitly shadows it. + if (oldField.getDeclaringClass(). + isAssignableFrom(field.getDeclaringClass())) + { + ht.put(name, field); + } + } else { + // "unknown member type" + Kit.codeBug(); + } + } catch (SecurityException e) { + // skip this field + Context.reportWarning("Could not access field " + + name + " of class " + cl.getName() + + " due to lack of privileges."); + } + } + + // Create bean propeties from corresponding get/set methods first for + // static members and then for instance members + for (int tableCursor = 0; tableCursor != 2; ++tableCursor) { + boolean isStatic = (tableCursor == 0); + Hashtable ht = (isStatic) ? staticMembers : members; + + Hashtable toAdd = new Hashtable(); + + // Now, For each member, make "bean" properties. + for (Enumeration e = ht.keys(); e.hasMoreElements(); ) { + + // Is this a getter? + String name = (String) e.nextElement(); + boolean memberIsGetMethod = name.startsWith("get"); + boolean memberIsSetMethod = name.startsWith("set"); + boolean memberIsIsMethod = name.startsWith("is"); + if (memberIsGetMethod || memberIsIsMethod + || memberIsSetMethod) { + // Double check name component. + String nameComponent + = name.substring(memberIsIsMethod ? 2 : 3); + if (nameComponent.length() == 0) + continue; + + // Make the bean property name. + String beanPropertyName = nameComponent; + char ch0 = nameComponent.charAt(0); + if (Character.isUpperCase(ch0)) { + if (nameComponent.length() == 1) { + beanPropertyName = nameComponent.toLowerCase(); + } else { + char ch1 = nameComponent.charAt(1); + if (!Character.isUpperCase(ch1)) { + beanPropertyName = Character.toLowerCase(ch0) + +nameComponent.substring(1); + } + } + } + + // If we already have a member by this name, don't do this + // property. + if (ht.containsKey(beanPropertyName) + || toAdd.containsKey(beanPropertyName)) { + continue; + } + + // Find the getter method, or if there is none, the is- + // method. + MemberBox getter = null; + getter = findGetter(isStatic, ht, "get", nameComponent); + // If there was no valid getter, check for an is- method. + if (getter == null) { + getter = findGetter(isStatic, ht, "is", nameComponent); + } + + // setter + MemberBox setter = null; + NativeJavaMethod setters = null; + String setterName = "set".concat(nameComponent); + + if (ht.containsKey(setterName)) { + // Is this value a method? + Object member = ht.get(setterName); + if (member instanceof NativeJavaMethod) { + NativeJavaMethod njmSet = (NativeJavaMethod)member; + if (getter != null) { + // We have a getter. Now, do we have a matching + // setter? + Class type = getter.method().getReturnType(); + setter = extractSetMethod(type, njmSet.methods, + isStatic); + } else { + // No getter, find any set method + setter = extractSetMethod(njmSet.methods, + isStatic); + } + if (njmSet.methods.length > 1) { + setters = njmSet; + } + } + } + // Make the property. + BeanProperty bp = new BeanProperty(getter, setter, + setters); + toAdd.put(beanPropertyName, bp); + } + } + + // Add the new bean properties. + for (Enumeration e = toAdd.keys(); e.hasMoreElements();) { + Object key = e.nextElement(); + Object value = toAdd.get(key); + ht.put(key, value); + } + } + + // Reflect constructors + Constructor[] constructors = getAccessibleConstructors(); + ctors = new MemberBox[constructors.length]; + for (int i = 0; i != constructors.length; ++i) { + ctors[i] = new MemberBox(constructors[i]); + } + } + + private Constructor[] getAccessibleConstructors() + { + // The JVM currently doesn't allow changing access on java.lang.Class + // constructors, so don't try + if (includePrivate && cl != ScriptRuntime.ClassClass) { + try { + Constructor[] cons = cl.getDeclaredConstructors(); + Constructor.setAccessible(cons, true); + + return cons; + } catch (SecurityException e) { + // Fall through to !includePrivate case + Context.reportWarning("Could not access constructor " + + " of class " + cl.getName() + + " due to lack of privileges."); + } + } + return cl.getConstructors(); + } + + private Field[] getAccessibleFields() { + if (includePrivate) { + try { + ArrayList fieldsList = new ArrayList(); + Class currentClass = cl; + + while (currentClass != null) { + // get all declared fields in this class, make them + // accessible, and save + Field[] declared = currentClass.getDeclaredFields(); + for (int i = 0; i < declared.length; i++) { + declared[i].setAccessible(true); + fieldsList.add(declared[i]); + } + // walk up superclass chain. no need to deal specially with + // interfaces, since they can't have fields + currentClass = currentClass.getSuperclass(); + } + + return (Field[]) fieldsList.toArray( + new Field[fieldsList.size()]); + } catch (SecurityException e) { + // fall through to !includePrivate case + } + } + return cl.getFields(); + } + + private MemberBox findGetter(boolean isStatic, Hashtable ht, String prefix, + String propertyName) + { + String getterName = prefix.concat(propertyName); + if (ht.containsKey(getterName)) { + // Check that the getter is a method. + Object member = ht.get(getterName); + if (member instanceof NativeJavaMethod) { + NativeJavaMethod njmGet = (NativeJavaMethod) member; + return extractGetMethod(njmGet.methods, isStatic); + } + } + return null; + } + + private static MemberBox extractGetMethod(MemberBox[] methods, + boolean isStatic) + { + // Inspect the list of all MemberBox for the only one having no + // parameters + for (int methodIdx = 0; methodIdx < methods.length; methodIdx++) { + MemberBox method = methods[methodIdx]; + // Does getter method have an empty parameter list with a return + // value (eg. a getSomething() or isSomething())? + if (method.argTypes.length == 0 + && (!isStatic || method.isStatic())) + { + Class type = method.method().getReturnType(); + if (type != Void.TYPE) { + return method; + } + break; + } + } + return null; + } + + private static MemberBox extractSetMethod(Class type, MemberBox[] methods, + boolean isStatic) + { + // + // Note: it may be preferable to allow NativeJavaMethod.findFunction() + // to find the appropriate setter; unfortunately, it requires an + // instance of the target arg to determine that. + // + + // Make two passes: one to find a method with direct type assignment, + // and one to find a widening conversion. + for (int pass = 1; pass <= 2; ++pass) { + for (int i = 0; i < methods.length; ++i) { + MemberBox method = methods[i]; + if (!isStatic || method.isStatic()) { + Class[] params = method.argTypes; + if (params.length == 1) { + if (pass == 1) { + if (params[0] == type) { + return method; + } + } else { + if (pass != 2) Kit.codeBug(); + if (params[0].isAssignableFrom(type)) { + return method; + } + } + } + } + } + } + return null; + } + + private static MemberBox extractSetMethod(MemberBox[] methods, + boolean isStatic) + { + + for (int i = 0; i < methods.length; ++i) { + MemberBox method = methods[i]; + if (!isStatic || method.isStatic()) { + if (method.method().getReturnType() == Void.TYPE) { + if (method.argTypes.length == 1) { + return method; + } + } + } + } + return null; + } + + Hashtable getFieldAndMethodsObjects(Scriptable scope, Object javaObject, + boolean isStatic) + { + Hashtable ht = isStatic ? staticFieldAndMethods : fieldAndMethods; + if (ht == null) + return null; + int len = ht.size(); + Hashtable result = new Hashtable(len); + Enumeration e = ht.elements(); + while (len-- > 0) { + FieldAndMethods fam = (FieldAndMethods) e.nextElement(); + FieldAndMethods famNew = new FieldAndMethods(scope, fam.methods, + fam.field); + famNew.javaObject = javaObject; + result.put(fam.field.getName(), famNew); + } + return result; + } + + static JavaMembers lookupClass(Scriptable scope, Class dynamicType, + Class staticType, boolean includeProtected) + { + JavaMembers members; + scope = ScriptableObject.getTopLevelScope(scope); + ClassCache cache = ClassCache.get(scope); + Map<Class<?>,JavaMembers> ct = cache.getClassCacheMap(); + + Class cl = dynamicType; + for (;;) { + members = ct.get(cl); + if (members != null) { + return members; + } + try { + members = new JavaMembers(scope, cl, includeProtected); + break; + } catch (SecurityException e) { + // Reflection may fail for objects that are in a restricted + // access package (e.g. sun.*). If we get a security + // exception, try again with the static type if it is interface. + // Otherwise, try superclass + if (staticType != null && staticType.isInterface()) { + cl = staticType; + staticType = null; // try staticType only once + } else { + Class parent = cl.getSuperclass(); + if (parent == null) { + if (cl.isInterface()) { + // last resort after failed staticType interface + parent = ScriptRuntime.ObjectClass; + } else { + throw e; + } + } + cl = parent; + } + } + } + + if (cache.isCachingEnabled()) + ct.put(cl, members); + return members; + } + + RuntimeException reportMemberNotFound(String memberName) + { + return Context.reportRuntimeError2( + "msg.java.member.not.found", cl.getName(), memberName); + } + + private Class cl; + private Hashtable members; + private Hashtable fieldAndMethods; + private Hashtable staticMembers; + private Hashtable staticFieldAndMethods; + MemberBox[] ctors; + private boolean includePrivate; +} + +class BeanProperty +{ + BeanProperty(MemberBox getter, MemberBox setter, NativeJavaMethod setters) + { + this.getter = getter; + this.setter = setter; + this.setters = setters; + } + + MemberBox getter; + MemberBox setter; + NativeJavaMethod setters; +} + +class FieldAndMethods extends NativeJavaMethod +{ + static final long serialVersionUID = -9222428244284796755L; + + FieldAndMethods(Scriptable scope, MemberBox[] methods, Field field) + { + super(methods); + this.field = field; + setParentScope(scope); + setPrototype(ScriptableObject.getFunctionPrototype(scope)); + } + + public Object getDefaultValue(Class hint) + { + if (hint == ScriptRuntime.FunctionClass) + return this; + Object rval; + Class type; + try { + rval = field.get(javaObject); + type = field.getType(); + } catch (IllegalAccessException accEx) { + throw Context.reportRuntimeError1( + "msg.java.internal.private", field.getName()); + } + Context cx = Context.getContext(); + rval = cx.getWrapFactory().wrap(cx, this, rval, type); + if (rval instanceof Scriptable) { + rval = ((Scriptable) rval).getDefaultValue(hint); + } + return rval; + } + + Field field; + Object javaObject; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaScriptException.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaScriptException.java new file mode 100644 index 0000000..11ebedf --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/JavaScriptException.java @@ -0,0 +1,117 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Bojan Cekrlic + * Hannes Wallnoefer + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Java reflection of JavaScript exceptions. + * Instances of this class are thrown by the JavaScript 'throw' keyword. + * + * @author Mike McCabe + */ +public class JavaScriptException extends RhinoException +{ + static final long serialVersionUID = -7666130513694669293L; + + /** + * @deprecated + * Use {@link WrappedException#WrappedException(Throwable)} to report + * exceptions in Java code. + */ + public JavaScriptException(Object value) + { + this(value, "", 0); + } + + /** + * Create a JavaScript exception wrapping the given JavaScript value + * + * @param value the JavaScript value thrown. + */ + public JavaScriptException(Object value, String sourceName, int lineNumber) + { + recordErrorOrigin(sourceName, lineNumber, null, 0); + this.value = value; + } + + public String details() + { + try { + return ScriptRuntime.toString(value); + } catch (RuntimeException rte) { + // ScriptRuntime.toString may throw a RuntimeException + if (value == null) { + return "null"; + } else if (value instanceof Scriptable) { + return ScriptRuntime.defaultObjectToString((Scriptable)value); + } else { + return value.toString(); + } + } + } + + /** + * @return the value wrapped by this exception + */ + public Object getValue() + { + return value; + } + + /** + * @deprecated Use {@link RhinoException#sourceName()} from the super class. + */ + public String getSourceName() + { + return sourceName(); + } + + /** + * @deprecated Use {@link RhinoException#lineNumber()} from the super class. + */ + public int getLineNumber() + { + return lineNumber(); + } + + private Object value; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Kit.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Kit.java new file mode 100644 index 0000000..f7b4cad --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Kit.java @@ -0,0 +1,486 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; +import java.lang.reflect.Method; +import java.util.Hashtable; + +/** + * Collection of utilities + */ + +public class Kit +{ + /** + * Reflection of Throwable.initCause(Throwable) from JDK 1.4 + * or nul if it is not available. + */ + private static Method Throwable_initCause = null; + + static { + // Are we running on a JDK 1.4 or later system? + try { + Class ThrowableClass = Kit.classOrNull("java.lang.Throwable"); + Class[] signature = { ThrowableClass }; + Throwable_initCause + = ThrowableClass.getMethod("initCause", signature); + } catch (Exception ex) { + // Assume any exceptions means the method does not exist. + } + } + + public static Class classOrNull(String className) + { + try { + return Class.forName(className); + } catch (ClassNotFoundException ex) { + } catch (SecurityException ex) { + } catch (LinkageError ex) { + } catch (IllegalArgumentException e) { + // Can be thrown if name has characters that a class name + // can not contain + } + return null; + } + + public static Class classOrNull(ClassLoader loader, String className) + { + try { + return loader.loadClass(className); + } catch (ClassNotFoundException ex) { + } catch (SecurityException ex) { + } catch (LinkageError ex) { + } catch (IllegalArgumentException e) { + // Can be thrown if name has characters that a class name + // can not contain + } + return null; + } + + static Object newInstanceOrNull(Class cl) + { + try { + return cl.newInstance(); + } catch (SecurityException x) { + } catch (LinkageError ex) { + } catch (InstantiationException x) { + } catch (IllegalAccessException x) { + } + return null; + } + + /** + * Check that testClass is accesible from the given loader. + */ + static boolean testIfCanLoadRhinoClasses(ClassLoader loader) + { + Class testClass = ScriptRuntime.ContextFactoryClass; + Class x = Kit.classOrNull(loader, testClass.getName()); + if (x != testClass) { + // The check covers the case when x == null => + // loader does not know about testClass or the case + // when x != null && x != testClass => + // loader loads a class unrelated to testClass + return false; + } + return true; + } + + /** + * If initCause methods exists in Throwable, call + * <tt>ex.initCause(cause)</tt> or otherwise do nothing. + * @return The <tt>ex</tt> argument. + */ + public static RuntimeException initCause(RuntimeException ex, + Throwable cause) + { + if (Throwable_initCause != null) { + Object[] args = { cause }; + try { + Throwable_initCause.invoke(ex, args); + } catch (Exception e) { + // Ignore any exceptions + } + } + return ex; + } + + /** + * Split string into array of strings using semicolon as string terminator + * (; after the last string is required). + */ + public static String[] semicolonSplit(String s) + { + String[] array = null; + for (;;) { + // loop 2 times: first to count semicolons and then to fill array + int count = 0; + int cursor = 0; + for (;;) { + int next = s.indexOf(';', cursor); + if (next < 0) { + break; + } + if (array != null) { + array[count] = s.substring(cursor, next); + } + ++count; + cursor = next + 1; + } + // after the last semicolon + if (array == null) { + // array size counting state: + // check for required terminating ';' + if (cursor != s.length()) + throw new IllegalArgumentException(); + array = new String[count]; + } else { + // array filling state: stop the loop + break; + } + } + return array; + } + + /** + * If character <tt>c</tt> is a hexadecimal digit, return + * <tt>accumulator</tt> * 16 plus corresponding + * number. Otherise return -1. + */ + public static int xDigitToInt(int c, int accumulator) + { + check: { + // Use 0..9 < A..Z < a..z + if (c <= '9') { + c -= '0'; + if (0 <= c) { break check; } + } else if (c <= 'F') { + if ('A' <= c) { + c -= ('A' - 10); + break check; + } + } else if (c <= 'f') { + if ('a' <= c) { + c -= ('a' - 10); + break check; + } + } + return -1; + } + return (accumulator << 4) | c; + } + + /** + * Add <i>listener</i> to <i>bag</i> of listeners. + * The function does not modify <i>bag</i> and return a new collection + * containing <i>listener</i> and all listeners from <i>bag</i>. + * Bag without listeners always represented as the null value. + * <p> + * Usage example: + * <pre> + * private volatile Object changeListeners; + * + * public void addMyListener(PropertyChangeListener l) + * { + * synchronized (this) { + * changeListeners = Kit.addListener(changeListeners, l); + * } + * } + * + * public void removeTextListener(PropertyChangeListener l) + * { + * synchronized (this) { + * changeListeners = Kit.removeListener(changeListeners, l); + * } + * } + * + * public void fireChangeEvent(Object oldValue, Object newValue) + * { + * // Get immune local copy + * Object listeners = changeListeners; + * if (listeners != null) { + * PropertyChangeEvent e = new PropertyChangeEvent( + * this, "someProperty" oldValue, newValue); + * for (int i = 0; ; ++i) { + * Object l = Kit.getListener(listeners, i); + * if (l == null) + * break; + * ((PropertyChangeListener)l).propertyChange(e); + * } + * } + * } + * </pre> + * + * @param listener Listener to add to <i>bag</i> + * @param bag Current collection of listeners. + * @return A new bag containing all listeners from <i>bag</i> and + * <i>listener</i>. + * @see #removeListener(Object bag, Object listener) + * @see #getListener(Object bag, int index) + */ + public static Object addListener(Object bag, Object listener) + { + if (listener == null) throw new IllegalArgumentException(); + if (listener instanceof Object[]) throw new IllegalArgumentException(); + + if (bag == null) { + bag = listener; + } else if (!(bag instanceof Object[])) { + bag = new Object[] { bag, listener }; + } else { + Object[] array = (Object[])bag; + int L = array.length; + // bag has at least 2 elements if it is array + if (L < 2) throw new IllegalArgumentException(); + Object[] tmp = new Object[L + 1]; + System.arraycopy(array, 0, tmp, 0, L); + tmp[L] = listener; + bag = tmp; + } + + return bag; + } + + /** + * Remove <i>listener</i> from <i>bag</i> of listeners. + * The function does not modify <i>bag</i> and return a new collection + * containing all listeners from <i>bag</i> except <i>listener</i>. + * If <i>bag</i> does not contain <i>listener</i>, the function returns + * <i>bag</i>. + * <p> + * For usage example, see {@link #addListener(Object bag, Object listener)}. + * + * @param listener Listener to remove from <i>bag</i> + * @param bag Current collection of listeners. + * @return A new bag containing all listeners from <i>bag</i> except + * <i>listener</i>. + * @see #addListener(Object bag, Object listener) + * @see #getListener(Object bag, int index) + */ + public static Object removeListener(Object bag, Object listener) + { + if (listener == null) throw new IllegalArgumentException(); + if (listener instanceof Object[]) throw new IllegalArgumentException(); + + if (bag == listener) { + bag = null; + } else if (bag instanceof Object[]) { + Object[] array = (Object[])bag; + int L = array.length; + // bag has at least 2 elements if it is array + if (L < 2) throw new IllegalArgumentException(); + if (L == 2) { + if (array[1] == listener) { + bag = array[0]; + } else if (array[0] == listener) { + bag = array[1]; + } + } else { + int i = L; + do { + --i; + if (array[i] == listener) { + Object[] tmp = new Object[L - 1]; + System.arraycopy(array, 0, tmp, 0, i); + System.arraycopy(array, i + 1, tmp, i, L - (i + 1)); + bag = tmp; + break; + } + } while (i != 0); + } + } + + return bag; + } + + /** + * Get listener at <i>index</i> position in <i>bag</i> or null if + * <i>index</i> equals to number of listeners in <i>bag</i>. + * <p> + * For usage example, see {@link #addListener(Object bag, Object listener)}. + * + * @param bag Current collection of listeners. + * @param index Index of the listener to access. + * @return Listener at the given index or null. + * @see #addListener(Object bag, Object listener) + * @see #removeListener(Object bag, Object listener) + */ + public static Object getListener(Object bag, int index) + { + if (index == 0) { + if (bag == null) + return null; + if (!(bag instanceof Object[])) + return bag; + Object[] array = (Object[])bag; + // bag has at least 2 elements if it is array + if (array.length < 2) throw new IllegalArgumentException(); + return array[0]; + } else if (index == 1) { + if (!(bag instanceof Object[])) { + if (bag == null) throw new IllegalArgumentException(); + return null; + } + Object[] array = (Object[])bag; + // the array access will check for index on its own + return array[1]; + } else { + // bag has to array + Object[] array = (Object[])bag; + int L = array.length; + if (L < 2) throw new IllegalArgumentException(); + if (index == L) + return null; + return array[index]; + } + } + + static Object initHash(Hashtable h, Object key, Object initialValue) + { + synchronized (h) { + Object current = h.get(key); + if (current == null) { + h.put(key, initialValue); + } else { + initialValue = current; + } + } + return initialValue; + } + + private final static class ComplexKey + { + private Object key1; + private Object key2; + private int hash; + + ComplexKey(Object key1, Object key2) + { + this.key1 = key1; + this.key2 = key2; + } + + public boolean equals(Object anotherObj) + { + if (!(anotherObj instanceof ComplexKey)) + return false; + ComplexKey another = (ComplexKey)anotherObj; + return key1.equals(another.key1) && key2.equals(another.key2); + } + + public int hashCode() + { + if (hash == 0) { + hash = key1.hashCode() ^ key2.hashCode(); + } + return hash; + } + } + + public static Object makeHashKeyFromPair(Object key1, Object key2) + { + if (key1 == null) throw new IllegalArgumentException(); + if (key2 == null) throw new IllegalArgumentException(); + return new ComplexKey(key1, key2); + } + + public static String readReader(Reader r) + throws IOException + { + char[] buffer = new char[512]; + int cursor = 0; + for (;;) { + int n = r.read(buffer, cursor, buffer.length - cursor); + if (n < 0) { break; } + cursor += n; + if (cursor == buffer.length) { + char[] tmp = new char[buffer.length * 2]; + System.arraycopy(buffer, 0, tmp, 0, cursor); + buffer = tmp; + } + } + return new String(buffer, 0, cursor); + } + + public static byte[] readStream(InputStream is, int initialBufferCapacity) + throws IOException + { + if (initialBufferCapacity <= 0) { + throw new IllegalArgumentException( + "Bad initialBufferCapacity: "+initialBufferCapacity); + } + byte[] buffer = new byte[initialBufferCapacity]; + int cursor = 0; + for (;;) { + int n = is.read(buffer, cursor, buffer.length - cursor); + if (n < 0) { break; } + cursor += n; + if (cursor == buffer.length) { + byte[] tmp = new byte[buffer.length * 2]; + System.arraycopy(buffer, 0, tmp, 0, cursor); + buffer = tmp; + } + } + if (cursor != buffer.length) { + byte[] tmp = new byte[cursor]; + System.arraycopy(buffer, 0, tmp, 0, cursor); + buffer = tmp; + } + return buffer; + } + + /** + * Throws RuntimeException to indicate failed assertion. + * The function never returns and its return type is RuntimeException + * only to be able to write <tt>throw Kit.codeBug()</tt> if plain + * <tt>Kit.codeBug()</tt> triggers unreachable code error. + */ + public static RuntimeException codeBug() + throws RuntimeException + { + RuntimeException ex = new IllegalStateException("FAILED ASSERTION"); + // Print stack trace ASAP + ex.printStackTrace(System.err); + throw ex; + } +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/LazilyLoadedCtor.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/LazilyLoadedCtor.java new file mode 100644 index 0000000..4153372 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/LazilyLoadedCtor.java @@ -0,0 +1,136 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.*; + +/** + * Avoid loading classes unless they are used. + * + * <p> This improves startup time and average memory usage. + */ +public final class LazilyLoadedCtor implements java.io.Serializable { + private static final long serialVersionUID = 1L; + + private static final int STATE_BEFORE_INIT = 0; + private static final int STATE_INITIALIZING = 1; + private static final int STATE_WITH_VALUE = 2; + + private final ScriptableObject scope; + private final String propertyName; + private final String className; + private final boolean sealed; + private Object initializedValue; + private int state; + + public LazilyLoadedCtor(ScriptableObject scope, String propertyName, + String className, boolean sealed) + { + + this.scope = scope; + this.propertyName = propertyName; + this.className = className; + this.sealed = sealed; + this.state = STATE_BEFORE_INIT; + + scope.addLazilyInitializedValue(propertyName, 0, this, + ScriptableObject.DONTENUM); + } + + void init() + { + synchronized (this) { + if (state == STATE_INITIALIZING) + throw new IllegalStateException( + "Recursive initialization for "+propertyName); + if (state == STATE_BEFORE_INIT) { + state = STATE_INITIALIZING; + // Set value now to have something to set in finally block if + // buildValue throws. + Object value = Scriptable.NOT_FOUND; + try { + value = buildValue(); + } finally { + initializedValue = value; + state = STATE_WITH_VALUE; + } + } + } + } + + Object getValue() + { + if (state != STATE_WITH_VALUE) + throw new IllegalStateException(propertyName); + return initializedValue; + } + + private Object buildValue() + { + Class cl = Kit.classOrNull(className); + if (cl != null) { + try { + Object value = ScriptableObject.buildClassCtor(scope, cl, + sealed, false); + if (value != null) { + return value; + } + else { + // cl has own static initializer which is expected + // to set the property on its own. + value = scope.get(propertyName, scope); + if (value != Scriptable.NOT_FOUND) + return value; + } + } catch (InvocationTargetException ex) { + Throwable target = ex.getTargetException(); + if (target instanceof RuntimeException) { + throw (RuntimeException)target; + } + } catch (RhinoException ex) { + } catch (InstantiationException ex) { + } catch (IllegalAccessException ex) { + } catch (SecurityException ex) { + } + } + return Scriptable.NOT_FOUND; + } + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/MemberBox.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/MemberBox.java new file mode 100644 index 0000000..2d3553f --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/MemberBox.java @@ -0,0 +1,362 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * Felix Meschberger + * Norris Boyd + * Ulrike Mueller <umueller@demandware.com> + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.*; +import java.io.*; + +/** + * Wrappper class for Method and Constructor instances to cache + * getParameterTypes() results, recover from IllegalAccessException + * in some cases and provide serialization support. + * + * @author Igor Bukanov + */ + +final class MemberBox implements Serializable +{ + static final long serialVersionUID = 6358550398665688245L; + + private transient Member memberObject; + transient Class[] argTypes; + transient Object delegateTo; + transient boolean vararg; + + + MemberBox(Method method) + { + init(method); + } + + MemberBox(Constructor constructor) + { + init(constructor); + } + + private void init(Method method) + { + this.memberObject = method; + this.argTypes = method.getParameterTypes(); + this.vararg = VMBridge.instance.isVarArgs(method); + } + + private void init(Constructor constructor) + { + this.memberObject = constructor; + this.argTypes = constructor.getParameterTypes(); + this.vararg = VMBridge.instance.isVarArgs(constructor); + } + + Method method() + { + return (Method)memberObject; + } + + Constructor ctor() + { + return (Constructor)memberObject; + } + + Member member() + { + return memberObject; + } + + boolean isMethod() + { + return memberObject instanceof Method; + } + + boolean isCtor() + { + return memberObject instanceof Constructor; + } + + boolean isStatic() + { + return Modifier.isStatic(memberObject.getModifiers()); + } + + String getName() + { + return memberObject.getName(); + } + + Class getDeclaringClass() + { + return memberObject.getDeclaringClass(); + } + + String toJavaDeclaration() + { + StringBuffer sb = new StringBuffer(); + if (isMethod()) { + Method method = method(); + sb.append(method.getReturnType()); + sb.append(' '); + sb.append(method.getName()); + } else { + Constructor ctor = ctor(); + String name = ctor.getDeclaringClass().getName(); + int lastDot = name.lastIndexOf('.'); + if (lastDot >= 0) { + name = name.substring(lastDot + 1); + } + sb.append(name); + } + sb.append(JavaMembers.liveConnectSignature(argTypes)); + return sb.toString(); + } + + public String toString() + { + return memberObject.toString(); + } + + Object invoke(Object target, Object[] args) + { + Method method = method(); + try { + try { + return method.invoke(target, args); + } catch (IllegalAccessException ex) { + Method accessible = searchAccessibleMethod(method, argTypes); + if (accessible != null) { + memberObject = accessible; + method = accessible; + } else { + if (!VMBridge.instance.tryToMakeAccessible(method)) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } + // Retry after recovery + return method.invoke(target, args); + } + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } + + Object newInstance(Object[] args) + { + Constructor ctor = ctor(); + try { + try { + return ctor.newInstance(args); + } catch (IllegalAccessException ex) { + if (!VMBridge.instance.tryToMakeAccessible(ctor)) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } + return ctor.newInstance(args); + } catch (Exception ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } + } + + private static Method searchAccessibleMethod(Method method, Class[] params) + { + int modifiers = method.getModifiers(); + if (Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers)) { + Class c = method.getDeclaringClass(); + if (!Modifier.isPublic(c.getModifiers())) { + String name = method.getName(); + Class[] intfs = c.getInterfaces(); + for (int i = 0, N = intfs.length; i != N; ++i) { + Class intf = intfs[i]; + if (Modifier.isPublic(intf.getModifiers())) { + try { + return intf.getMethod(name, params); + } catch (NoSuchMethodException ex) { + } catch (SecurityException ex) { } + } + } + for (;;) { + c = c.getSuperclass(); + if (c == null) { break; } + if (Modifier.isPublic(c.getModifiers())) { + try { + Method m = c.getMethod(name, params); + int mModifiers = m.getModifiers(); + if (Modifier.isPublic(mModifiers) + && !Modifier.isStatic(mModifiers)) + { + return m; + } + } catch (NoSuchMethodException ex) { + } catch (SecurityException ex) { } + } + } + } + } + return null; + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + Member member = readMember(in); + if (member instanceof Method) { + init((Method)member); + } else { + init((Constructor)member); + } + } + + private void writeObject(ObjectOutputStream out) + throws IOException + { + out.defaultWriteObject(); + writeMember(out, memberObject); + } + + /** + * Writes a Constructor or Method object. + * + * Methods and Constructors are not serializable, so we must serialize + * information about the class, the name, and the parameters and + * recreate upon deserialization. + */ + private static void writeMember(ObjectOutputStream out, Member member) + throws IOException + { + if (member == null) { + out.writeBoolean(false); + return; + } + out.writeBoolean(true); + if (!(member instanceof Method || member instanceof Constructor)) + throw new IllegalArgumentException("not Method or Constructor"); + out.writeBoolean(member instanceof Method); + out.writeObject(member.getName()); + out.writeObject(member.getDeclaringClass()); + if (member instanceof Method) { + writeParameters(out, ((Method) member).getParameterTypes()); + } else { + writeParameters(out, ((Constructor) member).getParameterTypes()); + } + } + + /** + * Reads a Method or a Constructor from the stream. + */ + private static Member readMember(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + if (!in.readBoolean()) + return null; + boolean isMethod = in.readBoolean(); + String name = (String) in.readObject(); + Class declaring = (Class) in.readObject(); + Class[] parms = readParameters(in); + try { + if (isMethod) { + return declaring.getMethod(name, parms); + } else { + return declaring.getConstructor(parms); + } + } catch (NoSuchMethodException e) { + throw new IOException("Cannot find member: " + e); + } + } + + private static final Class[] primitives = { + Boolean.TYPE, + Byte.TYPE, + Character.TYPE, + Double.TYPE, + Float.TYPE, + Integer.TYPE, + Long.TYPE, + Short.TYPE, + Void.TYPE + }; + + /** + * Writes an array of parameter types to the stream. + * + * Requires special handling because primitive types cannot be + * found upon deserialization by the default Java implementation. + */ + private static void writeParameters(ObjectOutputStream out, Class[] parms) + throws IOException + { + out.writeShort(parms.length); + outer: + for (int i=0; i < parms.length; i++) { + Class parm = parms[i]; + boolean primitive = parm.isPrimitive(); + out.writeBoolean(primitive); + if (!primitive) { + out.writeObject(parm); + continue; + } + for (int j=0; j < primitives.length; j++) { + if (parm.equals(primitives[j])) { + out.writeByte(j); + continue outer; + } + } + throw new IllegalArgumentException("Primitive " + parm + + " not found"); + } + } + + /** + * Reads an array of parameter types from the stream. + */ + private static Class[] readParameters(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + Class[] result = new Class[in.readShort()]; + for (int i=0; i < result.length; i++) { + if (!in.readBoolean()) { + result[i] = (Class) in.readObject(); + continue; + } + result[i] = primitives[in.readByte()]; + } + return result; + } +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeArray.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeArray.java new file mode 100644 index 0000000..b170ff4 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeArray.java @@ -0,0 +1,1727 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Mike McCabe + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.Arrays; + +/** + * This class implements the Array native object. + * @author Norris Boyd + * @author Mike McCabe + */ +public class NativeArray extends IdScriptableObject +{ + static final long serialVersionUID = 7331366857676127338L; + + /* + * Optimization possibilities and open issues: + * - Long vs. double schizophrenia. I suspect it might be better + * to use double throughout. + * + * - Functions that need a new Array call "new Array" in the + * current scope rather than using a hardwired constructor; + * "Array" could be redefined. It turns out that js calls the + * equivalent of "new Array" in the current scope, except that it + * always gets at least an object back, even when Array == null. + */ + + private static final Object ARRAY_TAG = new Object(); + private static final Integer NEGATIVE_ONE = new Integer(-1); + + static void init(Scriptable scope, boolean sealed) + { + NativeArray obj = new NativeArray(0); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + static int getMaximumInitialCapacity() { + return maximumInitialCapacity; + } + + static void setMaximumInitialCapacity(int maximumInitialCapacity) { + NativeArray.maximumInitialCapacity = maximumInitialCapacity; + } + + public NativeArray(long lengthArg) + { + denseOnly = lengthArg <= maximumInitialCapacity; + if (denseOnly) { + int intLength = (int) lengthArg; + if (intLength < DEFAULT_INITIAL_CAPACITY) + intLength = DEFAULT_INITIAL_CAPACITY; + dense = new Object[intLength]; + Arrays.fill(dense, Scriptable.NOT_FOUND); + } + length = lengthArg; + } + + public NativeArray(Object[] array) + { + denseOnly = true; + dense = array; + length = array.length; + } + + public String getClassName() + { + return "Array"; + } + + private static final int + Id_length = 1, + MAX_INSTANCE_ID = 1; + + protected int getMaxInstanceId() + { + return MAX_INSTANCE_ID; + } + + protected int findInstanceIdInfo(String s) + { + if (s.equals("length")) { + return instanceIdInfo(DONTENUM | PERMANENT, Id_length); + } + return super.findInstanceIdInfo(s); + } + + protected String getInstanceIdName(int id) + { + if (id == Id_length) { return "length"; } + return super.getInstanceIdName(id); + } + + protected Object getInstanceIdValue(int id) + { + if (id == Id_length) { + return ScriptRuntime.wrapNumber(length); + } + return super.getInstanceIdValue(id); + } + + protected void setInstanceIdValue(int id, Object value) + { + if (id == Id_length) { + setLength(value); return; + } + super.setInstanceIdValue(id, value); + } + + protected void fillConstructorProperties(IdFunctionObject ctor) + { + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_join, + "join", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_reverse, + "reverse", 1); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_sort, + "sort", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_push, + "push", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_pop, + "pop", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_shift, + "shift", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_unshift, + "unshift", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_splice, + "splice", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_concat, + "concat", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_slice, + "slice", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_indexOf, + "indexOf", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_lastIndexOf, + "lastIndexOf", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_every, + "every", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_filter, + "filter", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_forEach, + "forEach", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_map, + "map", 2); + addIdFunctionProperty(ctor, ARRAY_TAG, ConstructorId_some, + "some", 2); + super.fillConstructorProperties(ctor); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toLocaleString: arity=1; s="toLocaleString"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id_join: arity=1; s="join"; break; + case Id_reverse: arity=0; s="reverse"; break; + case Id_sort: arity=1; s="sort"; break; + case Id_push: arity=1; s="push"; break; + case Id_pop: arity=1; s="pop"; break; + case Id_shift: arity=1; s="shift"; break; + case Id_unshift: arity=1; s="unshift"; break; + case Id_splice: arity=1; s="splice"; break; + case Id_concat: arity=1; s="concat"; break; + case Id_slice: arity=1; s="slice"; break; + case Id_indexOf: arity=1; s="indexOf"; break; + case Id_lastIndexOf: arity=1; s="lastIndexOf"; break; + case Id_every: arity=1; s="every"; break; + case Id_filter: arity=1; s="filter"; break; + case Id_forEach: arity=1; s="forEach"; break; + case Id_map: arity=1; s="map"; break; + case Id_some: arity=1; s="some"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(ARRAY_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(ARRAY_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + again: + for (;;) { + switch (id) { + case ConstructorId_join: + case ConstructorId_reverse: + case ConstructorId_sort: + case ConstructorId_push: + case ConstructorId_pop: + case ConstructorId_shift: + case ConstructorId_unshift: + case ConstructorId_splice: + case ConstructorId_concat: + case ConstructorId_slice: + case ConstructorId_indexOf: + case ConstructorId_lastIndexOf: + case ConstructorId_every: + case ConstructorId_filter: + case ConstructorId_forEach: + case ConstructorId_map: + case ConstructorId_some: { + thisObj = ScriptRuntime.toObject(scope, args[0]); + Object[] newArgs = new Object[args.length-1]; + for (int i=0; i < newArgs.length; i++) + newArgs[i] = args[i+1]; + args = newArgs; + id = -id; + continue again; + } + + case Id_constructor: { + boolean inNewExpr = (thisObj == null); + if (!inNewExpr) { + // IdFunctionObject.construct will set up parent, proto + return f.construct(cx, scope, args); + } + return jsConstructor(cx, scope, args); + } + + case Id_toString: + return toStringHelper(cx, scope, thisObj, + cx.hasFeature(Context.FEATURE_TO_STRING_AS_SOURCE), false); + + case Id_toLocaleString: + return toStringHelper(cx, scope, thisObj, false, true); + + case Id_toSource: + return toStringHelper(cx, scope, thisObj, true, false); + + case Id_join: + return js_join(cx, thisObj, args); + + case Id_reverse: + return js_reverse(cx, thisObj, args); + + case Id_sort: + return js_sort(cx, scope, thisObj, args); + + case Id_push: + return js_push(cx, thisObj, args); + + case Id_pop: + return js_pop(cx, thisObj, args); + + case Id_shift: + return js_shift(cx, thisObj, args); + + case Id_unshift: + return js_unshift(cx, thisObj, args); + + case Id_splice: + return js_splice(cx, scope, thisObj, args); + + case Id_concat: + return js_concat(cx, scope, thisObj, args); + + case Id_slice: + return js_slice(cx, thisObj, args); + + case Id_indexOf: + return indexOfHelper(cx, thisObj, args, false); + + case Id_lastIndexOf: + return indexOfHelper(cx, thisObj, args, true); + + case Id_every: + case Id_filter: + case Id_forEach: + case Id_map: + case Id_some: + return iterativeMethod(cx, id, scope, thisObj, args); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + } + + public Object get(int index, Scriptable start) + { + if (!denseOnly && isGetterOrSetter(null, index, false)) + return super.get(index, start); + if (dense != null && 0 <= index && index < dense.length) + return dense[index]; + return super.get(index, start); + } + + public boolean has(int index, Scriptable start) + { + if (!denseOnly && isGetterOrSetter(null, index, false)) + return super.has(index, start); + if (dense != null && 0 <= index && index < dense.length) + return dense[index] != NOT_FOUND; + return super.has(index, start); + } + + // if id is an array index (ECMA 15.4.0), return the number, + // otherwise return -1L + private static long toArrayIndex(String id) + { + double d = ScriptRuntime.toNumber(id); + if (d == d) { + long index = ScriptRuntime.toUint32(d); + if (index == d && index != 4294967295L) { + // Assume that ScriptRuntime.toString(index) is the same + // as java.lang.Long.toString(index) for long + if (Long.toString(index).equals(id)) { + return index; + } + } + } + return -1; + } + + public void put(String id, Scriptable start, Object value) + { + super.put(id, start, value); + if (start == this) { + // If the object is sealed, super will throw exception + long index = toArrayIndex(id); + if (index >= length) { + length = index + 1; + denseOnly = false; + } + } + } + + private boolean ensureCapacity(int capacity) + { + if (capacity > dense.length) { + if (capacity > MAX_PRE_GROW_SIZE) { + denseOnly = false; + return false; + } + capacity = Math.max(capacity, (int)(dense.length * GROW_FACTOR)); + Object[] newDense = new Object[capacity]; + System.arraycopy(dense, 0, newDense, 0, dense.length); + Arrays.fill(newDense, dense.length, newDense.length, + Scriptable.NOT_FOUND); + dense = newDense; + } + return true; + } + + public void put(int index, Scriptable start, Object value) + { + if (start == this && !isSealed() && dense != null && 0 <= index && + (denseOnly || !isGetterOrSetter(null, index, true))) + { + if (index < dense.length) { + dense[index] = value; + if (this.length <= index) + this.length = (long)index + 1; + return; + } else if (denseOnly && index < dense.length * GROW_FACTOR && + ensureCapacity(index+1)) + { + dense[index] = value; + this.length = (long)index + 1; + return; + } else { + denseOnly = false; + } + } + super.put(index, start, value); + if (start == this) { + // only set the array length if given an array index (ECMA 15.4.0) + if (this.length <= index) { + // avoid overflowing index! + this.length = (long)index + 1; + } + } + } + + public void delete(int index) + { + if (dense != null && 0 <= index && index < dense.length && + !isSealed() && (denseOnly || !isGetterOrSetter(null, index, true))) + { + dense[index] = NOT_FOUND; + } else { + super.delete(index); + } + } + + public Object[] getIds() + { + Object[] superIds = super.getIds(); + if (dense == null) { return superIds; } + int N = dense.length; + long currentLength = length; + if (N > currentLength) { + N = (int)currentLength; + } + if (N == 0) { return superIds; } + int superLength = superIds.length; + Object[] ids = new Object[N + superLength]; + + int presentCount = 0; + for (int i = 0; i != N; ++i) { + // Replace existing elements by their indexes + if (dense[i] != NOT_FOUND) { + ids[presentCount] = new Integer(i); + ++presentCount; + } + } + if (presentCount != N) { + // dense contains deleted elems, need to shrink the result + Object[] tmp = new Object[presentCount + superLength]; + System.arraycopy(ids, 0, tmp, 0, presentCount); + ids = tmp; + } + System.arraycopy(superIds, 0, ids, presentCount, superLength); + return ids; + } + + public Object getDefaultValue(Class hint) + { + if (hint == ScriptRuntime.NumberClass) { + Context cx = Context.getContext(); + if (cx.getLanguageVersion() == Context.VERSION_1_2) + return new Long(length); + } + return super.getDefaultValue(hint); + } + + /** + * See ECMA 15.4.1,2 + */ + private static Object jsConstructor(Context cx, Scriptable scope, + Object[] args) + { + if (args.length == 0) + return new NativeArray(0); + + // Only use 1 arg as first element for version 1.2; for + // any other version (including 1.3) follow ECMA and use it as + // a length. + if (cx.getLanguageVersion() == Context.VERSION_1_2) { + return new NativeArray(args); + } else { + Object arg0 = args[0]; + if (args.length > 1 || !(arg0 instanceof Number)) { + return new NativeArray(args); + } else { + long len = ScriptRuntime.toUint32(arg0); + if (len != ((Number)arg0).doubleValue()) + throw Context.reportRuntimeError0("msg.arraylength.bad"); + return new NativeArray(len); + } + } + } + + public long getLength() { + return length; + } + + /** @deprecated Use {@link #getLength()} instead. */ + public long jsGet_length() { + return getLength(); + } + + /** + * Change the value of the internal flag that determines whether all + * storage is handed by a dense backing array rather than an associative + * store. + * @param denseOnly new value for denseOnly flag + * @throws IllegalArgumentException if an attempt is made to enable + * denseOnly after it was disabled; NativeArray code is not written + * to handle switching back to a dense representation + */ + void setDenseOnly(boolean denseOnly) { + if (denseOnly && !this.denseOnly) + throw new IllegalArgumentException(); + this.denseOnly = denseOnly; + } + + private void setLength(Object val) { + /* XXX do we satisfy this? + * 15.4.5.1 [[Put]](P, V): + * 1. Call the [[CanPut]] method of A with name P. + * 2. If Result(1) is false, return. + * ? + */ + + double d = ScriptRuntime.toNumber(val); + long longVal = ScriptRuntime.toUint32(d); + if (longVal != d) + throw Context.reportRuntimeError0("msg.arraylength.bad"); + + if (denseOnly) { + if (longVal < length) { + // downcast okay because denseOnly + Arrays.fill(dense, (int) longVal, dense.length, NOT_FOUND); + length = longVal; + return; + } else if (longVal < MAX_PRE_GROW_SIZE && + longVal < (length * GROW_FACTOR) && + ensureCapacity((int)longVal)) + { + length = longVal; + return; + } else { + denseOnly = false; + } + } + if (longVal < length) { + // remove all properties between longVal and length + if (length - longVal > 0x1000) { + // assume that the representation is sparse + Object[] e = getIds(); // will only find in object itself + for (int i=0; i < e.length; i++) { + Object id = e[i]; + if (id instanceof String) { + // > MAXINT will appear as string + String strId = (String)id; + long index = toArrayIndex(strId); + if (index >= longVal) + delete(strId); + } else { + int index = ((Integer)id).intValue(); + if (index >= longVal) + delete(index); + } + } + } else { + // assume a dense representation + for (long i = longVal; i < length; i++) { + deleteElem(this, i); + } + } + } + length = longVal; + } + + /* Support for generic Array-ish objects. Most of the Array + * functions try to be generic; anything that has a length + * property is assumed to be an array. + * getLengthProperty returns 0 if obj does not have the length property + * or its value is not convertible to a number. + */ + static long getLengthProperty(Context cx, Scriptable obj) { + // These will both give numeric lengths within Uint32 range. + if (obj instanceof NativeString) { + return ((NativeString)obj).getLength(); + } else if (obj instanceof NativeArray) { + return ((NativeArray)obj).getLength(); + } + return ScriptRuntime.toUint32( + ScriptRuntime.getObjectProp(obj, "length", cx)); + } + + private static Object setLengthProperty(Context cx, Scriptable target, + long length) + { + return ScriptRuntime.setObjectProp( + target, "length", ScriptRuntime.wrapNumber(length), cx); + } + + /* Utility functions to encapsulate index > Integer.MAX_VALUE + * handling. Also avoids unnecessary object creation that would + * be necessary to use the general ScriptRuntime.get/setElem + * functions... though this is probably premature optimization. + */ + private static void deleteElem(Scriptable target, long index) { + int i = (int)index; + if (i == index) { target.delete(i); } + else { target.delete(Long.toString(index)); } + } + + private static Object getElem(Context cx, Scriptable target, long index) + { + if (index > Integer.MAX_VALUE) { + String id = Long.toString(index); + return ScriptRuntime.getObjectProp(target, id, cx); + } else { + return ScriptRuntime.getObjectIndex(target, (int)index, cx); + } + } + + private static void setElem(Context cx, Scriptable target, long index, + Object value) + { + if (index > Integer.MAX_VALUE) { + String id = Long.toString(index); + ScriptRuntime.setObjectProp(target, id, value, cx); + } else { + ScriptRuntime.setObjectIndex(target, (int)index, value, cx); + } + } + + private static String toStringHelper(Context cx, Scriptable scope, + Scriptable thisObj, + boolean toSource, boolean toLocale) + { + /* It's probably redundant to handle long lengths in this + * function; StringBuffers are limited to 2^31 in java. + */ + + long length = getLengthProperty(cx, thisObj); + + StringBuffer result = new StringBuffer(256); + + // whether to return '4,unquoted,5' or '[4, "quoted", 5]' + String separator; + + if (toSource) { + result.append('['); + separator = ", "; + } else { + separator = ","; + } + + boolean haslast = false; + long i = 0; + + boolean toplevel, iterating; + if (cx.iterating == null) { + toplevel = true; + iterating = false; + cx.iterating = new ObjToIntMap(31); + } else { + toplevel = false; + iterating = cx.iterating.has(thisObj); + } + + // Make sure cx.iterating is set to null when done + // so we don't leak memory + try { + if (!iterating) { + cx.iterating.put(thisObj, 0); // stop recursion. + for (i = 0; i < length; i++) { + if (i > 0) result.append(separator); + Object elem = getElem(cx, thisObj, i); + if (elem == null || elem == Undefined.instance) { + haslast = false; + continue; + } + haslast = true; + + if (toSource) { + result.append(ScriptRuntime.uneval(cx, scope, elem)); + + } else if (elem instanceof String) { + String s = (String)elem; + if (toSource) { + result.append('\"'); + result.append(ScriptRuntime.escapeString(s)); + result.append('\"'); + } else { + result.append(s); + } + + } else { + if (toLocale) + { + Callable fun; + Scriptable funThis; + fun = ScriptRuntime.getPropFunctionAndThis( + elem, "toLocaleString", cx); + funThis = ScriptRuntime.lastStoredScriptable(cx); + elem = fun.call(cx, scope, funThis, + ScriptRuntime.emptyArgs); + } + result.append(ScriptRuntime.toString(elem)); + } + } + } + } finally { + if (toplevel) { + cx.iterating = null; + } + } + + if (toSource) { + //for [,,].length behavior; we want toString to be symmetric. + if (!haslast && i > 0) + result.append(", ]"); + else + result.append(']'); + } + return result.toString(); + } + + /** + * See ECMA 15.4.4.3 + */ + private static String js_join(Context cx, Scriptable thisObj, + Object[] args) + { + long llength = getLengthProperty(cx, thisObj); + int length = (int)llength; + if (llength != length) { + throw Context.reportRuntimeError1( + "msg.arraylength.too.big", String.valueOf(llength)); + } + // if no args, use "," as separator + String separator = (args.length < 1 || args[0] == Undefined.instance) + ? "," + : ScriptRuntime.toString(args[0]); + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly) { + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < length; i++) { + if (i != 0) { + sb.append(separator); + } + if (i < na.dense.length) { + Object temp = na.dense[i]; + if (temp != null && temp != Undefined.instance && + temp != Scriptable.NOT_FOUND) + { + sb.append(ScriptRuntime.toString(temp)); + } + } + } + return sb.toString(); + } + } + if (length == 0) { + return ""; + } + String[] buf = new String[length]; + int total_size = 0; + for (int i = 0; i != length; i++) { + Object temp = getElem(cx, thisObj, i); + if (temp != null && temp != Undefined.instance) { + String str = ScriptRuntime.toString(temp); + total_size += str.length(); + buf[i] = str; + } + } + total_size += (length - 1) * separator.length(); + StringBuffer sb = new StringBuffer(total_size); + for (int i = 0; i != length; i++) { + if (i != 0) { + sb.append(separator); + } + String str = buf[i]; + if (str != null) { + // str == null for undefined or null + sb.append(str); + } + } + return sb.toString(); + } + + /** + * See ECMA 15.4.4.4 + */ + private static Scriptable js_reverse(Context cx, Scriptable thisObj, + Object[] args) + { + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly) { + for (int i=0, j=((int)na.length)-1; i < j; i++,j--) { + Object temp = na.dense[i]; + na.dense[i] = na.dense[j]; + na.dense[j] = temp; + } + return thisObj; + } + } + long len = getLengthProperty(cx, thisObj); + + long half = len / 2; + for(long i=0; i < half; i++) { + long j = len - i - 1; + Object temp1 = getElem(cx, thisObj, i); + Object temp2 = getElem(cx, thisObj, j); + setElem(cx, thisObj, i, temp2); + setElem(cx, thisObj, j, temp1); + } + return thisObj; + } + + /** + * See ECMA 15.4.4.5 + */ + private static Scriptable js_sort(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + long length = getLengthProperty(cx, thisObj); + + if (length <= 1) { return thisObj; } + + Object compare; + Object[] cmpBuf; + + if (args.length > 0 && Undefined.instance != args[0]) { + // sort with given compare function + compare = args[0]; + cmpBuf = new Object[2]; // Buffer for cmp arguments + } else { + // sort with default compare + compare = null; + cmpBuf = null; + } + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly) { + int ilength = (int) length; + heapsort(cx, scope, na.dense, ilength, compare, cmpBuf); + return thisObj; + } + } + + // Should we use the extended sort function, or the faster one? + if (length >= Integer.MAX_VALUE) { + heapsort_extended(cx, scope, thisObj, length, compare, cmpBuf); + } else { + int ilength = (int)length; + // copy the JS array into a working array, so it can be + // sorted cheaply. + Object[] working = new Object[ilength]; + for (int i = 0; i != ilength; ++i) { + working[i] = getElem(cx, thisObj, i); + } + + heapsort(cx, scope, working, ilength, compare, cmpBuf); + + // copy the working array back into thisObj + for (int i = 0; i != ilength; ++i) { + setElem(cx, thisObj, i, working[i]); + } + } + return thisObj; + } + + // Return true only if x > y + private static boolean isBigger(Context cx, Scriptable scope, + Object x, Object y, + Object cmp, Object[] cmpBuf) + { + if (cmp == null) { + if (cmpBuf != null) Kit.codeBug(); + } else { + if (cmpBuf == null || cmpBuf.length != 2) Kit.codeBug(); + } + + Object undef = Undefined.instance; + Object notfound = Scriptable.NOT_FOUND; + + // sort undefined to end + if (y == undef || y == notfound) { + return false; // x can not be bigger then undef + } else if (x == undef || x == notfound) { + return true; // y != undef here, so x > y + } + + if (cmp == null) { + // if no cmp function supplied, sort lexicographically + String a = ScriptRuntime.toString(x); + String b = ScriptRuntime.toString(y); + return a.compareTo(b) > 0; + } + else { + // assemble args and call supplied JS cmp function + cmpBuf[0] = x; + cmpBuf[1] = y; + Callable fun = ScriptRuntime.getValueFunctionAndThis(cmp, cx); + Scriptable funThis = ScriptRuntime.lastStoredScriptable(cx); + + Object ret = fun.call(cx, scope, funThis, cmpBuf); + double d = ScriptRuntime.toNumber(ret); + + // XXX what to do when cmp function returns NaN? ECMA states + // that it's then not a 'consistent comparison function'... but + // then what do we do? Back out and start over with the generic + // cmp function when we see a NaN? Throw an error? + + // for now, just ignore it: + + return d > 0; + } + } + +/** Heapsort implementation. + * See "Introduction to Algorithms" by Cormen, Leiserson, Rivest for details. + * Adjusted for zero based indexes. + */ + private static void heapsort(Context cx, Scriptable scope, + Object[] array, int length, + Object cmp, Object[] cmpBuf) + { + if (length <= 1) Kit.codeBug(); + + // Build heap + for (int i = length / 2; i != 0;) { + --i; + Object pivot = array[i]; + heapify(cx, scope, pivot, array, i, length, cmp, cmpBuf); + } + + // Sort heap + for (int i = length; i != 1;) { + --i; + Object pivot = array[i]; + array[i] = array[0]; + heapify(cx, scope, pivot, array, 0, i, cmp, cmpBuf); + } + } + +/** pivot and child heaps of i should be made into heap starting at i, + * original array[i] is never used to have less array access during sorting. + */ + private static void heapify(Context cx, Scriptable scope, + Object pivot, Object[] array, int i, int end, + Object cmp, Object[] cmpBuf) + { + for (;;) { + int child = i * 2 + 1; + if (child >= end) { + break; + } + Object childVal = array[child]; + if (child + 1 < end) { + Object nextVal = array[child + 1]; + if (isBigger(cx, scope, nextVal, childVal, cmp, cmpBuf)) { + ++child; childVal = nextVal; + } + } + if (!isBigger(cx, scope, childVal, pivot, cmp, cmpBuf)) { + break; + } + array[i] = childVal; + i = child; + } + array[i] = pivot; + } + +/** Version of heapsort that call getElem/setElem on target to query/assign + * array elements instead of Java array access + */ + private static void heapsort_extended(Context cx, Scriptable scope, + Scriptable target, long length, + Object cmp, Object[] cmpBuf) + { + if (length <= 1) Kit.codeBug(); + + // Build heap + for (long i = length / 2; i != 0;) { + --i; + Object pivot = getElem(cx, target, i); + heapify_extended(cx, scope, pivot, target, i, length, cmp, cmpBuf); + } + + // Sort heap + for (long i = length; i != 1;) { + --i; + Object pivot = getElem(cx, target, i); + setElem(cx, target, i, getElem(cx, target, 0)); + heapify_extended(cx, scope, pivot, target, 0, i, cmp, cmpBuf); + } + } + + private static void heapify_extended(Context cx, Scriptable scope, + Object pivot, Scriptable target, + long i, long end, + Object cmp, Object[] cmpBuf) + { + for (;;) { + long child = i * 2 + 1; + if (child >= end) { + break; + } + Object childVal = getElem(cx, target, child); + if (child + 1 < end) { + Object nextVal = getElem(cx, target, child + 1); + if (isBigger(cx, scope, nextVal, childVal, cmp, cmpBuf)) { + ++child; childVal = nextVal; + } + } + if (!isBigger(cx, scope, childVal, pivot, cmp, cmpBuf)) { + break; + } + setElem(cx, target, i, childVal); + i = child; + } + setElem(cx, target, i, pivot); + } + + /** + * Non-ECMA methods. + */ + + private static Object js_push(Context cx, Scriptable thisObj, + Object[] args) + { + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly && + na.ensureCapacity((int) na.length + args.length)) + { + for (int i = 0; i < args.length; i++) { + na.dense[(int)na.length++] = args[i]; + } + return ScriptRuntime.wrapNumber(na.length); + } + } + long length = getLengthProperty(cx, thisObj); + for (int i = 0; i < args.length; i++) { + setElem(cx, thisObj, length + i, args[i]); + } + + length += args.length; + Object lengthObj = setLengthProperty(cx, thisObj, length); + + /* + * If JS1.2, follow Perl4 by returning the last thing pushed. + * Otherwise, return the new array length. + */ + if (cx.getLanguageVersion() == Context.VERSION_1_2) + // if JS1.2 && no arguments, return undefined. + return args.length == 0 + ? Undefined.instance + : args[args.length - 1]; + + else + return lengthObj; + } + + private static Object js_pop(Context cx, Scriptable thisObj, + Object[] args) + { + Object result; + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly && na.length > 0) { + na.length--; + result = na.dense[(int)na.length]; + na.dense[(int)na.length] = NOT_FOUND; + return result; + } + } + long length = getLengthProperty(cx, thisObj); + if (length > 0) { + length--; + + // Get the to-be-deleted property's value. + result = getElem(cx, thisObj, length); + + // We don't need to delete the last property, because + // setLength does that for us. + } else { + result = Undefined.instance; + } + // necessary to match js even when length < 0; js pop will give a + // length property to any target it is called on. + setLengthProperty(cx, thisObj, length); + + return result; + } + + private static Object js_shift(Context cx, Scriptable thisObj, + Object[] args) + { + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly && na.length > 0) { + na.length--; + Object result = na.dense[0]; + System.arraycopy(na.dense, 1, na.dense, 0, (int)na.length); + na.dense[(int)na.length] = NOT_FOUND; + return result; + } + } + Object result; + long length = getLengthProperty(cx, thisObj); + if (length > 0) { + long i = 0; + length--; + + // Get the to-be-deleted property's value. + result = getElem(cx, thisObj, i); + + /* + * Slide down the array above the first element. Leave i + * set to point to the last element. + */ + if (length > 0) { + for (i = 1; i <= length; i++) { + Object temp = getElem(cx, thisObj, i); + setElem(cx, thisObj, i - 1, temp); + } + } + // We don't need to delete the last property, because + // setLength does that for us. + } else { + result = Undefined.instance; + } + setLengthProperty(cx, thisObj, length); + return result; + } + + private static Object js_unshift(Context cx, Scriptable thisObj, + Object[] args) + { + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly && + na.ensureCapacity((int)na.length + args.length)) + { + System.arraycopy(na.dense, 0, na.dense, args.length, + (int) na.length); + for (int i = 0; i < args.length; i++) { + na.dense[i] = args[i]; + } + na.length += args.length; + return ScriptRuntime.wrapNumber(na.length); + } + } + long length = getLengthProperty(cx, thisObj); + int argc = args.length; + + if (args.length > 0) { + /* Slide up the array to make room for args at the bottom */ + if (length > 0) { + for (long last = length - 1; last >= 0; last--) { + Object temp = getElem(cx, thisObj, last); + setElem(cx, thisObj, last + argc, temp); + } + } + + /* Copy from argv to the bottom of the array. */ + for (int i = 0; i < args.length; i++) { + setElem(cx, thisObj, i, args[i]); + } + + /* Follow Perl by returning the new array length. */ + length += args.length; + return setLengthProperty(cx, thisObj, length); + } + return ScriptRuntime.wrapNumber(length); + } + + private static Object js_splice(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + NativeArray na = null; + boolean denseMode = false; + if (thisObj instanceof NativeArray) { + na = (NativeArray) thisObj; + denseMode = na.denseOnly; + } + + /* create an empty Array to return. */ + scope = getTopLevelScope(scope); + int argc = args.length; + if (argc == 0) + return ScriptRuntime.newObject(cx, scope, "Array", null); + long length = getLengthProperty(cx, thisObj); + + /* Convert the first argument into a starting index. */ + long begin = toSliceIndex(ScriptRuntime.toInteger(args[0]), length); + argc--; + + /* Convert the second argument into count */ + long count; + if (args.length == 1) { + count = length - begin; + } else { + double dcount = ScriptRuntime.toInteger(args[1]); + if (dcount < 0) { + count = 0; + } else if (dcount > (length - begin)) { + count = length - begin; + } else { + count = (long)dcount; + } + argc--; + } + + long end = begin + count; + + /* If there are elements to remove, put them into the return value. */ + Object result; + if (count != 0) { + if (count == 1 + && (cx.getLanguageVersion() == Context.VERSION_1_2)) + { + /* + * JS lacks "list context", whereby in Perl one turns the + * single scalar that's spliced out into an array just by + * assigning it to @single instead of $single, or by using it + * as Perl push's first argument, for instance. + * + * JS1.2 emulated Perl too closely and returned a non-Array for + * the single-splice-out case, requiring callers to test and + * wrap in [] if necessary. So JS1.3, default, and other + * versions all return an array of length 1 for uniformity. + */ + result = getElem(cx, thisObj, begin); + } else { + if (denseMode) { + int intLen = (int) (end - begin); + Object[] copy = new Object[intLen]; + System.arraycopy(na.dense, (int) begin, copy, 0, intLen); + result = cx.newArray(scope, copy); + } else { + Scriptable resultArray = ScriptRuntime.newObject(cx, scope, + "Array", null); + for (long last = begin; last != end; last++) { + Object temp = getElem(cx, thisObj, last); + setElem(cx, resultArray, last - begin, temp); + } + result = resultArray; + } + } + } else { // (count == 0) + if (cx.getLanguageVersion() == Context.VERSION_1_2) { + /* Emulate C JS1.2; if no elements are removed, return undefined. */ + result = Undefined.instance; + } else { + result = ScriptRuntime.newObject(cx, scope, "Array", null); + } + } + + /* Find the direction (up or down) to copy and make way for argv. */ + long delta = argc - count; + if (denseMode && length + delta < Integer.MAX_VALUE && + na.ensureCapacity((int) (length + delta))) + { + System.arraycopy(na.dense, (int) end, na.dense, + (int) (begin + argc), (int) (length - end)); + if (argc > 0) { + System.arraycopy(args, 2, na.dense, (int) begin, argc); + } + if (delta < 0) { + Arrays.fill(na.dense, (int) (length + delta), (int) length, + NOT_FOUND); + } + na.length = length + delta; + return result; + } + + if (delta > 0) { + for (long last = length - 1; last >= end; last--) { + Object temp = getElem(cx, thisObj, last); + setElem(cx, thisObj, last + delta, temp); + } + } else if (delta < 0) { + for (long last = end; last < length; last++) { + Object temp = getElem(cx, thisObj, last); + setElem(cx, thisObj, last + delta, temp); + } + } + + /* Copy from argv into the hole to complete the splice. */ + int argoffset = args.length - argc; + for (int i = 0; i < argc; i++) { + setElem(cx, thisObj, begin + i, args[i + argoffset]); + } + + /* Update length in case we deleted elements from the end. */ + setLengthProperty(cx, thisObj, length + delta); + return result; + } + + /* + * See Ecma 262v3 15.4.4.4 + */ + private static Scriptable js_concat(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + // create an empty Array to return. + scope = getTopLevelScope(scope); + Function ctor = ScriptRuntime.getExistingCtor(cx, scope, "Array"); + Scriptable result = ctor.construct(cx, scope, ScriptRuntime.emptyArgs); + if (thisObj instanceof NativeArray && result instanceof NativeArray) { + NativeArray denseThis = (NativeArray) thisObj; + NativeArray denseResult = (NativeArray) result; + if (denseThis.denseOnly && denseResult.denseOnly) { + // First calculate length of resulting array + boolean canUseDense = true; + int length = (int) denseThis.length; + for (int i = 0; i < args.length && canUseDense; i++) { + if (ScriptRuntime.instanceOf(args[i], ctor, cx)) { + // only try to use dense approach for Array-like + // objects that are actually NativeArrays + canUseDense = args[i] instanceof NativeArray; + length += ((NativeArray) args[i]).length; + } else { + length++; + } + } + if (canUseDense && denseResult.ensureCapacity(length)) { + System.arraycopy(denseThis.dense, 0, denseResult.dense, + 0, (int) denseThis.length); + int cursor = (int) denseThis.length; + for (int i = 0; i < args.length && canUseDense; i++) { + if (args[i] instanceof NativeArray) { + NativeArray arg = (NativeArray) args[i]; + System.arraycopy(arg.dense, 0, + denseResult.dense, cursor, + (int)arg.length); + cursor += (int)arg.length; + } else { + denseResult.dense[cursor++] = args[i]; + } + } + denseResult.length = length; + return result; + } + } + } + + long length; + long slot = 0; + + /* Put the target in the result array; only add it as an array + * if it looks like one. + */ + if (ScriptRuntime.instanceOf(thisObj, ctor, cx)) { + length = getLengthProperty(cx, thisObj); + + // Copy from the target object into the result + for (slot = 0; slot < length; slot++) { + Object temp = getElem(cx, thisObj, slot); + setElem(cx, result, slot, temp); + } + } else { + setElem(cx, result, slot++, thisObj); + } + + /* Copy from the arguments into the result. If any argument + * has a numeric length property, treat it as an array and add + * elements separately; otherwise, just copy the argument. + */ + for (int i = 0; i < args.length; i++) { + if (ScriptRuntime.instanceOf(args[i], ctor, cx)) { + // ScriptRuntime.instanceOf => instanceof Scriptable + Scriptable arg = (Scriptable)args[i]; + length = getLengthProperty(cx, arg); + for (long j = 0; j < length; j++, slot++) { + Object temp = getElem(cx, arg, j); + setElem(cx, result, slot, temp); + } + } else { + setElem(cx, result, slot++, args[i]); + } + } + return result; + } + + private Scriptable js_slice(Context cx, Scriptable thisObj, + Object[] args) + { + Scriptable scope = getTopLevelScope(this); + Scriptable result = ScriptRuntime.newObject(cx, scope, "Array", null); + long length = getLengthProperty(cx, thisObj); + + long begin, end; + if (args.length == 0) { + begin = 0; + end = length; + } else { + begin = toSliceIndex(ScriptRuntime.toInteger(args[0]), length); + if (args.length == 1) { + end = length; + } else { + end = toSliceIndex(ScriptRuntime.toInteger(args[1]), length); + } + } + + for (long slot = begin; slot < end; slot++) { + Object temp = getElem(cx, thisObj, slot); + setElem(cx, result, slot - begin, temp); + } + + return result; + } + + private static long toSliceIndex(double value, long length) { + long result; + if (value < 0.0) { + if (value + length < 0.0) { + result = 0; + } else { + result = (long)(value + length); + } + } else if (value > length) { + result = length; + } else { + result = (long)value; + } + return result; + } + + /** + * Implements the methods "indexOf" and "lastIndexOf". + */ + private Object indexOfHelper(Context cx, Scriptable thisObj, + Object[] args, boolean isLast) + { + Object compareTo = args.length > 0 ? args[0] : Undefined.instance; + long length = getLengthProperty(cx, thisObj); + long start; + if (isLast) { + // lastIndexOf + /* + * From http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:lastIndexOf + * The index at which to start searching backwards. Defaults to the + * array's length, i.e. the whole array will be searched. If the + * index is greater than or equal to the length of the array, the + * whole array will be searched. If negative, it is taken as the + * offset from the end of the array. Note that even when the index + * is negative, the array is still searched from back to front. If + * the calculated index is less than 0, -1 is returned, i.e. the + * array will not be searched. + */ + if (args.length < 2) { + // default + start = length-1; + } else { + start = ScriptRuntime.toInt32(ScriptRuntime.toNumber(args[1])); + if (start >= length) + start = length-1; + else if (start < 0) + start += length; + // Note that start may be negative, but that's okay + // as the result of -1 will fall out from the code below + } + } else { + // indexOf + /* + * From http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:indexOf + * The index at which to begin the search. Defaults to 0, i.e. the + * whole array will be searched. If the index is greater than or + * equal to the length of the array, -1 is returned, i.e. the array + * will not be searched. If negative, it is taken as the offset from + * the end of the array. Note that even when the index is negative, + * the array is still searched from front to back. If the calculated + * index is less than 0, the whole array will be searched. + */ + if (args.length < 2) { + // default + start = 0; + } else { + start = ScriptRuntime.toInt32(ScriptRuntime.toNumber(args[1])); + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + // Note that start may be > length-1, but that's okay + // as the result of -1 will fall out from the code below + } + } + if (thisObj instanceof NativeArray) { + NativeArray na = (NativeArray) thisObj; + if (na.denseOnly) { + if (isLast) { + for (int i=(int)start; i >= 0; i--) { + if (na.dense[i] != Scriptable.NOT_FOUND && + ScriptRuntime.shallowEq(na.dense[i], compareTo)) + { + return new Long(i); + } + } + } else { + for (int i=(int)start; i < length; i++) { + if (na.dense[i] != Scriptable.NOT_FOUND && + ScriptRuntime.shallowEq(na.dense[i], compareTo)) + { + return new Long(i); + } + } + } + return NEGATIVE_ONE; + } + } + if (isLast) { + for (long i=start; i >= 0; i--) { + if (ScriptRuntime.shallowEq(getElem(cx, thisObj, i), compareTo)) { + return new Long(i); + } + } + } else { + for (long i=start; i < length; i++) { + if (ScriptRuntime.shallowEq(getElem(cx, thisObj, i), compareTo)) { + return new Long(i); + } + } + } + return NEGATIVE_ONE; + } + + /** + * Implements the methods "every", "filter", "forEach", "map", and "some". + */ + private Object iterativeMethod(Context cx, int id, Scriptable scope, + Scriptable thisObj, Object[] args) + { + Object callbackArg = args.length > 0 ? args[0] : Undefined.instance; + if (callbackArg == null || !(callbackArg instanceof Function)) { + throw ScriptRuntime.notFunctionError( + ScriptRuntime.toString(callbackArg)); + } + Function f = (Function) callbackArg; + Scriptable parent = ScriptableObject.getTopLevelScope(f); + Scriptable thisArg; + if (args.length < 2 || args[1] == null || args[1] == Undefined.instance) + { + thisArg = parent; + } else { + thisArg = ScriptRuntime.toObject(cx, scope, args[1]); + } + long length = getLengthProperty(cx, thisObj); + Scriptable array = ScriptRuntime.newObject(cx, scope, "Array", null); + long j=0; + for (long i=0; i < length; i++) { + Object[] innerArgs = new Object[3]; + Object elem = (i > Integer.MAX_VALUE) + ? ScriptableObject.getProperty(thisObj, Long.toString(i)) + : ScriptableObject.getProperty(thisObj, (int)i); + if (elem == Scriptable.NOT_FOUND) { + continue; + } + innerArgs[0] = elem; + innerArgs[1] = new Long(i); + innerArgs[2] = thisObj; + Object result = f.call(cx, parent, thisArg, innerArgs); + switch (id) { + case Id_every: + if (!ScriptRuntime.toBoolean(result)) + return Boolean.FALSE; + break; + case Id_filter: + if (ScriptRuntime.toBoolean(result)) + setElem(cx, array, j++, innerArgs[0]); + break; + case Id_forEach: + break; + case Id_map: + setElem(cx, array, i, result); + break; + case Id_some: + if (ScriptRuntime.toBoolean(result)) + return Boolean.TRUE; + break; + } + } + switch (id) { + case Id_every: + return Boolean.TRUE; + case Id_filter: + case Id_map: + return array; + case Id_some: + return Boolean.FALSE; + case Id_forEach: + default: + return Undefined.instance; + } + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2005-09-26 15:47:42 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 3: c=s.charAt(0); + if (c=='m') { if (s.charAt(2)=='p' && s.charAt(1)=='a') {id=Id_map; break L0;} } + else if (c=='p') { if (s.charAt(2)=='p' && s.charAt(1)=='o') {id=Id_pop; break L0;} } + break L; + case 4: switch (s.charAt(2)) { + case 'i': X="join";id=Id_join; break L; + case 'm': X="some";id=Id_some; break L; + case 'r': X="sort";id=Id_sort; break L; + case 's': X="push";id=Id_push; break L; + } break L; + case 5: c=s.charAt(1); + if (c=='h') { X="shift";id=Id_shift; } + else if (c=='l') { X="slice";id=Id_slice; } + else if (c=='v') { X="every";id=Id_every; } + break L; + case 6: c=s.charAt(0); + if (c=='c') { X="concat";id=Id_concat; } + else if (c=='f') { X="filter";id=Id_filter; } + else if (c=='s') { X="splice";id=Id_splice; } + break L; + case 7: switch (s.charAt(0)) { + case 'f': X="forEach";id=Id_forEach; break L; + case 'i': X="indexOf";id=Id_indexOf; break L; + case 'r': X="reverse";id=Id_reverse; break L; + case 'u': X="unshift";id=Id_unshift; break L; + } break L; + case 8: c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + break L; + case 11: c=s.charAt(0); + if (c=='c') { X="constructor";id=Id_constructor; } + else if (c=='l') { X="lastIndexOf";id=Id_lastIndexOf; } + break L; + case 14: X="toLocaleString";id=Id_toLocaleString; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_toLocaleString = 3, + Id_toSource = 4, + Id_join = 5, + Id_reverse = 6, + Id_sort = 7, + Id_push = 8, + Id_pop = 9, + Id_shift = 10, + Id_unshift = 11, + Id_splice = 12, + Id_concat = 13, + Id_slice = 14, + Id_indexOf = 15, + Id_lastIndexOf = 16, + Id_every = 17, + Id_filter = 18, + Id_forEach = 19, + Id_map = 20, + Id_some = 21, + + MAX_PROTOTYPE_ID = 21; + +// #/string_id_map# + + private static final int + ConstructorId_join = -Id_join, + ConstructorId_reverse = -Id_reverse, + ConstructorId_sort = -Id_sort, + ConstructorId_push = -Id_push, + ConstructorId_pop = -Id_pop, + ConstructorId_shift = -Id_shift, + ConstructorId_unshift = -Id_unshift, + ConstructorId_splice = -Id_splice, + ConstructorId_concat = -Id_concat, + ConstructorId_slice = -Id_slice, + ConstructorId_indexOf = -Id_indexOf, + ConstructorId_lastIndexOf = -Id_lastIndexOf, + ConstructorId_every = -Id_every, + ConstructorId_filter = -Id_filter, + ConstructorId_forEach = -Id_forEach, + ConstructorId_map = -Id_map, + ConstructorId_some = -Id_some; + + /** + * Internal representation of the JavaScript array's length property. + */ + private long length; + + /** + * Fast storage for dense arrays. Sparse arrays will use the superclass's + * hashtable storage scheme. + */ + private Object[] dense; + + /** + * True if all numeric properties are stored in <code>dense</code>. + */ + private boolean denseOnly; + + /** + * The maximum size of <code>dense</code> that will be allocated initially. + */ + private static int maximumInitialCapacity = 10000; + + /** + * The default capacity for <code>dense</code>. + */ + private static final int DEFAULT_INITIAL_CAPACITY = 10; + + /** + * The factor to grow <code>dense</code> by. + */ + private static final double GROW_FACTOR = 1.5; + private static final int MAX_PRE_GROW_SIZE = (int)(Integer.MAX_VALUE / GROW_FACTOR); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeBoolean.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeBoolean.java new file mode 100644 index 0000000..b6a106a --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeBoolean.java @@ -0,0 +1,170 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the Boolean native object. + * See ECMA 15.6. + * @author Norris Boyd + */ +final class NativeBoolean extends IdScriptableObject +{ + static final long serialVersionUID = -3716996899943880933L; + + private static final Object BOOLEAN_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeBoolean obj = new NativeBoolean(false); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + private NativeBoolean(boolean b) + { + booleanValue = b; + } + + public String getClassName() + { + return "Boolean"; + } + + public Object getDefaultValue(Class typeHint) { + // This is actually non-ECMA, but will be proposed + // as a change in round 2. + if (typeHint == ScriptRuntime.BooleanClass) + return ScriptRuntime.wrapBoolean(booleanValue); + return super.getDefaultValue(typeHint); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id_valueOf: arity=0; s="valueOf"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(BOOLEAN_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(BOOLEAN_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + + if (id == Id_constructor) { + boolean b; + if (args.length == 0) { + b = false; + } else { + b = args[0] instanceof ScriptableObject && + ((ScriptableObject) args[0]).avoidObjectDetection() + ? true + : ScriptRuntime.toBoolean(args[0]); + } + if (thisObj == null) { + // new Boolean(val) creates a new boolean object. + return new NativeBoolean(b); + } + // Boolean(val) converts val to a boolean. + return ScriptRuntime.wrapBoolean(b); + } + + // The rest of Boolean.prototype methods require thisObj to be Boolean + + if (!(thisObj instanceof NativeBoolean)) + throw incompatibleCallError(f); + boolean value = ((NativeBoolean)thisObj).booleanValue; + + switch (id) { + + case Id_toString: + return value ? "true" : "false"; + + case Id_toSource: + return value ? "(new Boolean(true))" : "(new Boolean(false))"; + + case Id_valueOf: + return ScriptRuntime.wrapBoolean(value); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:31 EDT + L0: { id = 0; String X = null; int c; + int s_length = s.length(); + if (s_length==7) { X="valueOf";id=Id_valueOf; } + else if (s_length==8) { + c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + } + else if (s_length==11) { X="constructor";id=Id_constructor; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_toSource = 3, + Id_valueOf = 4, + MAX_PROTOTYPE_ID = 4; + +// #/string_id_map# + + private boolean booleanValue; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeCall.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeCall.java new file mode 100644 index 0000000..b196ac3 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeCall.java @@ -0,0 +1,154 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Bob Jervis + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the activation object. + * + * See ECMA 10.1.6 + * + * @see org.mozilla.javascript.Arguments + * @author Norris Boyd + */ +public final class NativeCall extends IdScriptableObject +{ + static final long serialVersionUID = -7471457301304454454L; + + private static final Object CALL_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeCall obj = new NativeCall(); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + NativeCall() { } + + NativeCall(NativeFunction function, Scriptable scope, Object[] args) + { + this.function = function; + + setParentScope(scope); + // leave prototype null + + this.originalArgs = (args == null) ? ScriptRuntime.emptyArgs : args; + + // initialize values of arguments + int paramAndVarCount = function.getParamAndVarCount(); + int paramCount = function.getParamCount(); + if (paramAndVarCount != 0) { + for (int i = 0; i < paramCount; ++i) { + String name = function.getParamOrVarName(i); + Object val = i < args.length ? args[i] + : Undefined.instance; + defineProperty(name, val, PERMANENT); + } + } + + // initialize "arguments" property but only if it was not overridden by + // the parameter with the same name + if (!super.has("arguments", this)) { + defineProperty("arguments", new Arguments(this), PERMANENT); + } + + if (paramAndVarCount != 0) { + for (int i = paramCount; i < paramAndVarCount; ++i) { + String name = function.getParamOrVarName(i); + if (!super.has(name, this)) { + if (function.getParamOrVarConst(i)) + defineProperty(name, Undefined.instance, CONST); + else + defineProperty(name, Undefined.instance, PERMANENT); + } + } + } + } + + public String getClassName() + { + return "Call"; + } + + protected int findPrototypeId(String s) + { + return s.equals("constructor") ? Id_constructor : 0; + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + if (id == Id_constructor) { + arity=1; s="constructor"; + } else { + throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(CALL_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(CALL_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + if (id == Id_constructor) { + if (thisObj != null) { + throw Context.reportRuntimeError1("msg.only.from.new", "Call"); + } + ScriptRuntime.checkDeprecated(cx, "Call"); + NativeCall result = new NativeCall(); + result.setPrototype(getObjectPrototype(scope)); + return result; + } + throw new IllegalArgumentException(String.valueOf(id)); + } + + private static final int + Id_constructor = 1, + MAX_PROTOTYPE_ID = 1; + + NativeFunction function; + Object[] originalArgs; + + transient NativeCall parentActivationCall; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeDate.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeDate.java new file mode 100644 index 0000000..75d41ab --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeDate.java @@ -0,0 +1,1604 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Peter Annema + * Norris Boyd + * Mike McCabe + * Ilya Frank + * + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.Date; +import java.text.DateFormat; + +/** + * This class implements the Date native object. + * See ECMA 15.9. + * @author Mike McCabe + */ +final class NativeDate extends IdScriptableObject +{ + static final long serialVersionUID = -8307438915861678966L; + + private static final Object DATE_TAG = new Object(); + + private static final String js_NaN_date_str = "Invalid Date"; + + static void init(Scriptable scope, boolean sealed) + { + NativeDate obj = new NativeDate(); + // Set the value of the prototype Date to NaN ('invalid date'); + obj.date = ScriptRuntime.NaN; + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + private NativeDate() + { + if (thisTimeZone == null) { + // j.u.TimeZone is synchronized, so setting class statics from it + // should be OK. + thisTimeZone = java.util.TimeZone.getDefault(); + LocalTZA = thisTimeZone.getRawOffset(); + } + } + + public String getClassName() + { + return "Date"; + } + + public Object getDefaultValue(Class typeHint) + { + if (typeHint == null) + typeHint = ScriptRuntime.StringClass; + return super.getDefaultValue(typeHint); + } + + double getJSTimeValue() + { + return date; + } + + protected void fillConstructorProperties(IdFunctionObject ctor) + { + addIdFunctionProperty(ctor, DATE_TAG, ConstructorId_now, + "now", 0); + addIdFunctionProperty(ctor, DATE_TAG, ConstructorId_parse, + "parse", 1); + addIdFunctionProperty(ctor, DATE_TAG, ConstructorId_UTC, + "UTC", 1); + super.fillConstructorProperties(ctor); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toTimeString: arity=0; s="toTimeString"; break; + case Id_toDateString: arity=0; s="toDateString"; break; + case Id_toLocaleString: arity=0; s="toLocaleString"; break; + case Id_toLocaleTimeString: arity=0; s="toLocaleTimeString"; break; + case Id_toLocaleDateString: arity=0; s="toLocaleDateString"; break; + case Id_toUTCString: arity=0; s="toUTCString"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id_valueOf: arity=0; s="valueOf"; break; + case Id_getTime: arity=0; s="getTime"; break; + case Id_getYear: arity=0; s="getYear"; break; + case Id_getFullYear: arity=0; s="getFullYear"; break; + case Id_getUTCFullYear: arity=0; s="getUTCFullYear"; break; + case Id_getMonth: arity=0; s="getMonth"; break; + case Id_getUTCMonth: arity=0; s="getUTCMonth"; break; + case Id_getDate: arity=0; s="getDate"; break; + case Id_getUTCDate: arity=0; s="getUTCDate"; break; + case Id_getDay: arity=0; s="getDay"; break; + case Id_getUTCDay: arity=0; s="getUTCDay"; break; + case Id_getHours: arity=0; s="getHours"; break; + case Id_getUTCHours: arity=0; s="getUTCHours"; break; + case Id_getMinutes: arity=0; s="getMinutes"; break; + case Id_getUTCMinutes: arity=0; s="getUTCMinutes"; break; + case Id_getSeconds: arity=0; s="getSeconds"; break; + case Id_getUTCSeconds: arity=0; s="getUTCSeconds"; break; + case Id_getMilliseconds: arity=0; s="getMilliseconds"; break; + case Id_getUTCMilliseconds: arity=0; s="getUTCMilliseconds"; break; + case Id_getTimezoneOffset: arity=0; s="getTimezoneOffset"; break; + case Id_setTime: arity=1; s="setTime"; break; + case Id_setMilliseconds: arity=1; s="setMilliseconds"; break; + case Id_setUTCMilliseconds: arity=1; s="setUTCMilliseconds"; break; + case Id_setSeconds: arity=2; s="setSeconds"; break; + case Id_setUTCSeconds: arity=2; s="setUTCSeconds"; break; + case Id_setMinutes: arity=3; s="setMinutes"; break; + case Id_setUTCMinutes: arity=3; s="setUTCMinutes"; break; + case Id_setHours: arity=4; s="setHours"; break; + case Id_setUTCHours: arity=4; s="setUTCHours"; break; + case Id_setDate: arity=1; s="setDate"; break; + case Id_setUTCDate: arity=1; s="setUTCDate"; break; + case Id_setMonth: arity=2; s="setMonth"; break; + case Id_setUTCMonth: arity=2; s="setUTCMonth"; break; + case Id_setFullYear: arity=3; s="setFullYear"; break; + case Id_setUTCFullYear: arity=3; s="setUTCFullYear"; break; + case Id_setYear: arity=1; s="setYear"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(DATE_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(DATE_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case ConstructorId_now: + return ScriptRuntime.wrapNumber(now()); + + case ConstructorId_parse: + { + String dataStr = ScriptRuntime.toString(args, 0); + return ScriptRuntime.wrapNumber(date_parseString(dataStr)); + } + + case ConstructorId_UTC: + return ScriptRuntime.wrapNumber(jsStaticFunction_UTC(args)); + + case Id_constructor: + { + // if called as a function, just return a string + // representing the current time. + if (thisObj != null) + return date_format(now(), Id_toString); + return jsConstructor(args); + } + } + + // The rest of Date.prototype methods require thisObj to be Date + + if (!(thisObj instanceof NativeDate)) + throw incompatibleCallError(f); + NativeDate realThis = (NativeDate)thisObj; + double t = realThis.date; + + switch (id) { + + case Id_toString: + case Id_toTimeString: + case Id_toDateString: + if (t == t) { + return date_format(t, id); + } + return js_NaN_date_str; + + case Id_toLocaleString: + case Id_toLocaleTimeString: + case Id_toLocaleDateString: + if (t == t) { + return toLocale_helper(t, id); + } + return js_NaN_date_str; + + case Id_toUTCString: + if (t == t) { + return js_toUTCString(t); + } + return js_NaN_date_str; + + case Id_toSource: + return "(new Date("+ScriptRuntime.toString(t)+"))"; + + case Id_valueOf: + case Id_getTime: + return ScriptRuntime.wrapNumber(t); + + case Id_getYear: + case Id_getFullYear: + case Id_getUTCFullYear: + if (t == t) { + if (id != Id_getUTCFullYear) t = LocalTime(t); + t = YearFromTime(t); + if (id == Id_getYear) { + if (cx.hasFeature(Context.FEATURE_NON_ECMA_GET_YEAR)) { + if (1900 <= t && t < 2000) { + t -= 1900; + } + } else { + t -= 1900; + } + } + } + return ScriptRuntime.wrapNumber(t); + + case Id_getMonth: + case Id_getUTCMonth: + if (t == t) { + if (id == Id_getMonth) t = LocalTime(t); + t = MonthFromTime(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getDate: + case Id_getUTCDate: + if (t == t) { + if (id == Id_getDate) t = LocalTime(t); + t = DateFromTime(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getDay: + case Id_getUTCDay: + if (t == t) { + if (id == Id_getDay) t = LocalTime(t); + t = WeekDay(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getHours: + case Id_getUTCHours: + if (t == t) { + if (id == Id_getHours) t = LocalTime(t); + t = HourFromTime(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getMinutes: + case Id_getUTCMinutes: + if (t == t) { + if (id == Id_getMinutes) t = LocalTime(t); + t = MinFromTime(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getSeconds: + case Id_getUTCSeconds: + if (t == t) { + if (id == Id_getSeconds) t = LocalTime(t); + t = SecFromTime(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getMilliseconds: + case Id_getUTCMilliseconds: + if (t == t) { + if (id == Id_getMilliseconds) t = LocalTime(t); + t = msFromTime(t); + } + return ScriptRuntime.wrapNumber(t); + + case Id_getTimezoneOffset: + if (t == t) { + t = (t - LocalTime(t)) / msPerMinute; + } + return ScriptRuntime.wrapNumber(t); + + case Id_setTime: + t = TimeClip(ScriptRuntime.toNumber(args, 0)); + realThis.date = t; + return ScriptRuntime.wrapNumber(t); + + case Id_setMilliseconds: + case Id_setUTCMilliseconds: + case Id_setSeconds: + case Id_setUTCSeconds: + case Id_setMinutes: + case Id_setUTCMinutes: + case Id_setHours: + case Id_setUTCHours: + t = makeTime(t, args, id); + realThis.date = t; + return ScriptRuntime.wrapNumber(t); + + case Id_setDate: + case Id_setUTCDate: + case Id_setMonth: + case Id_setUTCMonth: + case Id_setFullYear: + case Id_setUTCFullYear: + t = makeDate(t, args, id); + realThis.date = t; + return ScriptRuntime.wrapNumber(t); + + case Id_setYear: + { + double year = ScriptRuntime.toNumber(args, 0); + + if (year != year || Double.isInfinite(year)) { + t = ScriptRuntime.NaN; + } else { + if (t != t) { + t = 0; + } else { + t = LocalTime(t); + } + + if (year >= 0 && year <= 99) + year += 1900; + + double day = MakeDay(year, MonthFromTime(t), + DateFromTime(t)); + t = MakeDate(day, TimeWithinDay(t)); + t = internalUTC(t); + t = TimeClip(t); + } + } + realThis.date = t; + return ScriptRuntime.wrapNumber(t); + + default: throw new IllegalArgumentException(String.valueOf(id)); + } + + } + + /* ECMA helper functions */ + + private static final double HalfTimeDomain = 8.64e15; + private static final double HoursPerDay = 24.0; + private static final double MinutesPerHour = 60.0; + private static final double SecondsPerMinute = 60.0; + private static final double msPerSecond = 1000.0; + private static final double MinutesPerDay = (HoursPerDay * MinutesPerHour); + private static final double SecondsPerDay = (MinutesPerDay * SecondsPerMinute); + private static final double SecondsPerHour = (MinutesPerHour * SecondsPerMinute); + private static final double msPerDay = (SecondsPerDay * msPerSecond); + private static final double msPerHour = (SecondsPerHour * msPerSecond); + private static final double msPerMinute = (SecondsPerMinute * msPerSecond); + + private static double Day(double t) + { + return Math.floor(t / msPerDay); + } + + private static double TimeWithinDay(double t) + { + double result; + result = t % msPerDay; + if (result < 0) + result += msPerDay; + return result; + } + + private static boolean IsLeapYear(int year) + { + return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0); + } + + /* math here has to be f.p, because we need + * floor((1968 - 1969) / 4) == -1 + */ + private static double DayFromYear(double y) + { + return ((365 * ((y)-1970) + Math.floor(((y)-1969)/4.0) + - Math.floor(((y)-1901)/100.0) + Math.floor(((y)-1601)/400.0))); + } + + private static double TimeFromYear(double y) + { + return DayFromYear(y) * msPerDay; + } + + private static int YearFromTime(double t) + { + int lo = (int) Math.floor((t / msPerDay) / 366) + 1970; + int hi = (int) Math.floor((t / msPerDay) / 365) + 1970; + int mid; + + /* above doesn't work for negative dates... */ + if (hi < lo) { + int temp = lo; + lo = hi; + hi = temp; + } + + /* Use a simple binary search algorithm to find the right + year. This seems like brute force... but the computation + of hi and lo years above lands within one year of the + correct answer for years within a thousand years of + 1970; the loop below only requires six iterations + for year 270000. */ + while (hi > lo) { + mid = (hi + lo) / 2; + if (TimeFromYear(mid) > t) { + hi = mid - 1; + } else { + lo = mid + 1; + if (TimeFromYear(lo) > t) { + return mid; + } + } + } + return lo; + } + + private static double DayFromMonth(int m, int year) + { + int day = m * 30; + + if (m >= 7) { day += m / 2 - 1; } + else if (m >= 2) { day += (m - 1) / 2 - 1; } + else { day += m; } + + if (m >= 2 && IsLeapYear(year)) { ++day; } + + return day; + } + + private static int MonthFromTime(double t) + { + int year = YearFromTime(t); + int d = (int)(Day(t) - DayFromYear(year)); + + d -= 31 + 28; + if (d < 0) { + return (d < -28) ? 0 : 1; + } + + if (IsLeapYear(year)) { + if (d == 0) + return 1; // 29 February + --d; + } + + // d: date count from 1 March + int estimate = d / 30; // approx number of month since March + int mstart; + switch (estimate) { + case 0: return 2; + case 1: mstart = 31; break; + case 2: mstart = 31+30; break; + case 3: mstart = 31+30+31; break; + case 4: mstart = 31+30+31+30; break; + case 5: mstart = 31+30+31+30+31; break; + case 6: mstart = 31+30+31+30+31+31; break; + case 7: mstart = 31+30+31+30+31+31+30; break; + case 8: mstart = 31+30+31+30+31+31+30+31; break; + case 9: mstart = 31+30+31+30+31+31+30+31+30; break; + case 10: return 11; //Late december + default: throw Kit.codeBug(); + } + // if d < mstart then real month since March == estimate - 1 + return (d >= mstart) ? estimate + 2 : estimate + 1; + } + + private static int DateFromTime(double t) + { + int year = YearFromTime(t); + int d = (int)(Day(t) - DayFromYear(year)); + + d -= 31 + 28; + if (d < 0) { + return (d < -28) ? d + 31 + 28 + 1 : d + 28 + 1; + } + + if (IsLeapYear(year)) { + if (d == 0) + return 29; // 29 February + --d; + } + + // d: date count from 1 March + int mdays, mstart; + switch (d / 30) { // approx number of month since March + case 0: return d + 1; + case 1: mdays = 31; mstart = 31; break; + case 2: mdays = 30; mstart = 31+30; break; + case 3: mdays = 31; mstart = 31+30+31; break; + case 4: mdays = 30; mstart = 31+30+31+30; break; + case 5: mdays = 31; mstart = 31+30+31+30+31; break; + case 6: mdays = 31; mstart = 31+30+31+30+31+31; break; + case 7: mdays = 30; mstart = 31+30+31+30+31+31+30; break; + case 8: mdays = 31; mstart = 31+30+31+30+31+31+30+31; break; + case 9: mdays = 30; mstart = 31+30+31+30+31+31+30+31+30; break; + case 10: + return d - (31+30+31+30+31+31+30+31+30) + 1; //Late december + default: throw Kit.codeBug(); + } + d -= mstart; + if (d < 0) { + // wrong estimate: sfhift to previous month + d += mdays; + } + return d + 1; + } + + private static int WeekDay(double t) + { + double result; + result = Day(t) + 4; + result = result % 7; + if (result < 0) + result += 7; + return (int) result; + } + + private static double now() + { + return System.currentTimeMillis(); + } + + /* Should be possible to determine the need for this dynamically + * if we go with the workaround... I'm not using it now, because I + * can't think of any clean way to make toLocaleString() and the + * time zone (comment) in toString match the generated string + * values. Currently it's wrong-but-consistent in all but the + * most recent betas of the JRE - seems to work in 1.1.7. + */ + private final static boolean TZO_WORKAROUND = false; + private static double DaylightSavingTA(double t) + { + // Another workaround! The JRE doesn't seem to know about DST + // before year 1 AD, so we map to equivalent dates for the + // purposes of finding dst. To be safe, we do this for years + // outside 1970-2038. + if (t < 0.0 || t > 2145916800000.0) { + int year = EquivalentYear(YearFromTime(t)); + double day = MakeDay(year, MonthFromTime(t), DateFromTime(t)); + t = MakeDate(day, TimeWithinDay(t)); + } + if (!TZO_WORKAROUND) { + Date date = new Date((long) t); + if (thisTimeZone.inDaylightTime(date)) + return msPerHour; + else + return 0; + } else { + /* Use getOffset if inDaylightTime() is broken, because it + * seems to work acceptably. We don't switch over to it + * entirely, because it requires (expensive) exploded date arguments, + * and the api makes it impossible to handle dst + * changeovers cleanly. + */ + + // Hardcode the assumption that the changeover always + // happens at 2:00 AM: + t += LocalTZA + (HourFromTime(t) <= 2 ? msPerHour : 0); + + int year = YearFromTime(t); + double offset = thisTimeZone.getOffset(year > 0 ? 1 : 0, + year, + MonthFromTime(t), + DateFromTime(t), + WeekDay(t), + (int)TimeWithinDay(t)); + + if ((offset - LocalTZA) != 0) + return msPerHour; + else + return 0; + // return offset - LocalTZA; + } + } + + /* + * Find a year for which any given date will fall on the same weekday. + * + * This function should be used with caution when used other than + * for determining DST; it hasn't been proven not to produce an + * incorrect year for times near year boundaries. + */ + private static int EquivalentYear(int year) + { + int day = (int) DayFromYear(year) + 4; + day = day % 7; + if (day < 0) + day += 7; + // Years and leap years on which Jan 1 is a Sunday, Monday, etc. + if (IsLeapYear(year)) { + switch (day) { + case 0: return 1984; + case 1: return 1996; + case 2: return 1980; + case 3: return 1992; + case 4: return 1976; + case 5: return 1988; + case 6: return 1972; + } + } else { + switch (day) { + case 0: return 1978; + case 1: return 1973; + case 2: return 1974; + case 3: return 1975; + case 4: return 1981; + case 5: return 1971; + case 6: return 1977; + } + } + // Unreachable + throw Kit.codeBug(); + } + + private static double LocalTime(double t) + { + return t + LocalTZA + DaylightSavingTA(t); + } + + private static double internalUTC(double t) + { + return t - LocalTZA - DaylightSavingTA(t - LocalTZA); + } + + private static int HourFromTime(double t) + { + double result; + result = Math.floor(t / msPerHour) % HoursPerDay; + if (result < 0) + result += HoursPerDay; + return (int) result; + } + + private static int MinFromTime(double t) + { + double result; + result = Math.floor(t / msPerMinute) % MinutesPerHour; + if (result < 0) + result += MinutesPerHour; + return (int) result; + } + + private static int SecFromTime(double t) + { + double result; + result = Math.floor(t / msPerSecond) % SecondsPerMinute; + if (result < 0) + result += SecondsPerMinute; + return (int) result; + } + + private static int msFromTime(double t) + { + double result; + result = t % msPerSecond; + if (result < 0) + result += msPerSecond; + return (int) result; + } + + private static double MakeTime(double hour, double min, + double sec, double ms) + { + return ((hour * MinutesPerHour + min) * SecondsPerMinute + sec) + * msPerSecond + ms; + } + + private static double MakeDay(double year, double month, double date) + { + year += Math.floor(month / 12); + + month = month % 12; + if (month < 0) + month += 12; + + double yearday = Math.floor(TimeFromYear(year) / msPerDay); + double monthday = DayFromMonth((int)month, (int)year); + + return yearday + monthday + date - 1; + } + + private static double MakeDate(double day, double time) + { + return day * msPerDay + time; + } + + private static double TimeClip(double d) + { + if (d != d || + d == Double.POSITIVE_INFINITY || + d == Double.NEGATIVE_INFINITY || + Math.abs(d) > HalfTimeDomain) + { + return ScriptRuntime.NaN; + } + if (d > 0.0) + return Math.floor(d + 0.); + else + return Math.ceil(d + 0.); + } + + /* end of ECMA helper functions */ + + /* find UTC time from given date... no 1900 correction! */ + private static double date_msecFromDate(double year, double mon, + double mday, double hour, + double min, double sec, + double msec) + { + double day; + double time; + double result; + + day = MakeDay(year, mon, mday); + time = MakeTime(hour, min, sec, msec); + result = MakeDate(day, time); + return result; + } + + /* compute the time in msec (unclipped) from the given args */ + private static final int MAXARGS = 7; + private static double date_msecFromArgs(Object[] args) + { + double array[] = new double[MAXARGS]; + int loop; + double d; + + for (loop = 0; loop < MAXARGS; loop++) { + if (loop < args.length) { + d = ScriptRuntime.toNumber(args[loop]); + if (d != d || Double.isInfinite(d)) { + return ScriptRuntime.NaN; + } + array[loop] = ScriptRuntime.toInteger(args[loop]); + } else { + if (loop == 2) { + array[loop] = 1; /* Default the date argument to 1. */ + } else { + array[loop] = 0; + } + } + } + + /* adjust 2-digit years into the 20th century */ + if (array[0] >= 0 && array[0] <= 99) + array[0] += 1900; + + return date_msecFromDate(array[0], array[1], array[2], + array[3], array[4], array[5], array[6]); + } + + private static double jsStaticFunction_UTC(Object[] args) + { + return TimeClip(date_msecFromArgs(args)); + } + + private static double date_parseString(String s) + { + int year = -1; + int mon = -1; + int mday = -1; + int hour = -1; + int min = -1; + int sec = -1; + char c = 0; + char si = 0; + int i = 0; + int n = -1; + double tzoffset = -1; + char prevc = 0; + int limit = 0; + boolean seenplusminus = false; + + limit = s.length(); + while (i < limit) { + c = s.charAt(i); + i++; + if (c <= ' ' || c == ',' || c == '-') { + if (i < limit) { + si = s.charAt(i); + if (c == '-' && '0' <= si && si <= '9') { + prevc = c; + } + } + continue; + } + if (c == '(') { /* comments) */ + int depth = 1; + while (i < limit) { + c = s.charAt(i); + i++; + if (c == '(') + depth++; + else if (c == ')') + if (--depth <= 0) + break; + } + continue; + } + if ('0' <= c && c <= '9') { + n = c - '0'; + while (i < limit && '0' <= (c = s.charAt(i)) && c <= '9') { + n = n * 10 + c - '0'; + i++; + } + + /* allow TZA before the year, so + * 'Wed Nov 05 21:49:11 GMT-0800 1997' + * works */ + + /* uses of seenplusminus allow : in TZA, so Java + * no-timezone style of GMT+4:30 works + */ + if ((prevc == '+' || prevc == '-')/* && year>=0 */) { + /* make ':' case below change tzoffset */ + seenplusminus = true; + + /* offset */ + if (n < 24) + n = n * 60; /* EG. "GMT-3" */ + else + n = n % 100 + n / 100 * 60; /* eg "GMT-0430" */ + if (prevc == '+') /* plus means east of GMT */ + n = -n; + if (tzoffset != 0 && tzoffset != -1) + return ScriptRuntime.NaN; + tzoffset = n; + } else if (n >= 70 || + (prevc == '/' && mon >= 0 && mday >= 0 + && year < 0)) + { + if (year >= 0) + return ScriptRuntime.NaN; + else if (c <= ' ' || c == ',' || c == '/' || i >= limit) + year = n < 100 ? n + 1900 : n; + else + return ScriptRuntime.NaN; + } else if (c == ':') { + if (hour < 0) + hour = /*byte*/ n; + else if (min < 0) + min = /*byte*/ n; + else + return ScriptRuntime.NaN; + } else if (c == '/') { + if (mon < 0) + mon = /*byte*/ n-1; + else if (mday < 0) + mday = /*byte*/ n; + else + return ScriptRuntime.NaN; + } else if (i < limit && c != ',' && c > ' ' && c != '-') { + return ScriptRuntime.NaN; + } else if (seenplusminus && n < 60) { /* handle GMT-3:30 */ + if (tzoffset < 0) + tzoffset -= n; + else + tzoffset += n; + } else if (hour >= 0 && min < 0) { + min = /*byte*/ n; + } else if (min >= 0 && sec < 0) { + sec = /*byte*/ n; + } else if (mday < 0) { + mday = /*byte*/ n; + } else { + return ScriptRuntime.NaN; + } + prevc = 0; + } else if (c == '/' || c == ':' || c == '+' || c == '-') { + prevc = c; + } else { + int st = i - 1; + while (i < limit) { + c = s.charAt(i); + if (!(('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z'))) + break; + i++; + } + int letterCount = i - st; + if (letterCount < 2) + return ScriptRuntime.NaN; + /* + * Use ported code from jsdate.c rather than the locale-specific + * date-parsing code from Java, to keep js and rhino consistent. + * Is this the right strategy? + */ + String wtb = "am;pm;" + +"monday;tuesday;wednesday;thursday;friday;" + +"saturday;sunday;" + +"january;february;march;april;may;june;" + +"july;august;september;october;november;december;" + +"gmt;ut;utc;est;edt;cst;cdt;mst;mdt;pst;pdt;"; + int index = 0; + for (int wtbOffset = 0; ;) { + int wtbNext = wtb.indexOf(';', wtbOffset); + if (wtbNext < 0) + return ScriptRuntime.NaN; + if (wtb.regionMatches(true, wtbOffset, s, st, letterCount)) + break; + wtbOffset = wtbNext + 1; + ++index; + } + if (index < 2) { + /* + * AM/PM. Count 12:30 AM as 00:30, 12:30 PM as + * 12:30, instead of blindly adding 12 if PM. + */ + if (hour > 12 || hour < 0) { + return ScriptRuntime.NaN; + } else if (index == 0) { + // AM + if (hour == 12) + hour = 0; + } else { + // PM + if (hour != 12) + hour += 12; + } + } else if ((index -= 2) < 7) { + // ignore week days + } else if ((index -= 7) < 12) { + // month + if (mon < 0) { + mon = index; + } else { + return ScriptRuntime.NaN; + } + } else { + index -= 12; + // timezones + switch (index) { + case 0 /* gmt */: tzoffset = 0; break; + case 1 /* ut */: tzoffset = 0; break; + case 2 /* utc */: tzoffset = 0; break; + case 3 /* est */: tzoffset = 5 * 60; break; + case 4 /* edt */: tzoffset = 4 * 60; break; + case 5 /* cst */: tzoffset = 6 * 60; break; + case 6 /* cdt */: tzoffset = 5 * 60; break; + case 7 /* mst */: tzoffset = 7 * 60; break; + case 8 /* mdt */: tzoffset = 6 * 60; break; + case 9 /* pst */: tzoffset = 8 * 60; break; + case 10 /* pdt */:tzoffset = 7 * 60; break; + default: Kit.codeBug(); + } + } + } + } + if (year < 0 || mon < 0 || mday < 0) + return ScriptRuntime.NaN; + if (sec < 0) + sec = 0; + if (min < 0) + min = 0; + if (hour < 0) + hour = 0; + + double msec = date_msecFromDate(year, mon, mday, hour, min, sec, 0); + if (tzoffset == -1) { /* no time zone specified, have to use local */ + return internalUTC(msec); + } else { + return msec + tzoffset * msPerMinute; + } + } + + private static String date_format(double t, int methodId) + { + StringBuffer result = new StringBuffer(60); + double local = LocalTime(t); + + /* Tue Oct 31 09:41:40 GMT-0800 (PST) 2000 */ + /* Tue Oct 31 2000 */ + /* 09:41:40 GMT-0800 (PST) */ + + if (methodId != Id_toTimeString) { + appendWeekDayName(result, WeekDay(local)); + result.append(' '); + appendMonthName(result, MonthFromTime(local)); + result.append(' '); + append0PaddedUint(result, DateFromTime(local), 2); + result.append(' '); + int year = YearFromTime(local); + if (year < 0) { + result.append('-'); + year = -year; + } + append0PaddedUint(result, year, 4); + if (methodId != Id_toDateString) + result.append(' '); + } + + if (methodId != Id_toDateString) { + append0PaddedUint(result, HourFromTime(local), 2); + result.append(':'); + append0PaddedUint(result, MinFromTime(local), 2); + result.append(':'); + append0PaddedUint(result, SecFromTime(local), 2); + + // offset from GMT in minutes. The offset includes daylight + // savings, if it applies. + int minutes = (int) Math.floor((LocalTZA + DaylightSavingTA(t)) + / msPerMinute); + // map 510 minutes to 0830 hours + int offset = (minutes / 60) * 100 + minutes % 60; + if (offset > 0) { + result.append(" GMT+"); + } else { + result.append(" GMT-"); + offset = -offset; + } + append0PaddedUint(result, offset, 4); + + if (timeZoneFormatter == null) + timeZoneFormatter = new java.text.SimpleDateFormat("zzz"); + + // Find an equivalent year before getting the timezone + // comment. See DaylightSavingTA. + if (t < 0.0 || t > 2145916800000.0) { + int equiv = EquivalentYear(YearFromTime(local)); + double day = MakeDay(equiv, MonthFromTime(t), DateFromTime(t)); + t = MakeDate(day, TimeWithinDay(t)); + } + result.append(" ("); + java.util.Date date = new Date((long) t); + synchronized (timeZoneFormatter) { + result.append(timeZoneFormatter.format(date)); + } + result.append(')'); + } + return result.toString(); + } + + /* the javascript constructor */ + private static Object jsConstructor(Object[] args) + { + NativeDate obj = new NativeDate(); + + // if called as a constructor with no args, + // return a new Date with the current time. + if (args.length == 0) { + obj.date = now(); + return obj; + } + + // if called with just one arg - + if (args.length == 1) { + Object arg0 = args[0]; + if (arg0 instanceof Scriptable) + arg0 = ((Scriptable) arg0).getDefaultValue(null); + double date; + if (arg0 instanceof String) { + // it's a string; parse it. + date = date_parseString((String)arg0); + } else { + // if it's not a string, use it as a millisecond date + date = ScriptRuntime.toNumber(arg0); + } + obj.date = TimeClip(date); + return obj; + } + + double time = date_msecFromArgs(args); + + if (!Double.isNaN(time) && !Double.isInfinite(time)) + time = TimeClip(internalUTC(time)); + + obj.date = time; + + return obj; + } + + private static String toLocale_helper(double t, int methodId) + { + java.text.DateFormat formatter; + switch (methodId) { + case Id_toLocaleString: + if (localeDateTimeFormatter == null) { + localeDateTimeFormatter + = DateFormat.getDateTimeInstance(DateFormat.LONG, + DateFormat.LONG); + } + formatter = localeDateTimeFormatter; + break; + case Id_toLocaleTimeString: + if (localeTimeFormatter == null) { + localeTimeFormatter + = DateFormat.getTimeInstance(DateFormat.LONG); + } + formatter = localeTimeFormatter; + break; + case Id_toLocaleDateString: + if (localeDateFormatter == null) { + localeDateFormatter + = DateFormat.getDateInstance(DateFormat.LONG); + } + formatter = localeDateFormatter; + break; + default: formatter = null; // unreachable + } + + synchronized (formatter) { + return formatter.format(new Date((long) t)); + } + } + + private static String js_toUTCString(double date) + { + StringBuffer result = new StringBuffer(60); + + appendWeekDayName(result, WeekDay(date)); + result.append(", "); + append0PaddedUint(result, DateFromTime(date), 2); + result.append(' '); + appendMonthName(result, MonthFromTime(date)); + result.append(' '); + int year = YearFromTime(date); + if (year < 0) { + result.append('-'); year = -year; + } + append0PaddedUint(result, year, 4); + result.append(' '); + append0PaddedUint(result, HourFromTime(date), 2); + result.append(':'); + append0PaddedUint(result, MinFromTime(date), 2); + result.append(':'); + append0PaddedUint(result, SecFromTime(date), 2); + result.append(" GMT"); + return result.toString(); + } + + private static void append0PaddedUint(StringBuffer sb, int i, int minWidth) + { + if (i < 0) Kit.codeBug(); + int scale = 1; + --minWidth; + if (i >= 10) { + if (i < 1000 * 1000 * 1000) { + for (;;) { + int newScale = scale * 10; + if (i < newScale) { break; } + --minWidth; + scale = newScale; + } + } else { + // Separated case not to check against 10 * 10^9 overflow + minWidth -= 9; + scale = 1000 * 1000 * 1000; + } + } + while (minWidth > 0) { + sb.append('0'); + --minWidth; + } + while (scale != 1) { + sb.append((char)('0' + (i / scale))); + i %= scale; + scale /= 10; + } + sb.append((char)('0' + i)); + } + + private static void appendMonthName(StringBuffer sb, int index) + { + // Take advantage of the fact that all month abbreviations + // have the same length to minimize amount of strings runtime has + // to keep in memory + String months = "Jan"+"Feb"+"Mar"+"Apr"+"May"+"Jun" + +"Jul"+"Aug"+"Sep"+"Oct"+"Nov"+"Dec"; + index *= 3; + for (int i = 0; i != 3; ++i) { + sb.append(months.charAt(index + i)); + } + } + + private static void appendWeekDayName(StringBuffer sb, int index) + { + String days = "Sun"+"Mon"+"Tue"+"Wed"+"Thu"+"Fri"+"Sat"; + index *= 3; + for (int i = 0; i != 3; ++i) { + sb.append(days.charAt(index + i)); + } + } + + private static double makeTime(double date, Object[] args, int methodId) + { + int maxargs; + boolean local = true; + switch (methodId) { + case Id_setUTCMilliseconds: + local = false; + // fallthrough + case Id_setMilliseconds: + maxargs = 1; + break; + + case Id_setUTCSeconds: + local = false; + // fallthrough + case Id_setSeconds: + maxargs = 2; + break; + + case Id_setUTCMinutes: + local = false; + // fallthrough + case Id_setMinutes: + maxargs = 3; + break; + + case Id_setUTCHours: + local = false; + // fallthrough + case Id_setHours: + maxargs = 4; + break; + + default: + Kit.codeBug(); + maxargs = 0; + } + + int i; + double conv[] = new double[4]; + double hour, min, sec, msec; + double lorutime; /* Local or UTC version of date */ + + double time; + double result; + + /* just return NaN if the date is already NaN */ + if (date != date) + return date; + + /* Satisfy the ECMA rule that if a function is called with + * fewer arguments than the specified formal arguments, the + * remaining arguments are set to undefined. Seems like all + * the Date.setWhatever functions in ECMA are only varargs + * beyond the first argument; this should be set to undefined + * if it's not given. This means that "d = new Date(); + * d.setMilliseconds()" returns NaN. Blech. + */ + if (args.length == 0) + args = ScriptRuntime.padArguments(args, 1); + + for (i = 0; i < args.length && i < maxargs; i++) { + conv[i] = ScriptRuntime.toNumber(args[i]); + + // limit checks that happen in MakeTime in ECMA. + if (conv[i] != conv[i] || Double.isInfinite(conv[i])) { + return ScriptRuntime.NaN; + } + conv[i] = ScriptRuntime.toInteger(conv[i]); + } + + if (local) + lorutime = LocalTime(date); + else + lorutime = date; + + i = 0; + int stop = args.length; + + if (maxargs >= 4 && i < stop) + hour = conv[i++]; + else + hour = HourFromTime(lorutime); + + if (maxargs >= 3 && i < stop) + min = conv[i++]; + else + min = MinFromTime(lorutime); + + if (maxargs >= 2 && i < stop) + sec = conv[i++]; + else + sec = SecFromTime(lorutime); + + if (maxargs >= 1 && i < stop) + msec = conv[i++]; + else + msec = msFromTime(lorutime); + + time = MakeTime(hour, min, sec, msec); + result = MakeDate(Day(lorutime), time); + + if (local) + result = internalUTC(result); + date = TimeClip(result); + + return date; + } + + private static double makeDate(double date, Object[] args, int methodId) + { + int maxargs; + boolean local = true; + switch (methodId) { + case Id_setUTCDate: + local = false; + // fallthrough + case Id_setDate: + maxargs = 1; + break; + + case Id_setUTCMonth: + local = false; + // fallthrough + case Id_setMonth: + maxargs = 2; + break; + + case Id_setUTCFullYear: + local = false; + // fallthrough + case Id_setFullYear: + maxargs = 3; + break; + + default: + Kit.codeBug(); + maxargs = 0; + } + + int i; + double conv[] = new double[3]; + double year, month, day; + double lorutime; /* local or UTC version of date */ + double result; + + /* See arg padding comment in makeTime.*/ + if (args.length == 0) + args = ScriptRuntime.padArguments(args, 1); + + for (i = 0; i < args.length && i < maxargs; i++) { + conv[i] = ScriptRuntime.toNumber(args[i]); + + // limit checks that happen in MakeDate in ECMA. + if (conv[i] != conv[i] || Double.isInfinite(conv[i])) { + return ScriptRuntime.NaN; + } + conv[i] = ScriptRuntime.toInteger(conv[i]); + } + + /* return NaN if date is NaN and we're not setting the year, + * If we are, use 0 as the time. */ + if (date != date) { + if (args.length < 3) { + return ScriptRuntime.NaN; + } else { + lorutime = 0; + } + } else { + if (local) + lorutime = LocalTime(date); + else + lorutime = date; + } + + i = 0; + int stop = args.length; + + if (maxargs >= 3 && i < stop) + year = conv[i++]; + else + year = YearFromTime(lorutime); + + if (maxargs >= 2 && i < stop) + month = conv[i++]; + else + month = MonthFromTime(lorutime); + + if (maxargs >= 1 && i < stop) + day = conv[i++]; + else + day = DateFromTime(lorutime); + + day = MakeDay(year, month, day); /* day within year */ + result = MakeDate(day, TimeWithinDay(lorutime)); + + if (local) + result = internalUTC(result); + + date = TimeClip(result); + + return date; + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:38 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 6: X="getDay";id=Id_getDay; break L; + case 7: switch (s.charAt(3)) { + case 'D': c=s.charAt(0); + if (c=='g') { X="getDate";id=Id_getDate; } + else if (c=='s') { X="setDate";id=Id_setDate; } + break L; + case 'T': c=s.charAt(0); + if (c=='g') { X="getTime";id=Id_getTime; } + else if (c=='s') { X="setTime";id=Id_setTime; } + break L; + case 'Y': c=s.charAt(0); + if (c=='g') { X="getYear";id=Id_getYear; } + else if (c=='s') { X="setYear";id=Id_setYear; } + break L; + case 'u': X="valueOf";id=Id_valueOf; break L; + } break L; + case 8: switch (s.charAt(3)) { + case 'H': c=s.charAt(0); + if (c=='g') { X="getHours";id=Id_getHours; } + else if (c=='s') { X="setHours";id=Id_setHours; } + break L; + case 'M': c=s.charAt(0); + if (c=='g') { X="getMonth";id=Id_getMonth; } + else if (c=='s') { X="setMonth";id=Id_setMonth; } + break L; + case 'o': X="toSource";id=Id_toSource; break L; + case 't': X="toString";id=Id_toString; break L; + } break L; + case 9: X="getUTCDay";id=Id_getUTCDay; break L; + case 10: c=s.charAt(3); + if (c=='M') { + c=s.charAt(0); + if (c=='g') { X="getMinutes";id=Id_getMinutes; } + else if (c=='s') { X="setMinutes";id=Id_setMinutes; } + } + else if (c=='S') { + c=s.charAt(0); + if (c=='g') { X="getSeconds";id=Id_getSeconds; } + else if (c=='s') { X="setSeconds";id=Id_setSeconds; } + } + else if (c=='U') { + c=s.charAt(0); + if (c=='g') { X="getUTCDate";id=Id_getUTCDate; } + else if (c=='s') { X="setUTCDate";id=Id_setUTCDate; } + } + break L; + case 11: switch (s.charAt(3)) { + case 'F': c=s.charAt(0); + if (c=='g') { X="getFullYear";id=Id_getFullYear; } + else if (c=='s') { X="setFullYear";id=Id_setFullYear; } + break L; + case 'M': X="toGMTString";id=Id_toGMTString; break L; + case 'T': X="toUTCString";id=Id_toUTCString; break L; + case 'U': c=s.charAt(0); + if (c=='g') { + c=s.charAt(9); + if (c=='r') { X="getUTCHours";id=Id_getUTCHours; } + else if (c=='t') { X="getUTCMonth";id=Id_getUTCMonth; } + } + else if (c=='s') { + c=s.charAt(9); + if (c=='r') { X="setUTCHours";id=Id_setUTCHours; } + else if (c=='t') { X="setUTCMonth";id=Id_setUTCMonth; } + } + break L; + case 's': X="constructor";id=Id_constructor; break L; + } break L; + case 12: c=s.charAt(2); + if (c=='D') { X="toDateString";id=Id_toDateString; } + else if (c=='T') { X="toTimeString";id=Id_toTimeString; } + break L; + case 13: c=s.charAt(0); + if (c=='g') { + c=s.charAt(6); + if (c=='M') { X="getUTCMinutes";id=Id_getUTCMinutes; } + else if (c=='S') { X="getUTCSeconds";id=Id_getUTCSeconds; } + } + else if (c=='s') { + c=s.charAt(6); + if (c=='M') { X="setUTCMinutes";id=Id_setUTCMinutes; } + else if (c=='S') { X="setUTCSeconds";id=Id_setUTCSeconds; } + } + break L; + case 14: c=s.charAt(0); + if (c=='g') { X="getUTCFullYear";id=Id_getUTCFullYear; } + else if (c=='s') { X="setUTCFullYear";id=Id_setUTCFullYear; } + else if (c=='t') { X="toLocaleString";id=Id_toLocaleString; } + break L; + case 15: c=s.charAt(0); + if (c=='g') { X="getMilliseconds";id=Id_getMilliseconds; } + else if (c=='s') { X="setMilliseconds";id=Id_setMilliseconds; } + break L; + case 17: X="getTimezoneOffset";id=Id_getTimezoneOffset; break L; + case 18: c=s.charAt(0); + if (c=='g') { X="getUTCMilliseconds";id=Id_getUTCMilliseconds; } + else if (c=='s') { X="setUTCMilliseconds";id=Id_setUTCMilliseconds; } + else if (c=='t') { + c=s.charAt(8); + if (c=='D') { X="toLocaleDateString";id=Id_toLocaleDateString; } + else if (c=='T') { X="toLocaleTimeString";id=Id_toLocaleTimeString; } + } + break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + ConstructorId_now = -3, + ConstructorId_parse = -2, + ConstructorId_UTC = -1, + + Id_constructor = 1, + Id_toString = 2, + Id_toTimeString = 3, + Id_toDateString = 4, + Id_toLocaleString = 5, + Id_toLocaleTimeString = 6, + Id_toLocaleDateString = 7, + Id_toUTCString = 8, + Id_toSource = 9, + Id_valueOf = 10, + Id_getTime = 11, + Id_getYear = 12, + Id_getFullYear = 13, + Id_getUTCFullYear = 14, + Id_getMonth = 15, + Id_getUTCMonth = 16, + Id_getDate = 17, + Id_getUTCDate = 18, + Id_getDay = 19, + Id_getUTCDay = 20, + Id_getHours = 21, + Id_getUTCHours = 22, + Id_getMinutes = 23, + Id_getUTCMinutes = 24, + Id_getSeconds = 25, + Id_getUTCSeconds = 26, + Id_getMilliseconds = 27, + Id_getUTCMilliseconds = 28, + Id_getTimezoneOffset = 29, + Id_setTime = 30, + Id_setMilliseconds = 31, + Id_setUTCMilliseconds = 32, + Id_setSeconds = 33, + Id_setUTCSeconds = 34, + Id_setMinutes = 35, + Id_setUTCMinutes = 36, + Id_setHours = 37, + Id_setUTCHours = 38, + Id_setDate = 39, + Id_setUTCDate = 40, + Id_setMonth = 41, + Id_setUTCMonth = 42, + Id_setFullYear = 43, + Id_setUTCFullYear = 44, + Id_setYear = 45, + + MAX_PROTOTYPE_ID = 45; + + private static final int + Id_toGMTString = Id_toUTCString; // Alias, see Ecma B.2.6 +// #/string_id_map# + + /* cached values */ + private static java.util.TimeZone thisTimeZone; + private static double LocalTZA; + private static java.text.DateFormat timeZoneFormatter; + private static java.text.DateFormat localeDateTimeFormatter; + private static java.text.DateFormat localeDateFormatter; + private static java.text.DateFormat localeTimeFormatter; + + private double date; +} + + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeError.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeError.java new file mode 100644 index 0000000..4aff10c --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeError.java @@ -0,0 +1,227 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript; + +/** + * + * The class of error objects + * + * ECMA 15.11 + */ +final class NativeError extends IdScriptableObject +{ + static final long serialVersionUID = -5338413581437645187L; + + private static final Object ERROR_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeError obj = new NativeError(); + ScriptableObject.putProperty(obj, "name", "Error"); + ScriptableObject.putProperty(obj, "message", ""); + ScriptableObject.putProperty(obj, "fileName", ""); + ScriptableObject.putProperty(obj, "lineNumber", new Integer(0)); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + static NativeError make(Context cx, Scriptable scope, + IdFunctionObject ctorObj, Object[] args) + { + Scriptable proto = (Scriptable)(ctorObj.get("prototype", ctorObj)); + + NativeError obj = new NativeError(); + obj.setPrototype(proto); + obj.setParentScope(scope); + + int arglen = args.length; + if (arglen >= 1) { + ScriptableObject.putProperty(obj, "message", + ScriptRuntime.toString(args[0])); + if (arglen >= 2) { + ScriptableObject.putProperty(obj, "fileName", args[1]); + if (arglen >= 3) { + int line = ScriptRuntime.toInt32(args[2]); + ScriptableObject.putProperty(obj, "lineNumber", + new Integer(line)); + } + } + } + if(arglen < 3 && cx.hasFeature(Context.FEATURE_LOCATION_INFORMATION_IN_ERROR)) { + // Fill in fileName and lineNumber automatically when not specified + // explicitly, see Bugzilla issue #342807 + int[] linep = new int[1]; + String fileName = Context.getSourcePositionFromStack(linep); + ScriptableObject.putProperty(obj, "lineNumber", + new Integer(linep[0])); + if(arglen < 2) { + ScriptableObject.putProperty(obj, "fileName", fileName); + } + } + return obj; + } + + public String getClassName() + { + return "Error"; + } + + public String toString() + { + return js_toString(this); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toSource: arity=0; s="toSource"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(ERROR_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(ERROR_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_constructor: + return make(cx, scope, f, args); + + case Id_toString: + return js_toString(thisObj); + + case Id_toSource: + return js_toSource(cx, scope, thisObj); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + + private static String js_toString(Scriptable thisObj) + { + return getString(thisObj, "name")+": "+getString(thisObj, "message"); + } + + private static String js_toSource(Context cx, Scriptable scope, + Scriptable thisObj) + { + // Emulation of SpiderMonkey behavior + Object name = ScriptableObject.getProperty(thisObj, "name"); + Object message = ScriptableObject.getProperty(thisObj, "message"); + Object fileName = ScriptableObject.getProperty(thisObj, "fileName"); + Object lineNumber = ScriptableObject.getProperty(thisObj, "lineNumber"); + + StringBuffer sb = new StringBuffer(); + sb.append("(new "); + if (name == NOT_FOUND) { + name = Undefined.instance; + } + sb.append(ScriptRuntime.toString(name)); + sb.append("("); + if (message != NOT_FOUND + || fileName != NOT_FOUND + || lineNumber != NOT_FOUND) + { + if (message == NOT_FOUND) { + message = ""; + } + sb.append(ScriptRuntime.uneval(cx, scope, message)); + if (fileName != NOT_FOUND || lineNumber != NOT_FOUND) { + sb.append(", "); + if (fileName == NOT_FOUND) { + fileName = ""; + } + sb.append(ScriptRuntime.uneval(cx, scope, fileName)); + if (lineNumber != NOT_FOUND) { + int line = ScriptRuntime.toInt32(lineNumber); + if (line != 0) { + sb.append(", "); + sb.append(ScriptRuntime.toString(line)); + } + } + } + } + sb.append("))"); + return sb.toString(); + } + + private static String getString(Scriptable obj, String id) + { + Object value = ScriptableObject.getProperty(obj, id); + if (value == NOT_FOUND) return ""; + return ScriptRuntime.toString(value); + } + + protected int findPrototypeId(String s) + { + int id; +// #string_id_map# +// #generated# Last update: 2007-05-09 08:15:45 EDT + L0: { id = 0; String X = null; int c; + int s_length = s.length(); + if (s_length==8) { + c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + } + else if (s_length==11) { X="constructor";id=Id_constructor; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_toSource = 3, + + MAX_PROTOTYPE_ID = 3; + +// #/string_id_map# +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeFunction.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeFunction.java new file mode 100644 index 0000000..ac70556 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeFunction.java @@ -0,0 +1,169 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Bob Jervis + * Roger Lawrence + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import org.mozilla.javascript.debug.DebuggableScript; + +/** + * This class implements the Function native object. + * See ECMA 15.3. + * @author Norris Boyd + */ +public abstract class NativeFunction extends BaseFunction +{ + + public final void initScriptFunction(Context cx, Scriptable scope) + { + ScriptRuntime.setFunctionProtoAndParent(this, scope); + } + + /** + * @param indent How much to indent the decompiled result + * + * @param flags Flags specifying format of decompilation output + */ + final String decompile(int indent, int flags) + { + String encodedSource = getEncodedSource(); + if (encodedSource == null) { + return super.decompile(indent, flags); + } else { + UintMap properties = new UintMap(1); + properties.put(Decompiler.INITIAL_INDENT_PROP, indent); + return Decompiler.decompile(encodedSource, flags, properties); + } + } + + public int getLength() + { + int paramCount = getParamCount(); + if (getLanguageVersion() != Context.VERSION_1_2) { + return paramCount; + } + Context cx = Context.getContext(); + NativeCall activation = ScriptRuntime.findFunctionActivation(cx, this); + if (activation == null) { + return paramCount; + } + return activation.originalArgs.length; + } + + public int getArity() + { + return getParamCount(); + } + + /** + * @deprecated Use {@link BaseFunction#getFunctionName()} instead. + * For backwards compatibility keep an old method name used by + * Batik and possibly others. + */ + public String jsGet_name() + { + return getFunctionName(); + } + + /** + * Get encoded source string. + */ + public String getEncodedSource() + { + return null; + } + + public DebuggableScript getDebuggableView() + { + return null; + } + + /** + * Resume execution of a suspended generator. + * @param cx The current context + * @param scope Scope for the parent generator function + * @param operation The resumption operation (next, send, etc.. ) + * @param state The generator state (has locals, stack, etc.) + * @param value The return value of yield (if required). + * @return The next yielded value (if any) + */ + public Object resumeGenerator(Context cx, Scriptable scope, + int operation, Object state, Object value) + { + throw new EvaluatorException("resumeGenerator() not implemented"); + } + + + protected abstract int getLanguageVersion(); + + /** + * Get number of declared parameters. It should be 0 for scripts. + */ + protected abstract int getParamCount(); + + /** + * Get number of declared parameters and variables defined through var + * statements. + */ + protected abstract int getParamAndVarCount(); + + /** + * Get parameter or variable name. + * If <tt>index < {@link #getParamCount()}</tt>, then return the name of the + * corresponding parameter. Otherwise return the name of variable. + */ + protected abstract String getParamOrVarName(int index); + + /** + * Get parameter or variable const-ness. + * If <tt>index < {@link #getParamCount()}</tt>, then return the const-ness + * of the corresponding parameter. Otherwise return whether the variable is + * const. + */ + protected boolean getParamOrVarConst(int index) + { + // By default return false to preserve compatibility with existing + // classes subclassing this class, which are mostly generated by jsc + // from earlier Rhino versions. See Bugzilla #396117. + return false; + } +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeGenerator.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeGenerator.java new file mode 100644 index 0000000..0a8da9f --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeGenerator.java @@ -0,0 +1,281 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements generator objects. See + * http://developer.mozilla.org/en/docs/New_in_JavaScript_1.7#Generators + * + * @author Norris Boyd + */ +public final class NativeGenerator extends IdScriptableObject { + private static final Object GENERATOR_TAG = new Object(); + + static NativeGenerator init(ScriptableObject scope, boolean sealed) { + // Generator + // Can't use "NativeGenerator().exportAsJSClass" since we don't want + // to define "Generator" as a constructor in the top-level scope. + + NativeGenerator prototype = new NativeGenerator(); + if (scope != null) { + prototype.setParentScope(scope); + prototype.setPrototype(getObjectPrototype(scope)); + } + prototype.activatePrototypeMap(MAX_PROTOTYPE_ID); + if (sealed) { + prototype.sealObject(); + } + + // Need to access Generator prototype when constructing + // Generator instances, but don't have a generator constructor + // to use to find the prototype. Use the "associateValue" + // approach instead. + if (scope != null) { + scope.associateValue(GENERATOR_TAG, prototype); + } + + return prototype; + } + + /** + * Only for constructing the prototype object. + */ + private NativeGenerator() { } + + public NativeGenerator(Scriptable scope, NativeFunction function, + Object savedState) + { + this.function = function; + this.savedState = savedState; + // Set parent and prototype properties. Since we don't have a + // "Generator" constructor in the top scope, we stash the + // prototype in the top scope's associated value. + Scriptable top = ScriptableObject.getTopLevelScope(scope); + this.setParentScope(top); + NativeGenerator prototype = (NativeGenerator) + ScriptableObject.getTopScopeValue(top, GENERATOR_TAG); + this.setPrototype(prototype); + } + + public static final int GENERATOR_SEND = 0, + GENERATOR_THROW = 1, + GENERATOR_CLOSE = 2; + + public String getClassName() { + return "Generator"; + } + + /** + * Close the generator if it is still open. + */ + public void finalize() throws Throwable { + if (savedState != null) { + // This is a little tricky since we are most likely running in + // a different thread. We need to get a Context to run this, and + // we must call "doTopCall" since this will likely be the outermost + // JavaScript frame on this thread. + Context cx = Context.getCurrentContext(); + ContextFactory factory = cx != null ? cx.getFactory() + : ContextFactory.getGlobal(); + Scriptable scope = ScriptableObject.getTopLevelScope(this); + factory.call(new CloseGeneratorAction(this)); + } + } + + private static class CloseGeneratorAction implements ContextAction { + private NativeGenerator generator; + + CloseGeneratorAction(NativeGenerator generator) { + this.generator = generator; + } + + public Object run(Context cx) { + Scriptable scope = ScriptableObject.getTopLevelScope(generator); + Callable closeGenerator = new Callable() { + public Object call(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) { + return ((NativeGenerator)thisObj).resume(cx, scope, + GENERATOR_CLOSE, new GeneratorClosedException()); + } + }; + return ScriptRuntime.doTopCall(closeGenerator, cx, scope, + generator, null); + } + } + + protected void initPrototypeId(int id) { + String s; + int arity; + switch (id) { + case Id_close: arity=1; s="close"; break; + case Id_next: arity=1; s="next"; break; + case Id_send: arity=0; s="send"; break; + case Id_throw: arity=0; s="throw"; break; + case Id___iterator__: arity=1; s="__iterator__"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(GENERATOR_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(GENERATOR_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + + if (!(thisObj instanceof NativeGenerator)) + throw incompatibleCallError(f); + + NativeGenerator generator = (NativeGenerator) thisObj; + + switch (id) { + + case Id_close: + // need to run any pending finally clauses + return generator.resume(cx, scope, GENERATOR_CLOSE, + new GeneratorClosedException()); + + case Id_next: + // arguments to next() are ignored + generator.firstTime = false; + return generator.resume(cx, scope, GENERATOR_SEND, + Undefined.instance); + + case Id_send: { + Object arg = args.length > 0 ? args[0] : Undefined.instance; + if (generator.firstTime && !arg.equals(Undefined.instance)) { + throw ScriptRuntime.typeError0("msg.send.newborn"); + } + return generator.resume(cx, scope, GENERATOR_SEND, arg); + } + + case Id_throw: + return generator.resume(cx, scope, GENERATOR_THROW, + args.length > 0 ? args[0] : Undefined.instance); + + case Id___iterator__: + return thisObj; + + default: + throw new IllegalArgumentException(String.valueOf(id)); + } + } + + private Object resume(Context cx, Scriptable scope, int operation, + Object value) + { + if (savedState == null) { + if (operation == GENERATOR_CLOSE) + return Undefined.instance; + Object thrown; + if (operation == GENERATOR_THROW) { + thrown = value; + } else { + thrown = NativeIterator.getStopIterationObject(scope); + } + throw new JavaScriptException(thrown, lineSource, lineNumber); + } + try { + synchronized (this) { + // generator execution is necessarily single-threaded and + // non-reentrant. + // See https://bugzilla.mozilla.org/show_bug.cgi?id=349263 + if (locked) + throw ScriptRuntime.typeError0("msg.already.exec.gen"); + locked = true; + } + return function.resumeGenerator(cx, scope, operation, savedState, + value); + } catch (GeneratorClosedException e) { + // On closing a generator in the compile path, the generator + // throws a special exception. This ensures execution of all pending + // finalizers and will not get caught by user code. + return Undefined.instance; + } catch (RhinoException e) { + lineNumber = e.lineNumber(); + lineSource = e.lineSource(); + savedState = null; + throw e; + } finally { + synchronized (this) { + locked = false; + } + if (operation == GENERATOR_CLOSE) + savedState = null; + } + } + +// #string_id_map# + + protected int findPrototypeId(String s) { + int id; +// #generated# Last update: 2007-06-14 13:13:03 EDT + L0: { id = 0; String X = null; int c; + int s_length = s.length(); + if (s_length==4) { + c=s.charAt(0); + if (c=='n') { X="next";id=Id_next; } + else if (c=='s') { X="send";id=Id_send; } + } + else if (s_length==5) { + c=s.charAt(0); + if (c=='c') { X="close";id=Id_close; } + else if (c=='t') { X="throw";id=Id_throw; } + } + else if (s_length==12) { X="__iterator__";id=Id___iterator__; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_close = 1, + Id_next = 2, + Id_send = 3, + Id_throw = 4, + Id___iterator__ = 5, + MAX_PROTOTYPE_ID = 5; + +// #/string_id_map# + private NativeFunction function; + private Object savedState; + private String lineSource; + private int lineNumber; + private boolean firstTime = true; + private boolean locked; + + public static class GeneratorClosedException extends RuntimeException { + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeGlobal.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeGlobal.java new file mode 100644 index 0000000..58faad4 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeGlobal.java @@ -0,0 +1,790 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; + +import org.mozilla.javascript.xml.XMLLib; + +/** + * This class implements the global native object (function and value + * properties only). + * + * See ECMA 15.1.[12]. + * + * @author Mike Shaver + */ + +public class NativeGlobal implements Serializable, IdFunctionCall +{ + static final long serialVersionUID = 6080442165748707530L; + + public static void init(Context cx, Scriptable scope, boolean sealed) { + NativeGlobal obj = new NativeGlobal(); + + for (int id = 1; id <= LAST_SCOPE_FUNCTION_ID; ++id) { + String name; + int arity = 1; + switch (id) { + case Id_decodeURI: + name = "decodeURI"; + break; + case Id_decodeURIComponent: + name = "decodeURIComponent"; + break; + case Id_encodeURI: + name = "encodeURI"; + break; + case Id_encodeURIComponent: + name = "encodeURIComponent"; + break; + case Id_escape: + name = "escape"; + break; + case Id_eval: + name = "eval"; + break; + case Id_isFinite: + name = "isFinite"; + break; + case Id_isNaN: + name = "isNaN"; + break; + case Id_isXMLName: + name = "isXMLName"; + break; + case Id_parseFloat: + name = "parseFloat"; + break; + case Id_parseInt: + name = "parseInt"; + arity = 2; + break; + case Id_unescape: + name = "unescape"; + break; + case Id_uneval: + name = "uneval"; + break; + default: + throw Kit.codeBug(); + } + IdFunctionObject f = new IdFunctionObject(obj, FTAG, id, name, + arity, scope); + if (sealed) { + f.sealObject(); + } + f.exportAsScopeProperty(); + } + + ScriptableObject.defineProperty( + scope, "NaN", ScriptRuntime.NaNobj, + ScriptableObject.DONTENUM); + ScriptableObject.defineProperty( + scope, "Infinity", + ScriptRuntime.wrapNumber(Double.POSITIVE_INFINITY), + ScriptableObject.DONTENUM); + ScriptableObject.defineProperty( + scope, "undefined", Undefined.instance, + ScriptableObject.DONTENUM); + + String[] errorMethods = Kit.semicolonSplit("" + +"ConversionError;" + +"EvalError;" + +"RangeError;" + +"ReferenceError;" + +"SyntaxError;" + +"TypeError;" + +"URIError;" + +"InternalError;" + +"JavaException;" + ); + + /* + Each error constructor gets its own Error object as a prototype, + with the 'name' property set to the name of the error. + */ + for (int i = 0; i < errorMethods.length; i++) { + String name = errorMethods[i]; + Scriptable errorProto = ScriptRuntime. + newObject(cx, scope, "Error", + ScriptRuntime.emptyArgs); + errorProto.put("name", errorProto, name); + if (sealed) { + if (errorProto instanceof ScriptableObject) { + ((ScriptableObject)errorProto).sealObject(); + } + } + IdFunctionObject ctor = new IdFunctionObject(obj, FTAG, + Id_new_CommonError, + name, 1, scope); + ctor.markAsConstructor(errorProto); + if (sealed) { + ctor.sealObject(); + } + ctor.exportAsScopeProperty(); + } + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (f.hasTag(FTAG)) { + int methodId = f.methodId(); + switch (methodId) { + case Id_decodeURI: + case Id_decodeURIComponent: { + String str = ScriptRuntime.toString(args, 0); + return decode(str, methodId == Id_decodeURI); + } + + case Id_encodeURI: + case Id_encodeURIComponent: { + String str = ScriptRuntime.toString(args, 0); + return encode(str, methodId == Id_encodeURI); + } + + case Id_escape: + return js_escape(args); + + case Id_eval: + return js_eval(cx, scope, args); + + case Id_isFinite: { + boolean result; + if (args.length < 1) { + result = false; + } else { + double d = ScriptRuntime.toNumber(args[0]); + result = (d == d + && d != Double.POSITIVE_INFINITY + && d != Double.NEGATIVE_INFINITY); + } + return ScriptRuntime.wrapBoolean(result); + } + + case Id_isNaN: { + // The global method isNaN, as per ECMA-262 15.1.2.6. + boolean result; + if (args.length < 1) { + result = true; + } else { + double d = ScriptRuntime.toNumber(args[0]); + result = (d != d); + } + return ScriptRuntime.wrapBoolean(result); + } + + case Id_isXMLName: { + Object name = (args.length == 0) + ? Undefined.instance : args[0]; + XMLLib xmlLib = XMLLib.extractFromScope(scope); + return ScriptRuntime.wrapBoolean( + xmlLib.isXMLName(cx, name)); + } + + case Id_parseFloat: + return js_parseFloat(args); + + case Id_parseInt: + return js_parseInt(args); + + case Id_unescape: + return js_unescape(args); + + case Id_uneval: { + Object value = (args.length != 0) + ? args[0] : Undefined.instance; + return ScriptRuntime.uneval(cx, scope, value); + } + + case Id_new_CommonError: + // The implementation of all the ECMA error constructors + // (SyntaxError, TypeError, etc.) + return NativeError.make(cx, scope, f, args); + } + } + throw f.unknown(); + } + + /** + * The global method parseInt, as per ECMA-262 15.1.2.2. + */ + private Object js_parseInt(Object[] args) { + String s = ScriptRuntime.toString(args, 0); + int radix = ScriptRuntime.toInt32(args, 1); + + int len = s.length(); + if (len == 0) + return ScriptRuntime.NaNobj; + + boolean negative = false; + int start = 0; + char c; + do { + c = s.charAt(start); + if (!Character.isWhitespace(c)) + break; + start++; + } while (start < len); + + if (c == '+' || (negative = (c == '-'))) + start++; + + final int NO_RADIX = -1; + if (radix == 0) { + radix = NO_RADIX; + } else if (radix < 2 || radix > 36) { + return ScriptRuntime.NaNobj; + } else if (radix == 16 && len - start > 1 && s.charAt(start) == '0') { + c = s.charAt(start+1); + if (c == 'x' || c == 'X') + start += 2; + } + + if (radix == NO_RADIX) { + radix = 10; + if (len - start > 1 && s.charAt(start) == '0') { + c = s.charAt(start+1); + if (c == 'x' || c == 'X') { + radix = 16; + start += 2; + } else if ('0' <= c && c <= '9') { + radix = 8; + start++; + } + } + } + + double d = ScriptRuntime.stringToNumber(s, start, radix); + return ScriptRuntime.wrapNumber(negative ? -d : d); + } + + /** + * The global method parseFloat, as per ECMA-262 15.1.2.3. + * + * @param args the arguments to parseFloat, ignoring args[>=1] + */ + private Object js_parseFloat(Object[] args) + { + if (args.length < 1) + return ScriptRuntime.NaNobj; + + String s = ScriptRuntime.toString(args[0]); + int len = s.length(); + int start = 0; + // Scan forward to skip whitespace + char c; + for (;;) { + if (start == len) { + return ScriptRuntime.NaNobj; + } + c = s.charAt(start); + if (!TokenStream.isJSSpace(c)) { + break; + } + ++start; + } + + int i = start; + if (c == '+' || c == '-') { + ++i; + if (i == len) { + return ScriptRuntime.NaNobj; + } + c = s.charAt(i); + } + + if (c == 'I') { + // check for "Infinity" + if (i+8 <= len && s.regionMatches(i, "Infinity", 0, 8)) { + double d; + if (s.charAt(start) == '-') { + d = Double.NEGATIVE_INFINITY; + } else { + d = Double.POSITIVE_INFINITY; + } + return ScriptRuntime.wrapNumber(d); + } + return ScriptRuntime.NaNobj; + } + + // Find the end of the legal bit + int decimal = -1; + int exponent = -1; + for (; i < len; i++) { + switch (s.charAt(i)) { + case '.': + if (decimal != -1) // Only allow a single decimal point. + break; + decimal = i; + continue; + + case 'e': + case 'E': + if (exponent != -1) + break; + exponent = i; + continue; + + case '+': + case '-': + // Only allow '+' or '-' after 'e' or 'E' + if (exponent != i-1) + break; + continue; + + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + continue; + + default: + break; + } + break; + } + s = s.substring(start, i); + try { + return Double.valueOf(s); + } + catch (NumberFormatException ex) { + return ScriptRuntime.NaNobj; + } + } + + /** + * The global method escape, as per ECMA-262 15.1.2.4. + + * Includes code for the 'mask' argument supported by the C escape + * method, which used to be part of the browser imbedding. Blame + * for the strange constant names should be directed there. + */ + + private Object js_escape(Object[] args) { + final int + URL_XALPHAS = 1, + URL_XPALPHAS = 2, + URL_PATH = 4; + + String s = ScriptRuntime.toString(args, 0); + + int mask = URL_XALPHAS | URL_XPALPHAS | URL_PATH; + if (args.length > 1) { // the 'mask' argument. Non-ECMA. + double d = ScriptRuntime.toNumber(args[1]); + if (d != d || ((mask = (int) d) != d) || + 0 != (mask & ~(URL_XALPHAS | URL_XPALPHAS | URL_PATH))) + { + throw Context.reportRuntimeError0("msg.bad.esc.mask"); + } + } + + StringBuffer sb = null; + for (int k = 0, L = s.length(); k != L; ++k) { + int c = s.charAt(k); + if (mask != 0 + && ((c >= '0' && c <= '9') + || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') + || c == '@' || c == '*' || c == '_' || c == '-' || c == '.' + || (0 != (mask & URL_PATH) && (c == '/' || c == '+')))) + { + if (sb != null) { + sb.append((char)c); + } + } else { + if (sb == null) { + sb = new StringBuffer(L + 3); + sb.append(s); + sb.setLength(k); + } + + int hexSize; + if (c < 256) { + if (c == ' ' && mask == URL_XPALPHAS) { + sb.append('+'); + continue; + } + sb.append('%'); + hexSize = 2; + } else { + sb.append('%'); + sb.append('u'); + hexSize = 4; + } + + // append hexadecimal form of c left-padded with 0 + for (int shift = (hexSize - 1) * 4; shift >= 0; shift -= 4) { + int digit = 0xf & (c >> shift); + int hc = (digit < 10) ? '0' + digit : 'A' - 10 + digit; + sb.append((char)hc); + } + } + } + + return (sb == null) ? s : sb.toString(); + } + + /** + * The global unescape method, as per ECMA-262 15.1.2.5. + */ + + private Object js_unescape(Object[] args) + { + String s = ScriptRuntime.toString(args, 0); + int firstEscapePos = s.indexOf('%'); + if (firstEscapePos >= 0) { + int L = s.length(); + char[] buf = s.toCharArray(); + int destination = firstEscapePos; + for (int k = firstEscapePos; k != L;) { + char c = buf[k]; + ++k; + if (c == '%' && k != L) { + int end, start; + if (buf[k] == 'u') { + start = k + 1; + end = k + 5; + } else { + start = k; + end = k + 2; + } + if (end <= L) { + int x = 0; + for (int i = start; i != end; ++i) { + x = Kit.xDigitToInt(buf[i], x); + } + if (x >= 0) { + c = (char)x; + k = end; + } + } + } + buf[destination] = c; + ++destination; + } + s = new String(buf, 0, destination); + } + return s; + } + + private Object js_eval(Context cx, Scriptable scope, Object[] args) + { + String m = ScriptRuntime.getMessage1("msg.cant.call.indirect", "eval"); + throw NativeGlobal.constructError(cx, "EvalError", m, scope); + } + + static boolean isEvalFunction(Object functionObj) + { + if (functionObj instanceof IdFunctionObject) { + IdFunctionObject function = (IdFunctionObject)functionObj; + if (function.hasTag(FTAG) && function.methodId() == Id_eval) { + return true; + } + } + return false; + } + + /** + * @deprecated Use {@link ScriptRuntime#constructError(String,String)} + * instead. + */ + public static EcmaError constructError(Context cx, + String error, + String message, + Scriptable scope) + { + return ScriptRuntime.constructError(error, message); + } + + /** + * @deprecated Use + * {@link ScriptRuntime#constructError(String,String,String,int,String,int)} + * instead. + */ + public static EcmaError constructError(Context cx, + String error, + String message, + Scriptable scope, + String sourceName, + int lineNumber, + int columnNumber, + String lineSource) + { + return ScriptRuntime.constructError(error, message, + sourceName, lineNumber, + lineSource, columnNumber); + } + + /* + * ECMA 3, 15.1.3 URI Handling Function Properties + * + * The following are implementations of the algorithms + * given in the ECMA specification for the hidden functions + * 'Encode' and 'Decode'. + */ + private static String encode(String str, boolean fullUri) { + byte[] utf8buf = null; + StringBuffer sb = null; + + for (int k = 0, length = str.length(); k != length; ++k) { + char C = str.charAt(k); + if (encodeUnescaped(C, fullUri)) { + if (sb != null) { + sb.append(C); + } + } else { + if (sb == null) { + sb = new StringBuffer(length + 3); + sb.append(str); + sb.setLength(k); + utf8buf = new byte[6]; + } + if (0xDC00 <= C && C <= 0xDFFF) { + throw Context.reportRuntimeError0("msg.bad.uri"); + } + int V; + if (C < 0xD800 || 0xDBFF < C) { + V = C; + } else { + k++; + if (k == length) { + throw Context.reportRuntimeError0("msg.bad.uri"); + } + char C2 = str.charAt(k); + if (!(0xDC00 <= C2 && C2 <= 0xDFFF)) { + throw Context.reportRuntimeError0("msg.bad.uri"); + } + V = ((C - 0xD800) << 10) + (C2 - 0xDC00) + 0x10000; + } + int L = oneUcs4ToUtf8Char(utf8buf, V); + for (int j = 0; j < L; j++) { + int d = 0xff & utf8buf[j]; + sb.append('%'); + sb.append(toHexChar(d >>> 4)); + sb.append(toHexChar(d & 0xf)); + } + } + } + return (sb == null) ? str : sb.toString(); + } + + private static char toHexChar(int i) { + if (i >> 4 != 0) Kit.codeBug(); + return (char)((i < 10) ? i + '0' : i - 10 + 'a'); + } + + private static int unHex(char c) { + if ('A' <= c && c <= 'F') { + return c - 'A' + 10; + } else if ('a' <= c && c <= 'f') { + return c - 'a' + 10; + } else if ('0' <= c && c <= '9') { + return c - '0'; + } else { + return -1; + } + } + + private static int unHex(char c1, char c2) { + int i1 = unHex(c1); + int i2 = unHex(c2); + if (i1 >= 0 && i2 >= 0) { + return (i1 << 4) | i2; + } + return -1; + } + + private static String decode(String str, boolean fullUri) { + char[] buf = null; + int bufTop = 0; + + for (int k = 0, length = str.length(); k != length;) { + char C = str.charAt(k); + if (C != '%') { + if (buf != null) { + buf[bufTop++] = C; + } + ++k; + } else { + if (buf == null) { + // decode always compress so result can not be bigger then + // str.length() + buf = new char[length]; + str.getChars(0, k, buf, 0); + bufTop = k; + } + int start = k; + if (k + 3 > length) + throw Context.reportRuntimeError0("msg.bad.uri"); + int B = unHex(str.charAt(k + 1), str.charAt(k + 2)); + if (B < 0) throw Context.reportRuntimeError0("msg.bad.uri"); + k += 3; + if ((B & 0x80) == 0) { + C = (char)B; + } else { + // Decode UTF-8 sequence into ucs4Char and encode it into + // UTF-16 + int utf8Tail, ucs4Char, minUcs4Char; + if ((B & 0xC0) == 0x80) { + // First UTF-8 should be ouside 0x80..0xBF + throw Context.reportRuntimeError0("msg.bad.uri"); + } else if ((B & 0x20) == 0) { + utf8Tail = 1; ucs4Char = B & 0x1F; + minUcs4Char = 0x80; + } else if ((B & 0x10) == 0) { + utf8Tail = 2; ucs4Char = B & 0x0F; + minUcs4Char = 0x800; + } else if ((B & 0x08) == 0) { + utf8Tail = 3; ucs4Char = B & 0x07; + minUcs4Char = 0x10000; + } else if ((B & 0x04) == 0) { + utf8Tail = 4; ucs4Char = B & 0x03; + minUcs4Char = 0x200000; + } else if ((B & 0x02) == 0) { + utf8Tail = 5; ucs4Char = B & 0x01; + minUcs4Char = 0x4000000; + } else { + // First UTF-8 can not be 0xFF or 0xFE + throw Context.reportRuntimeError0("msg.bad.uri"); + } + if (k + 3 * utf8Tail > length) + throw Context.reportRuntimeError0("msg.bad.uri"); + for (int j = 0; j != utf8Tail; j++) { + if (str.charAt(k) != '%') + throw Context.reportRuntimeError0("msg.bad.uri"); + B = unHex(str.charAt(k + 1), str.charAt(k + 2)); + if (B < 0 || (B & 0xC0) != 0x80) + throw Context.reportRuntimeError0("msg.bad.uri"); + ucs4Char = (ucs4Char << 6) | (B & 0x3F); + k += 3; + } + // Check for overlongs and other should-not-present codes + if (ucs4Char < minUcs4Char + || ucs4Char == 0xFFFE || ucs4Char == 0xFFFF) + { + ucs4Char = 0xFFFD; + } + if (ucs4Char >= 0x10000) { + ucs4Char -= 0x10000; + if (ucs4Char > 0xFFFFF) + throw Context.reportRuntimeError0("msg.bad.uri"); + char H = (char)((ucs4Char >>> 10) + 0xD800); + C = (char)((ucs4Char & 0x3FF) + 0xDC00); + buf[bufTop++] = H; + } else { + C = (char)ucs4Char; + } + } + if (fullUri && URI_DECODE_RESERVED.indexOf(C) >= 0) { + for (int x = start; x != k; x++) { + buf[bufTop++] = str.charAt(x); + } + } else { + buf[bufTop++] = C; + } + } + } + return (buf == null) ? str : new String(buf, 0, bufTop); + } + + private static boolean encodeUnescaped(char c, boolean fullUri) { + if (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') + || ('0' <= c && c <= '9')) + { + return true; + } + if ("-_.!~*'()".indexOf(c) >= 0) + return true; + if (fullUri) { + return URI_DECODE_RESERVED.indexOf(c) >= 0; + } + return false; + } + + private static final String URI_DECODE_RESERVED = ";/?:@&=+$,#"; + + /* Convert one UCS-4 char and write it into a UTF-8 buffer, which must be + * at least 6 bytes long. Return the number of UTF-8 bytes of data written. + */ + private static int oneUcs4ToUtf8Char(byte[] utf8Buffer, int ucs4Char) { + int utf8Length = 1; + + //JS_ASSERT(ucs4Char <= 0x7FFFFFFF); + if ((ucs4Char & ~0x7F) == 0) + utf8Buffer[0] = (byte)ucs4Char; + else { + int i; + int a = ucs4Char >>> 11; + utf8Length = 2; + while (a != 0) { + a >>>= 5; + utf8Length++; + } + i = utf8Length; + while (--i > 0) { + utf8Buffer[i] = (byte)((ucs4Char & 0x3F) | 0x80); + ucs4Char >>>= 6; + } + utf8Buffer[0] = (byte)(0x100 - (1 << (8-utf8Length)) + ucs4Char); + } + return utf8Length; + } + + private static final Object FTAG = new Object(); + + private static final int + Id_decodeURI = 1, + Id_decodeURIComponent = 2, + Id_encodeURI = 3, + Id_encodeURIComponent = 4, + Id_escape = 5, + Id_eval = 6, + Id_isFinite = 7, + Id_isNaN = 8, + Id_isXMLName = 9, + Id_parseFloat = 10, + Id_parseInt = 11, + Id_unescape = 12, + Id_uneval = 13, + + LAST_SCOPE_FUNCTION_ID = 13, + + Id_new_CommonError = 14; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeIterator.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeIterator.java new file mode 100644 index 0000000..c61f417 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeIterator.java @@ -0,0 +1,260 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.Iterator; + +/** + * This class implements iterator objects. See + * http://developer.mozilla.org/en/docs/New_in_JavaScript_1.7#Iterators + * + * @author Norris Boyd + */ +public final class NativeIterator extends IdScriptableObject { + private static final Object ITERATOR_TAG = new Object(); + + static void init(ScriptableObject scope, boolean sealed) { + // Iterator + NativeIterator iterator = new NativeIterator(); + iterator.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + + // Generator + NativeGenerator.init(scope, sealed); + + // StopIteration + NativeObject obj = new StopIteration(); + obj.setPrototype(getObjectPrototype(scope)); + obj.setParentScope(scope); + if (sealed) { obj.sealObject(); } + ScriptableObject.defineProperty(scope, STOP_ITERATION, obj, + ScriptableObject.DONTENUM); + // Use "associateValue" so that generators can continue to + // throw StopIteration even if the property of the global + // scope is replaced or deleted. + scope.associateValue(ITERATOR_TAG, obj); + } + + /** + * Only for constructing the prototype object. + */ + private NativeIterator() { + } + + private NativeIterator(Object objectIterator) { + this.objectIterator = objectIterator; + } + + /** + * Get the value of the "StopIteration" object. Note that this value + * is stored in the top-level scope using "associateValue" so the + * value can still be found even if a script overwrites or deletes + * the global "StopIteration" property. + * @param scope a scope whose parent chain reaches a top-level scope + * @return the StopIteration object + */ + public static Object getStopIterationObject(Scriptable scope) { + Scriptable top = ScriptableObject.getTopLevelScope(scope); + return ScriptableObject.getTopScopeValue(top, ITERATOR_TAG); + } + + private static final String STOP_ITERATION = "StopIteration"; + public static final String ITERATOR_PROPERTY_NAME = "__iterator__"; + + static class StopIteration extends NativeObject { + public String getClassName() { + return STOP_ITERATION; + } + + /* StopIteration has custom instanceof behavior since it + * doesn't have a constructor. + */ + public boolean hasInstance(Scriptable instance) { + return instance instanceof StopIteration; + } + } + + public String getClassName() { + return "Iterator"; + } + + protected void initPrototypeId(int id) { + String s; + int arity; + switch (id) { + case Id_constructor: arity=2; s="constructor"; break; + case Id_next: arity=0; s="next"; break; + case Id___iterator__: arity=1; s=ITERATOR_PROPERTY_NAME; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(ITERATOR_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(ITERATOR_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + + if (id == Id_constructor) { + return jsConstructor(cx, scope, thisObj, args); + } + + if (!(thisObj instanceof NativeIterator)) + throw incompatibleCallError(f); + + NativeIterator iterator = (NativeIterator) thisObj; + + switch (id) { + + case Id_next: + return iterator.next(cx, scope); + + case Id___iterator__: + /// XXX: what about argument? SpiderMonkey apparently ignores it + return thisObj; + + default: + throw new IllegalArgumentException(String.valueOf(id)); + } + } + + /* the javascript constructor */ + private static Object jsConstructor(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (args.length == 0 || args[0] == null || + args[0] == Undefined.instance) + { + throw ScriptRuntime.typeError1("msg.no.properties", + ScriptRuntime.toString(args[0])); + } + Scriptable obj = ScriptRuntime.toObject(scope, args[0]); + boolean keyOnly = args.length > 1 && ScriptRuntime.toBoolean(args[1]); + if (thisObj != null) { + // Called as a function. Convert to iterator if possible. + + // For objects that implement java.lang.Iterable or + // java.util.Iterator, have JavaScript Iterator call the underlying + // iteration methods + Iterator iterator = + VMBridge.instance.getJavaIterator(cx, scope, obj); + if (iterator != null) { + scope = ScriptableObject.getTopLevelScope(scope); + return cx.getWrapFactory().wrap(cx, scope, + new WrappedJavaIterator(iterator, scope), + WrappedJavaIterator.class); + } + + // Otherwise, just call the runtime routine + Scriptable jsIterator = ScriptRuntime.toIterator(cx, scope, obj, + keyOnly); + if (jsIterator != null) { + return jsIterator; + } + } + + // Otherwise, just set up to iterate over the properties of the object. + // Do not call __iterator__ method. + Object objectIterator = ScriptRuntime.enumInit(obj, cx, + keyOnly ? ScriptRuntime.ENUMERATE_KEYS_NO_ITERATOR + : ScriptRuntime.ENUMERATE_ARRAY_NO_ITERATOR); + ScriptRuntime.setEnumNumbers(objectIterator, true); + NativeIterator result = new NativeIterator(objectIterator); + result.setPrototype(NativeIterator.getClassPrototype(scope, + result.getClassName())); + result.setParentScope(scope); + return result; + } + + private Object next(Context cx, Scriptable scope) { + Boolean b = ScriptRuntime.enumNext(this.objectIterator); + if (!b.booleanValue()) { + // Out of values. Throw StopIteration. + throw new JavaScriptException( + NativeIterator.getStopIterationObject(scope), null, 0); + } + return ScriptRuntime.enumId(this.objectIterator, cx); + } + + static public class WrappedJavaIterator + { + WrappedJavaIterator(Iterator iterator, Scriptable scope) { + this.iterator = iterator; + this.scope = scope; + } + + public Object next() { + if (!iterator.hasNext()) { + // Out of values. Throw StopIteration. + throw new JavaScriptException( + NativeIterator.getStopIterationObject(scope), null, 0); + } + return iterator.next(); + } + + public Object __iterator__(boolean b) { + return this; + } + + private Iterator iterator; + private Scriptable scope; + } + +// #string_id_map# + + protected int findPrototypeId(String s) { + int id; +// #generated# Last update: 2007-06-11 09:43:19 EDT + L0: { id = 0; String X = null; + int s_length = s.length(); + if (s_length==4) { X="next";id=Id_next; } + else if (s_length==11) { X="constructor";id=Id_constructor; } + else if (s_length==12) { X="__iterator__";id=Id___iterator__; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_next = 2, + Id___iterator__ = 3, + MAX_PROTOTYPE_ID = 3; + +// #/string_id_map# + + private Object objectIterator; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaArray.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaArray.java new file mode 100644 index 0000000..2f711a0 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaArray.java @@ -0,0 +1,168 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Frank Mitchell + * Mike Shaver + * Kemal Bayram + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.Array; + +/** + * This class reflects Java arrays into the JavaScript environment. + * + * @author Mike Shaver + * @see NativeJavaClass + * @see NativeJavaObject + * @see NativeJavaPackage + */ + +public class NativeJavaArray extends NativeJavaObject +{ + static final long serialVersionUID = -924022554283675333L; + + public String getClassName() { + return "JavaArray"; + } + + public static NativeJavaArray wrap(Scriptable scope, Object array) { + return new NativeJavaArray(scope, array); + } + + public Object unwrap() { + return array; + } + + public NativeJavaArray(Scriptable scope, Object array) { + super(scope, null, ScriptRuntime.ObjectClass); + Class cl = array.getClass(); + if (!cl.isArray()) { + throw new RuntimeException("Array expected"); + } + this.array = array; + this.length = Array.getLength(array); + this.cls = cl.getComponentType(); + } + + public boolean has(String id, Scriptable start) { + return id.equals("length") || super.has(id, start); + } + + public boolean has(int index, Scriptable start) { + return 0 <= index && index < length; + } + + public Object get(String id, Scriptable start) { + if (id.equals("length")) + return new Integer(length); + Object result = super.get(id, start); + if (result == NOT_FOUND && + !ScriptableObject.hasProperty(getPrototype(), id)) + { + throw Context.reportRuntimeError2( + "msg.java.member.not.found", array.getClass().getName(), id); + } + return result; + } + + public Object get(int index, Scriptable start) { + if (0 <= index && index < length) { + Context cx = Context.getContext(); + Object obj = Array.get(array, index); + return cx.getWrapFactory().wrap(cx, this, obj, cls); + } + return Undefined.instance; + } + + public void put(String id, Scriptable start, Object value) { + // Ignore assignments to "length"--it's readonly. + if (!id.equals("length")) + throw Context.reportRuntimeError1( + "msg.java.array.member.not.found", id); + } + + public void put(int index, Scriptable start, Object value) { + if (0 <= index && index < length) { + Array.set(array, index, Context.jsToJava(value, cls)); + } + else { + throw Context.reportRuntimeError2( + "msg.java.array.index.out.of.bounds", String.valueOf(index), + String.valueOf(length - 1)); + } + } + + public Object getDefaultValue(Class hint) { + if (hint == null || hint == ScriptRuntime.StringClass) + return array.toString(); + if (hint == ScriptRuntime.BooleanClass) + return Boolean.TRUE; + if (hint == ScriptRuntime.NumberClass) + return ScriptRuntime.NaNobj; + return this; + } + + public Object[] getIds() { + Object[] result = new Object[length]; + int i = length; + while (--i >= 0) + result[i] = new Integer(i); + return result; + } + + public boolean hasInstance(Scriptable value) { + if (!(value instanceof Wrapper)) + return false; + Object instance = ((Wrapper)value).unwrap(); + return cls.isInstance(instance); + } + + public Scriptable getPrototype() { + if (prototype == null) { + prototype = + ScriptableObject.getClassPrototype(this.getParentScope(), + "Array"); + } + return prototype; + } + + Object array; + int length; + Class cls; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaClass.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaClass.java new file mode 100644 index 0000000..ab8af5c --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaClass.java @@ -0,0 +1,320 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Frank Mitchell + * Mike Shaver + * Kurt Westerfeld + * Kemal Bayram + * Ulrike Mueller <umueller@demandware.com> + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.*; +import java.util.Hashtable; + +/** + * This class reflects Java classes into the JavaScript environment, mainly + * for constructors and static members. We lazily reflect properties, + * and currently do not guarantee that a single j.l.Class is only + * reflected once into the JS environment, although we should. + * The only known case where multiple reflections + * are possible occurs when a j.l.Class is wrapped as part of a + * method return or property access, rather than by walking the + * Packages/java tree. + * + * @author Mike Shaver + * @see NativeJavaArray + * @see NativeJavaObject + * @see NativeJavaPackage + */ + +public class NativeJavaClass extends NativeJavaObject implements Function +{ + static final long serialVersionUID = -6460763940409461664L; + + // Special property for getting the underlying Java class object. + static final String javaClassPropertyName = "__javaObject__"; + + public NativeJavaClass() { + } + + public NativeJavaClass(Scriptable scope, Class cl) { + this.parent = scope; + this.javaObject = cl; + initMembers(); + } + + protected void initMembers() { + Class cl = (Class)javaObject; + members = JavaMembers.lookupClass(parent, cl, cl, false); + staticFieldAndMethods + = members.getFieldAndMethodsObjects(this, cl, true); + } + + public String getClassName() { + return "JavaClass"; + } + + public boolean has(String name, Scriptable start) { + return members.has(name, true) || javaClassPropertyName.equals(name); + } + + public Object get(String name, Scriptable start) { + // When used as a constructor, ScriptRuntime.newObject() asks + // for our prototype to create an object of the correct type. + // We don't really care what the object is, since we're returning + // one constructed out of whole cloth, so we return null. + if (name.equals("prototype")) + return null; + + if (staticFieldAndMethods != null) { + Object result = staticFieldAndMethods.get(name); + if (result != null) + return result; + } + + if (members.has(name, true)) { + return members.get(this, name, javaObject, true); + } + + if (javaClassPropertyName.equals(name)) { + Context cx = Context.getContext(); + Scriptable scope = ScriptableObject.getTopLevelScope(start); + return cx.getWrapFactory().wrap(cx, scope, javaObject, + ScriptRuntime.ClassClass); + } + + // experimental: look for nested classes by appending $name to + // current class' name. + Class nestedClass = findNestedClass(getClassObject(), name); + if (nestedClass != null) { + NativeJavaClass nestedValue = new NativeJavaClass + (ScriptableObject.getTopLevelScope(this), nestedClass); + nestedValue.setParentScope(this); + return nestedValue; + } + + throw members.reportMemberNotFound(name); + } + + public void put(String name, Scriptable start, Object value) { + members.put(this, name, javaObject, value, true); + } + + public Object[] getIds() { + return members.getIds(true); + } + + public Class getClassObject() { + return (Class) super.unwrap(); + } + + public Object getDefaultValue(Class hint) { + if (hint == null || hint == ScriptRuntime.StringClass) + return this.toString(); + if (hint == ScriptRuntime.BooleanClass) + return Boolean.TRUE; + if (hint == ScriptRuntime.NumberClass) + return ScriptRuntime.NaNobj; + return this; + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + // If it looks like a "cast" of an object to this class type, + // walk the prototype chain to see if there's a wrapper of a + // object that's an instanceof this class. + if (args.length == 1 && args[0] instanceof Scriptable) { + Class c = getClassObject(); + Scriptable p = (Scriptable) args[0]; + do { + if (p instanceof Wrapper) { + Object o = ((Wrapper) p).unwrap(); + if (c.isInstance(o)) + return p; + } + p = p.getPrototype(); + } while (p != null); + } + return construct(cx, scope, args); + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + Class classObject = getClassObject(); + int modifiers = classObject.getModifiers(); + if (! (Modifier.isInterface(modifiers) || + Modifier.isAbstract(modifiers))) + { + MemberBox[] ctors = members.ctors; + int index = NativeJavaMethod.findFunction(cx, ctors, args); + if (index < 0) { + String sig = NativeJavaMethod.scriptSignature(args); + throw Context.reportRuntimeError2( + "msg.no.java.ctor", classObject.getName(), sig); + } + + // Found the constructor, so try invoking it. + return constructSpecific(cx, scope, args, ctors[index]); + } else { + Scriptable topLevel = ScriptableObject.getTopLevelScope(this); + String msg = ""; + try { + // trying to construct an interface; use JavaAdapter to + // construct a new class on the fly that implements this + // interface. + Object v = topLevel.get("JavaAdapter", topLevel); + if (v != NOT_FOUND) { + Function f = (Function) v; + Object[] adapterArgs = { this, args[0] }; + return f.construct(cx, topLevel,adapterArgs); + } + } catch (Exception ex) { + // fall through to error + String m = ex.getMessage(); + if (m != null) + msg = m; + } + throw Context.reportRuntimeError2( + "msg.cant.instantiate", msg, classObject.getName()); + } + } + + static Scriptable constructSpecific(Context cx, Scriptable scope, + Object[] args, MemberBox ctor) + { + Scriptable topLevel = ScriptableObject.getTopLevelScope(scope); + Class[] argTypes = ctor.argTypes; + + if (ctor.vararg) { + // marshall the explicit parameter + Object[] newArgs = new Object[argTypes.length]; + for (int i = 0; i < argTypes.length-1; i++) { + newArgs[i] = Context.jsToJava(args[i], argTypes[i]); + } + + Object varArgs; + + // Handle special situation where a single variable parameter + // is given and it is a Java or ECMA array. + if (args.length == argTypes.length && + (args[args.length-1] == null || + args[args.length-1] instanceof NativeArray || + args[args.length-1] instanceof NativeJavaArray)) + { + // convert the ECMA array into a native array + varArgs = Context.jsToJava(args[args.length-1], + argTypes[argTypes.length - 1]); + } else { + // marshall the variable parameter + Class componentType = argTypes[argTypes.length - 1]. + getComponentType(); + varArgs = Array.newInstance(componentType, + args.length - argTypes.length + 1); + for (int i=0; i < Array.getLength(varArgs); i++) { + Object value = Context.jsToJava(args[argTypes.length-1 + i], + componentType); + Array.set(varArgs, i, value); + } + } + + // add varargs + newArgs[argTypes.length-1] = varArgs; + // replace the original args with the new one + args = newArgs; + } else { + Object[] origArgs = args; + for (int i = 0; i < args.length; i++) { + Object arg = args[i]; + Object x = Context.jsToJava(arg, argTypes[i]); + if (x != arg) { + if (args == origArgs) { + args = origArgs.clone(); + } + args[i] = x; + } + } + } + + Object instance = ctor.newInstance(args); + // we need to force this to be wrapped, because construct _has_ + // to return a scriptable + return cx.getWrapFactory().wrapNewObject(cx, topLevel, instance); + } + + public String toString() { + return "[JavaClass " + getClassObject().getName() + "]"; + } + + /** + * Determines if prototype is a wrapped Java object and performs + * a Java "instanceof". + * Exception: if value is an instance of NativeJavaClass, it isn't + * considered an instance of the Java class; this forestalls any + * name conflicts between java.lang.Class's methods and the + * static methods exposed by a JavaNativeClass. + */ + public boolean hasInstance(Scriptable value) { + + if (value instanceof Wrapper && + !(value instanceof NativeJavaClass)) { + Object instance = ((Wrapper)value).unwrap(); + + return getClassObject().isInstance(instance); + } + + // value wasn't something we understand + return false; + } + + private static Class findNestedClass(Class parentClass, String name) { + String nestedClassName = parentClass.getName() + '$' + name; + ClassLoader loader = parentClass.getClassLoader(); + if (loader == null) { + // ALERT: if loader is null, nested class should be loaded + // via system class loader which can be different from the + // loader that brought Rhino classes that Class.forName() would + // use, but ClassLoader.getSystemClassLoader() is Java 2 only + return Kit.classOrNull(nestedClassName); + } else { + return Kit.classOrNull(loader, nestedClassName); + } + } + + private Hashtable staticFieldAndMethods; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaConstructor.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaConstructor.java new file mode 100644 index 0000000..530bf81 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaConstructor.java @@ -0,0 +1,85 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Frank Mitchell + * Mike Shaver + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class reflects a single Java constructor into the JavaScript + * environment. It satisfies a request for an overloaded constructor, + * as introduced in LiveConnect 3. + * All NativeJavaConstructors behave as JSRef `bound' methods, in that they + * always construct the same NativeJavaClass regardless of any reparenting + * that may occur. + * + * @author Frank Mitchell + * @see NativeJavaMethod + * @see NativeJavaPackage + * @see NativeJavaClass + */ + +public class NativeJavaConstructor extends BaseFunction +{ + static final long serialVersionUID = -8149253217482668463L; + + MemberBox ctor; + + public NativeJavaConstructor(MemberBox ctor) + { + this.ctor = ctor; + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return NativeJavaClass.constructSpecific(cx, scope, args, ctor); + } + + public String getFunctionName() + { + String sig = JavaMembers.liveConnectSignature(ctor.argTypes); + return "<init>".concat(sig); + } + + public String toString() + { + return "[JavaConstructor " + ctor.getName() + "]"; + } +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaMethod.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaMethod.java new file mode 100644 index 0000000..eb66f40 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaMethod.java @@ -0,0 +1,576 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Frank Mitchell + * Mike Shaver + * Ulrike Mueller <umueller@demandware.com> + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.reflect.*; + +/** + * This class reflects Java methods into the JavaScript environment and + * handles overloading of methods. + * + * @author Mike Shaver + * @see NativeJavaArray + * @see NativeJavaPackage + * @see NativeJavaClass + */ + +public class NativeJavaMethod extends BaseFunction +{ + static final long serialVersionUID = -3440381785576412928L; + + NativeJavaMethod(MemberBox[] methods) + { + this.functionName = methods[0].getName(); + this.methods = methods; + } + + NativeJavaMethod(MemberBox method, String name) + { + this.functionName = name; + this.methods = new MemberBox[] { method }; + } + + public NativeJavaMethod(Method method, String name) + { + this(new MemberBox(method), name); + } + + public String getFunctionName() + { + return functionName; + } + + static String scriptSignature(Object[] values) + { + StringBuffer sig = new StringBuffer(); + for (int i = 0; i != values.length; ++i) { + Object value = values[i]; + + String s; + if (value == null) { + s = "null"; + } else if (value instanceof Boolean) { + s = "boolean"; + } else if (value instanceof String) { + s = "string"; + } else if (value instanceof Number) { + s = "number"; + } else if (value instanceof Scriptable) { + if (value instanceof Undefined) { + s = "undefined"; + } else if (value instanceof Wrapper) { + Object wrapped = ((Wrapper)value).unwrap(); + s = wrapped.getClass().getName(); + } else if (value instanceof Function) { + s = "function"; + } else { + s = "object"; + } + } else { + s = JavaMembers.javaSignature(value.getClass()); + } + + if (i != 0) { + sig.append(','); + } + sig.append(s); + } + return sig.toString(); + } + + String decompile(int indent, int flags) + { + StringBuffer sb = new StringBuffer(); + boolean justbody = (0 != (flags & Decompiler.ONLY_BODY_FLAG)); + if (!justbody) { + sb.append("function "); + sb.append(getFunctionName()); + sb.append("() {"); + } + sb.append("/*\n"); + sb.append(toString()); + sb.append(justbody ? "*/\n" : "*/}\n"); + return sb.toString(); + } + + public String toString() + { + StringBuffer sb = new StringBuffer(); + for (int i = 0, N = methods.length; i != N; ++i) { + Method method = methods[i].method(); + sb.append(JavaMembers.javaSignature(method.getReturnType())); + sb.append(' '); + sb.append(method.getName()); + sb.append(JavaMembers.liveConnectSignature(methods[i].argTypes)); + sb.append('\n'); + } + return sb.toString(); + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + // Find a method that matches the types given. + if (methods.length == 0) { + throw new RuntimeException("No methods defined for call"); + } + + int index = findFunction(cx, methods, args); + if (index < 0) { + Class c = methods[0].method().getDeclaringClass(); + String sig = c.getName() + '.' + getFunctionName() + '(' + + scriptSignature(args) + ')'; + throw Context.reportRuntimeError1("msg.java.no_such_method", sig); + } + + MemberBox meth = methods[index]; + Class[] argTypes = meth.argTypes; + + if (meth.vararg) { + // marshall the explicit parameters + Object[] newArgs = new Object[argTypes.length]; + for (int i = 0; i < argTypes.length-1; i++) { + newArgs[i] = Context.jsToJava(args[i], argTypes[i]); + } + + Object varArgs; + + // Handle special situation where a single variable parameter + // is given and it is a Java or ECMA array or is null. + if (args.length == argTypes.length && + (args[args.length-1] == null || + args[args.length-1] instanceof NativeArray || + args[args.length-1] instanceof NativeJavaArray)) + { + // convert the ECMA array into a native array + varArgs = Context.jsToJava(args[args.length-1], + argTypes[argTypes.length - 1]); + } else { + // marshall the variable parameters + Class componentType = argTypes[argTypes.length - 1]. + getComponentType(); + varArgs = Array.newInstance(componentType, + args.length - argTypes.length + 1); + for (int i = 0; i < Array.getLength(varArgs); i++) { + Object value = Context.jsToJava(args[argTypes.length-1 + i], + componentType); + Array.set(varArgs, i, value); + } + } + + // add varargs + newArgs[argTypes.length-1] = varArgs; + // replace the original args with the new one + args = newArgs; + } else { + // First, we marshall the args. + Object[] origArgs = args; + for (int i = 0; i < args.length; i++) { + Object arg = args[i]; + Object coerced = Context.jsToJava(arg, argTypes[i]); + if (coerced != arg) { + if (origArgs == args) { + args = args.clone(); + } + args[i] = coerced; + } + } + } + Object javaObject; + if (meth.isStatic()) { + javaObject = null; // don't need an object + } else { + Scriptable o = thisObj; + Class c = meth.getDeclaringClass(); + for (;;) { + if (o == null) { + throw Context.reportRuntimeError3( + "msg.nonjava.method", getFunctionName(), + ScriptRuntime.toString(thisObj), c.getName()); + } + if (o instanceof Wrapper) { + javaObject = ((Wrapper)o).unwrap(); + if (c.isInstance(javaObject)) { + break; + } + } + o = o.getPrototype(); + } + } + if (debug) { + printDebug("Calling ", meth, args); + } + + Object retval = meth.invoke(javaObject, args); + Class staticType = meth.method().getReturnType(); + + if (debug) { + Class actualType = (retval == null) ? null + : retval.getClass(); + System.err.println(" ----- Returned " + retval + + " actual = " + actualType + + " expect = " + staticType); + } + + Object wrapped = cx.getWrapFactory().wrap(cx, scope, + retval, staticType); + if (debug) { + Class actualType = (wrapped == null) ? null + : wrapped.getClass(); + System.err.println(" ----- Wrapped as " + wrapped + + " class = " + actualType); + } + + if (wrapped == null && staticType == Void.TYPE) { + wrapped = Undefined.instance; + } + return wrapped; + } + + /** + * Find the index of the correct function to call given the set of methods + * or constructors and the arguments. + * If no function can be found to call, return -1. + */ + static int findFunction(Context cx, + MemberBox[] methodsOrCtors, Object[] args) + { + if (methodsOrCtors.length == 0) { + return -1; + } else if (methodsOrCtors.length == 1) { + MemberBox member = methodsOrCtors[0]; + Class[] argTypes = member.argTypes; + int alength = argTypes.length; + + if (member.vararg) { + alength--; + if ( alength > args.length) { + return -1; + } + } else { + if (alength != args.length) { + return -1; + } + } + for (int j = 0; j != alength; ++j) { + if (!NativeJavaObject.canConvert(args[j], argTypes[j])) { + if (debug) printDebug("Rejecting (args can't convert) ", + member, args); + return -1; + } + } + if (debug) printDebug("Found ", member, args); + return 0; + } + + int firstBestFit = -1; + int[] extraBestFits = null; + int extraBestFitsCount = 0; + + search: + for (int i = 0; i < methodsOrCtors.length; i++) { + MemberBox member = methodsOrCtors[i]; + Class[] argTypes = member.argTypes; + int alength = argTypes.length; + if (member.vararg) { + alength--; + if ( alength > args.length) { + continue search; + } + } else { + if (alength != args.length) { + continue search; + } + } + for (int j = 0; j < alength; j++) { + if (!NativeJavaObject.canConvert(args[j], argTypes[j])) { + if (debug) printDebug("Rejecting (args can't convert) ", + member, args); + continue search; + } + } + if (firstBestFit < 0) { + if (debug) printDebug("Found first applicable ", member, args); + firstBestFit = i; + } else { + // Compare with all currently fit methods. + // The loop starts from -1 denoting firstBestFit and proceed + // until extraBestFitsCount to avoid extraBestFits allocation + // in the most common case of no ambiguity + int betterCount = 0; // number of times member was prefered over + // best fits + int worseCount = 0; // number of times best fits were prefered + // over member + for (int j = -1; j != extraBestFitsCount; ++j) { + int bestFitIndex; + if (j == -1) { + bestFitIndex = firstBestFit; + } else { + bestFitIndex = extraBestFits[j]; + } + MemberBox bestFit = methodsOrCtors[bestFitIndex]; + if (cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS) && + (bestFit.member().getModifiers() & Modifier.PUBLIC) != + (member.member().getModifiers() & Modifier.PUBLIC)) + { + // When FEATURE_ENHANCED_JAVA_ACCESS gives us access + // to non-public members, continue to prefer public + // methods in overloading + if ((bestFit.member().getModifiers() & Modifier.PUBLIC) == 0) + ++betterCount; + else + ++worseCount; + } else { + int preference = preferSignature(args, argTypes, + member.vararg, + bestFit.argTypes, + bestFit.vararg ); + if (preference == PREFERENCE_AMBIGUOUS) { + break; + } else if (preference == PREFERENCE_FIRST_ARG) { + ++betterCount; + } else if (preference == PREFERENCE_SECOND_ARG) { + ++worseCount; + } else { + if (preference != PREFERENCE_EQUAL) Kit.codeBug(); + // This should not happen in theory + // but on some JVMs, Class.getMethods will return all + // static methods of the class heirarchy, even if + // a derived class's parameters match exactly. + // We want to call the dervied class's method. + if (bestFit.isStatic() + && bestFit.getDeclaringClass().isAssignableFrom( + member.getDeclaringClass())) + { + // On some JVMs, Class.getMethods will return all + // static methods of the class heirarchy, even if + // a derived class's parameters match exactly. + // We want to call the dervied class's method. + if (debug) printDebug( + "Substituting (overridden static)", + member, args); + if (j == -1) { + firstBestFit = i; + } else { + extraBestFits[j] = i; + } + } else { + if (debug) printDebug( + "Ignoring same signature member ", + member, args); + } + continue search; + } + } + } + if (betterCount == 1 + extraBestFitsCount) { + // member was prefered over all best fits + if (debug) printDebug( + "New first applicable ", member, args); + firstBestFit = i; + extraBestFitsCount = 0; + } else if (worseCount == 1 + extraBestFitsCount) { + // all best fits were prefered over member, ignore it + if (debug) printDebug( + "Rejecting (all current bests better) ", member, args); + } else { + // some ambiguity was present, add member to best fit set + if (debug) printDebug( + "Added to best fit set ", member, args); + if (extraBestFits == null) { + // Allocate maximum possible array + extraBestFits = new int[methodsOrCtors.length - 1]; + } + extraBestFits[extraBestFitsCount] = i; + ++extraBestFitsCount; + } + } + } + + if (firstBestFit < 0) { + // Nothing was found + return -1; + } else if (extraBestFitsCount == 0) { + // single best fit + return firstBestFit; + } + + // report remaining ambiguity + StringBuffer buf = new StringBuffer(); + for (int j = -1; j != extraBestFitsCount; ++j) { + int bestFitIndex; + if (j == -1) { + bestFitIndex = firstBestFit; + } else { + bestFitIndex = extraBestFits[j]; + } + buf.append("\n "); + buf.append(methodsOrCtors[bestFitIndex].toJavaDeclaration()); + } + + MemberBox firstFitMember = methodsOrCtors[firstBestFit]; + String memberName = firstFitMember.getName(); + String memberClass = firstFitMember.getDeclaringClass().getName(); + + if (methodsOrCtors[0].isMethod()) { + throw Context.reportRuntimeError3( + "msg.constructor.ambiguous", + memberName, scriptSignature(args), buf.toString()); + } else { + throw Context.reportRuntimeError4( + "msg.method.ambiguous", memberClass, + memberName, scriptSignature(args), buf.toString()); + } + } + + /** Types are equal */ + private static final int PREFERENCE_EQUAL = 0; + private static final int PREFERENCE_FIRST_ARG = 1; + private static final int PREFERENCE_SECOND_ARG = 2; + /** No clear "easy" conversion */ + private static final int PREFERENCE_AMBIGUOUS = 3; + + /** + * Determine which of two signatures is the closer fit. + * Returns one of PREFERENCE_EQUAL, PREFERENCE_FIRST_ARG, + * PREFERENCE_SECOND_ARG, or PREFERENCE_AMBIGUOUS. + */ + private static int preferSignature(Object[] args, + Class[] sig1, + boolean vararg1, + Class[] sig2, + boolean vararg2 ) + { + // TODO: This test is pretty primitive. It bascially prefers + // a matching no vararg method over a vararg method independent + // of the type conversion cost. This can lead to unexpected results. + int alength = args.length; + if (!vararg1 && vararg2) { + // prefer the no vararg signature + return PREFERENCE_FIRST_ARG; + } else if (vararg1 && !vararg2) { + // prefer the no vararg signature + return PREFERENCE_SECOND_ARG; + } else if (vararg1 && vararg2) { + if (sig1.length < sig2.length) { + // prefer the signature with more explicit types + return PREFERENCE_SECOND_ARG; + } else if (sig1.length > sig2.length) { + // prefer the signature with more explicit types + return PREFERENCE_FIRST_ARG; + } else { + // Both are varargs and have the same length, so make the + // decision with the explicit args. + alength = Math.min(args.length, sig1.length-1); + } + } + + int totalPreference = 0; + for (int j = 0; j < alength; j++) { + Class type1 = sig1[j]; + Class type2 = sig2[j]; + if (type1 == type2) { + continue; + } + Object arg = args[j]; + + // Determine which of type1, type2 is easier to convert from arg. + + int rank1 = NativeJavaObject.getConversionWeight(arg, type1); + int rank2 = NativeJavaObject.getConversionWeight(arg, type2); + + int preference; + if (rank1 < rank2) { + preference = PREFERENCE_FIRST_ARG; + } else if (rank1 > rank2) { + preference = PREFERENCE_SECOND_ARG; + } else { + // Equal ranks + if (rank1 == NativeJavaObject.CONVERSION_NONTRIVIAL) { + if (type1.isAssignableFrom(type2)) { + preference = PREFERENCE_SECOND_ARG; + } else if (type2.isAssignableFrom(type1)) { + preference = PREFERENCE_FIRST_ARG; + } else { + preference = PREFERENCE_AMBIGUOUS; + } + } else { + preference = PREFERENCE_AMBIGUOUS; + } + } + + totalPreference |= preference; + + if (totalPreference == PREFERENCE_AMBIGUOUS) { + break; + } + } + return totalPreference; + } + + + private static final boolean debug = false; + + private static void printDebug(String msg, MemberBox member, + Object[] args) + { + if (debug) { + StringBuffer sb = new StringBuffer(); + sb.append(" ----- "); + sb.append(msg); + sb.append(member.getDeclaringClass().getName()); + sb.append('.'); + if (member.isMethod()) { + sb.append(member.getName()); + } + sb.append(JavaMembers.liveConnectSignature(member.argTypes)); + sb.append(" for arguments ("); + sb.append(scriptSignature(args)); + sb.append(')'); + System.out.println(sb); + } + } + + MemberBox[] methods; + private String functionName; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaObject.java new file mode 100644 index 0000000..3d27852 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaObject.java @@ -0,0 +1,1002 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Frank Mitchell + * Mike Shaver + * Kemal Bayram + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.*; +import java.lang.reflect.*; +import java.util.Hashtable; +import java.util.Date; + +/** + * This class reflects non-Array Java objects into the JavaScript environment. It + * reflect fields directly, and uses NativeJavaMethod objects to reflect (possibly + * overloaded) methods.<p> + * + * @author Mike Shaver + * @see NativeJavaArray + * @see NativeJavaPackage + * @see NativeJavaClass + */ + +public class NativeJavaObject implements Scriptable, Wrapper, Serializable +{ + static final long serialVersionUID = -6948590651130498591L; + + public NativeJavaObject() { } + + public NativeJavaObject(Scriptable scope, Object javaObject, + Class staticType) + { + this(scope, javaObject, staticType, false); + } + + public NativeJavaObject(Scriptable scope, Object javaObject, + Class staticType, boolean isAdapter) + { + this.parent = ScriptableObject.getVeryTopLevelScope(scope); // APPJET + this.javaObject = javaObject; + this.staticType = staticType; + this.isAdapter = isAdapter; + initMembers(); + } + + protected void initMembers() { + Class dynamicType; + if (javaObject != null) { + dynamicType = javaObject.getClass(); + } else { + dynamicType = staticType; + } + members = JavaMembers.lookupClass(parent, dynamicType, staticType, + isAdapter); + fieldAndMethods + = members.getFieldAndMethodsObjects(this, javaObject, false); + } + + public boolean has(String name, Scriptable start) { + return members.has(name, false); + } + + public boolean has(int index, Scriptable start) { + return false; + } + + public Object get(String name, Scriptable start) { + if (fieldAndMethods != null) { + Object result = fieldAndMethods.get(name); + if (result != null) { + return result; + } + } + // TODO: passing 'this' as the scope is bogus since it has + // no parent scope + return members.get(this, name, javaObject, false); + } + + public Object get(int index, Scriptable start) { + throw members.reportMemberNotFound(Integer.toString(index)); + } + + public void put(String name, Scriptable start, Object value) { + // We could be asked to modify the value of a property in the + // prototype. Since we can't add a property to a Java object, + // we modify it in the prototype rather than copy it down. + if (prototype == null || members.has(name, false)) + members.put(this, name, javaObject, value, false); + else + prototype.put(name, prototype, value); + } + + public void put(int index, Scriptable start, Object value) { + throw members.reportMemberNotFound(Integer.toString(index)); + } + + public boolean hasInstance(Scriptable value) { + // This is an instance of a Java class, so always return false + return false; + } + + public void delete(String name) { + } + + public void delete(int index) { + } + + public Scriptable getPrototype() { + if (prototype == null && javaObject instanceof String) { + return ScriptableObject.getClassPrototype(parent, "String"); + } + return prototype; + } + + /** + * Sets the prototype of the object. + */ + public void setPrototype(Scriptable m) { + prototype = m; + } + + /** + * Returns the parent (enclosing) scope of the object. + */ + public Scriptable getParentScope() { + return parent; + } + + /** + * Sets the parent (enclosing) scope of the object. + */ + public void setParentScope(Scriptable m) { + parent = m; + } + + public Object[] getIds() { + return members.getIds(false); + } + +/** +@deprecated Use {@link Context#getWrapFactory()} together with calling {@link +WrapFactory#wrap(Context, Scriptable, Object, Class)} +*/ + public static Object wrap(Scriptable scope, Object obj, Class staticType) { + + Context cx = Context.getContext(); + return cx.getWrapFactory().wrap(cx, scope, obj, staticType); + } + + public Object unwrap() { + return javaObject; + } + + public String getClassName() { + return "JavaObject"; + } + + public Object getDefaultValue(Class hint) + { + Object value; + if (hint == null) { + if (javaObject instanceof Boolean) { + hint = ScriptRuntime.BooleanClass; + } + } + if (hint == null || hint == ScriptRuntime.StringClass) { + value = javaObject.toString(); + } else { + String converterName; + if (hint == ScriptRuntime.BooleanClass) { + converterName = "booleanValue"; + } else if (hint == ScriptRuntime.NumberClass) { + converterName = "doubleValue"; + } else { + throw Context.reportRuntimeError0("msg.default.value"); + } + Object converterObject = get(converterName, this); + if (converterObject instanceof Function) { + Function f = (Function)converterObject; + value = f.call(Context.getContext(), f.getParentScope(), + this, ScriptRuntime.emptyArgs); + } else { + if (hint == ScriptRuntime.NumberClass + && javaObject instanceof Boolean) + { + boolean b = ((Boolean)javaObject).booleanValue(); + value = ScriptRuntime.wrapNumber(b ? 1.0 : 0.0); + } else { + value = javaObject.toString(); + } + } + } + return value; + } + + /** + * Determine whether we can/should convert between the given type and the + * desired one. This should be superceded by a conversion-cost calculation + * function, but for now I'll hide behind precedent. + */ + public static boolean canConvert(Object fromObj, Class to) { + int weight = getConversionWeight(fromObj, to); + + return (weight < CONVERSION_NONE); + } + + private static final int JSTYPE_UNDEFINED = 0; // undefined type + private static final int JSTYPE_NULL = 1; // null + private static final int JSTYPE_BOOLEAN = 2; // boolean + private static final int JSTYPE_NUMBER = 3; // number + private static final int JSTYPE_STRING = 4; // string + private static final int JSTYPE_JAVA_CLASS = 5; // JavaClass + private static final int JSTYPE_JAVA_OBJECT = 6; // JavaObject + private static final int JSTYPE_JAVA_ARRAY = 7; // JavaArray + private static final int JSTYPE_OBJECT = 8; // Scriptable + + static final byte CONVERSION_TRIVIAL = 1; + static final byte CONVERSION_NONTRIVIAL = 0; + static final byte CONVERSION_NONE = 99; + + /** + * Derive a ranking based on how "natural" the conversion is. + * The special value CONVERSION_NONE means no conversion is possible, + * and CONVERSION_NONTRIVIAL signals that more type conformance testing + * is required. + * Based on + * <a href="http://www.mozilla.org/js/liveconnect/lc3_method_overloading.html"> + * "preferred method conversions" from Live Connect 3</a> + */ + static int getConversionWeight(Object fromObj, Class to) { + int fromCode = getJSTypeCode(fromObj); + + switch (fromCode) { + + case JSTYPE_UNDEFINED: + if (to == ScriptRuntime.StringClass || + to == ScriptRuntime.ObjectClass) { + return 1; + } + break; + + case JSTYPE_NULL: + if (!to.isPrimitive()) { + return 1; + } + break; + + case JSTYPE_BOOLEAN: + // "boolean" is #1 + if (to == Boolean.TYPE) { + return 1; + } + else if (to == ScriptRuntime.BooleanClass) { + return 2; + } + else if (to == ScriptRuntime.ObjectClass) { + return 3; + } + else if (to == ScriptRuntime.StringClass) { + return 4; + } + break; + + case JSTYPE_NUMBER: + if (to.isPrimitive()) { + if (to == Double.TYPE) { + return 1; + } + else if (to != Boolean.TYPE) { + return 1 + getSizeRank(to); + } + } + else { + if (to == ScriptRuntime.StringClass) { + // native numbers are #1-8 + return 9; + } + else if (to == ScriptRuntime.ObjectClass) { + return 10; + } + else if (ScriptRuntime.NumberClass.isAssignableFrom(to)) { + // "double" is #1 + return 2; + } + } + break; + + case JSTYPE_STRING: + if (to == ScriptRuntime.StringClass) { + return 1; + } + else if (to.isInstance(fromObj)) { + return 2; + } + else if (to.isPrimitive()) { + if (to == Character.TYPE) { + return 3; + } else if (to != Boolean.TYPE) { + return 4; + } + } + break; + + case JSTYPE_JAVA_CLASS: + if (to == ScriptRuntime.ClassClass) { + return 1; + } + else if (to == ScriptRuntime.ObjectClass) { + return 3; + } + else if (to == ScriptRuntime.StringClass) { + return 4; + } + break; + + case JSTYPE_JAVA_OBJECT: + case JSTYPE_JAVA_ARRAY: + Object javaObj = fromObj; + if (javaObj instanceof Wrapper) { + javaObj = ((Wrapper)javaObj).unwrap(); + } + if (to.isInstance(javaObj)) { + return CONVERSION_NONTRIVIAL; + } + if (to == ScriptRuntime.StringClass) { + return 2; + } + else if (to.isPrimitive() && to != Boolean.TYPE) { + return (fromCode == JSTYPE_JAVA_ARRAY) + ? CONVERSION_NONE : 2 + getSizeRank(to); + } + break; + + case JSTYPE_OBJECT: + // Other objects takes #1-#3 spots + if (to == fromObj.getClass()) { + // No conversion required + return 1; + } + if (to.isArray()) { + if (fromObj instanceof NativeArray) { + // This is a native array conversion to a java array + // Array conversions are all equal, and preferable to object + // and string conversion, per LC3. + return 1; + } + } + else if (to == ScriptRuntime.ObjectClass) { + return 2; + } + else if (to == ScriptRuntime.StringClass) { + return 3; + } + else if (to == ScriptRuntime.DateClass) { + if (fromObj instanceof NativeDate) { + // This is a native date to java date conversion + return 1; + } + } + else if (to.isInterface()) { + if (fromObj instanceof Function) { + // See comments in coerceType + if (to.getMethods().length == 1) { + return 1; + } + } + return 11; + } + else if (to.isPrimitive() && to != Boolean.TYPE) { + return 3 + getSizeRank(to); + } + break; + } + + return CONVERSION_NONE; + } + + static int getSizeRank(Class aType) { + if (aType == Double.TYPE) { + return 1; + } + else if (aType == Float.TYPE) { + return 2; + } + else if (aType == Long.TYPE) { + return 3; + } + else if (aType == Integer.TYPE) { + return 4; + } + else if (aType == Short.TYPE) { + return 5; + } + else if (aType == Character.TYPE) { + return 6; + } + else if (aType == Byte.TYPE) { + return 7; + } + else if (aType == Boolean.TYPE) { + return CONVERSION_NONE; + } + else { + return 8; + } + } + + private static int getJSTypeCode(Object value) { + if (value == null) { + return JSTYPE_NULL; + } + else if (value == Undefined.instance) { + return JSTYPE_UNDEFINED; + } + else if (value instanceof String) { + return JSTYPE_STRING; + } + else if (value instanceof Number) { + return JSTYPE_NUMBER; + } + else if (value instanceof Boolean) { + return JSTYPE_BOOLEAN; + } + else if (value instanceof Scriptable) { + if (value instanceof NativeJavaClass) { + return JSTYPE_JAVA_CLASS; + } + else if (value instanceof NativeJavaArray) { + return JSTYPE_JAVA_ARRAY; + } + else if (value instanceof Wrapper) { + return JSTYPE_JAVA_OBJECT; + } + else { + return JSTYPE_OBJECT; + } + } + else if (value instanceof Class) { + return JSTYPE_JAVA_CLASS; + } + else { + Class valueClass = value.getClass(); + if (valueClass.isArray()) { + return JSTYPE_JAVA_ARRAY; + } + else { + return JSTYPE_JAVA_OBJECT; + } + } + } + + /** + * Not intended for public use. Callers should use the + * public API Context.toType. + * @deprecated as of 1.5 Release 4 + * @see org.mozilla.javascript.Context#jsToJava(Object, Class) + */ + public static Object coerceType(Class type, Object value) + { + return coerceTypeImpl(type, value); + } + + /** + * Type-munging for field setting and method invocation. + * Conforms to LC3 specification + */ + static Object coerceTypeImpl(Class type, Object value) + { + if (value != null && value.getClass() == type) { + return value; + } + + switch (getJSTypeCode(value)) { + + case JSTYPE_NULL: + // raise error if type.isPrimitive() + if (type.isPrimitive()) { + reportConversionError(value, type); + } + return null; + + case JSTYPE_UNDEFINED: + if (type == ScriptRuntime.StringClass || + type == ScriptRuntime.ObjectClass) { + return "undefined"; + } + else { + reportConversionError("undefined", type); + } + break; + + case JSTYPE_BOOLEAN: + // Under LC3, only JS Booleans can be coerced into a Boolean value + if (type == Boolean.TYPE || + type == ScriptRuntime.BooleanClass || + type == ScriptRuntime.ObjectClass) { + return value; + } + else if (type == ScriptRuntime.StringClass) { + return value.toString(); + } + else { + reportConversionError(value, type); + } + break; + + case JSTYPE_NUMBER: + if (type == ScriptRuntime.StringClass) { + return ScriptRuntime.toString(value); + } + else if (type == ScriptRuntime.ObjectClass) { + return coerceToNumber(Double.TYPE, value); + } + else if ((type.isPrimitive() && type != Boolean.TYPE) || + ScriptRuntime.NumberClass.isAssignableFrom(type)) { + return coerceToNumber(type, value); + } + else { + reportConversionError(value, type); + } + break; + + case JSTYPE_STRING: + if (type == ScriptRuntime.StringClass || type.isInstance(value)) { + return value; + } + else if (type == Character.TYPE + || type == ScriptRuntime.CharacterClass) + { + // Special case for converting a single char string to a + // character + // Placed here because it applies *only* to JS strings, + // not other JS objects converted to strings + if (((String)value).length() == 1) { + return new Character(((String)value).charAt(0)); + } + else { + return coerceToNumber(type, value); + } + } + else if ((type.isPrimitive() && type != Boolean.TYPE) + || ScriptRuntime.NumberClass.isAssignableFrom(type)) + { + return coerceToNumber(type, value); + } + else { + reportConversionError(value, type); + } + break; + + case JSTYPE_JAVA_CLASS: + if (value instanceof Wrapper) { + value = ((Wrapper)value).unwrap(); + } + + if (type == ScriptRuntime.ClassClass || + type == ScriptRuntime.ObjectClass) { + return value; + } + else if (type == ScriptRuntime.StringClass) { + return value.toString(); + } + else { + reportConversionError(value, type); + } + break; + + case JSTYPE_JAVA_OBJECT: + case JSTYPE_JAVA_ARRAY: + if (value instanceof Wrapper) { + value = ((Wrapper)value).unwrap(); + } + if (type.isPrimitive()) { + if (type == Boolean.TYPE) { + reportConversionError(value, type); + } + return coerceToNumber(type, value); + } + else { + if (type == ScriptRuntime.StringClass) { + return value.toString(); + } + else { + if (type.isInstance(value)) { + return value; + } + else { + reportConversionError(value, type); + } + } + } + break; + + case JSTYPE_OBJECT: + if (type == ScriptRuntime.StringClass) { + return ScriptRuntime.toString(value); + } + else if (type.isPrimitive()) { + if (type == Boolean.TYPE) { + reportConversionError(value, type); + } + return coerceToNumber(type, value); + } + else if (type.isInstance(value)) { + return value; + } + else if (type == ScriptRuntime.DateClass + && value instanceof NativeDate) + { + double time = ((NativeDate)value).getJSTimeValue(); + // XXX: This will replace NaN by 0 + return new Date((long)time); + } + else if (type.isArray() && value instanceof NativeArray) { + // Make a new java array, and coerce the JS array components + // to the target (component) type. + NativeArray array = (NativeArray) value; + long length = array.getLength(); + Class arrayType = type.getComponentType(); + Object Result = Array.newInstance(arrayType, (int)length); + for (int i = 0 ; i < length ; ++i) { + try { + Array.set(Result, i, coerceType(arrayType, + array.get(i, array))); + } + catch (EvaluatorException ee) { + reportConversionError(value, type); + } + } + + return Result; + } + else if (value instanceof Wrapper) { + value = ((Wrapper)value).unwrap(); + if (type.isInstance(value)) + return value; + reportConversionError(value, type); + } + else if (type.isInterface() && value instanceof Callable) { + // Try to use function as implementation of Java interface. + // + // XXX: Curently only instances of ScriptableObject are + // supported since the resulting interface proxies should + // be reused next time conversion is made and generic + // Callable has no storage for it. Weak references can + // address it but for now use this restriction. + if (value instanceof ScriptableObject) { + ScriptableObject so = (ScriptableObject)value; + Object key = Kit.makeHashKeyFromPair( + COERCED_INTERFACE_KEY, type); + Object old = so.getAssociatedValue(key); + if (old != null) { + // Function was already wrapped + return old; + } + Context cx = Context.getContext(); + Object glue + = InterfaceAdapter.create(cx, type, (Callable)value); + // Store for later retrival + glue = so.associateValue(key, glue); + return glue; + } + reportConversionError(value, type); + } else { + reportConversionError(value, type); + } + break; + } + + return value; + } + + private static Object coerceToNumber(Class type, Object value) + { + Class valueClass = value.getClass(); + + // Character + if (type == Character.TYPE || type == ScriptRuntime.CharacterClass) { + if (valueClass == ScriptRuntime.CharacterClass) { + return value; + } + return new Character((char)toInteger(value, + ScriptRuntime.CharacterClass, + Character.MIN_VALUE, + Character.MAX_VALUE)); + } + + // Double, Float + if (type == ScriptRuntime.ObjectClass || + type == ScriptRuntime.DoubleClass || type == Double.TYPE) { + return valueClass == ScriptRuntime.DoubleClass + ? value + : new Double(toDouble(value)); + } + + if (type == ScriptRuntime.FloatClass || type == Float.TYPE) { + if (valueClass == ScriptRuntime.FloatClass) { + return value; + } + else { + double number = toDouble(value); + if (Double.isInfinite(number) || Double.isNaN(number) + || number == 0.0) { + return new Float((float)number); + } + else { + double absNumber = Math.abs(number); + if (absNumber < Float.MIN_VALUE) { + return new Float((number > 0.0) ? +0.0 : -0.0); + } + else if (absNumber > Float.MAX_VALUE) { + return new Float((number > 0.0) ? + Float.POSITIVE_INFINITY : + Float.NEGATIVE_INFINITY); + } + else { + return new Float((float)number); + } + } + } + } + + // Integer, Long, Short, Byte + if (type == ScriptRuntime.IntegerClass || type == Integer.TYPE) { + if (valueClass == ScriptRuntime.IntegerClass) { + return value; + } + else { + return new Integer((int)toInteger(value, + ScriptRuntime.IntegerClass, + Integer.MIN_VALUE, + Integer.MAX_VALUE)); + } + } + + if (type == ScriptRuntime.LongClass || type == Long.TYPE) { + if (valueClass == ScriptRuntime.LongClass) { + return value; + } else { + /* Long values cannot be expressed exactly in doubles. + * We thus use the largest and smallest double value that + * has a value expressible as a long value. We build these + * numerical values from their hexidecimal representations + * to avoid any problems caused by attempting to parse a + * decimal representation. + */ + final double max = Double.longBitsToDouble(0x43dfffffffffffffL); + final double min = Double.longBitsToDouble(0xc3e0000000000000L); + return new Long(toInteger(value, + ScriptRuntime.LongClass, + min, + max)); + } + } + + if (type == ScriptRuntime.ShortClass || type == Short.TYPE) { + if (valueClass == ScriptRuntime.ShortClass) { + return value; + } + else { + return new Short((short)toInteger(value, + ScriptRuntime.ShortClass, + Short.MIN_VALUE, + Short.MAX_VALUE)); + } + } + + if (type == ScriptRuntime.ByteClass || type == Byte.TYPE) { + if (valueClass == ScriptRuntime.ByteClass) { + return value; + } + else { + return new Byte((byte)toInteger(value, + ScriptRuntime.ByteClass, + Byte.MIN_VALUE, + Byte.MAX_VALUE)); + } + } + + return new Double(toDouble(value)); + } + + + private static double toDouble(Object value) + { + if (value instanceof Number) { + return ((Number)value).doubleValue(); + } + else if (value instanceof String) { + return ScriptRuntime.toNumber((String)value); + } + else if (value instanceof Scriptable) { + if (value instanceof Wrapper) { + // XXX: optimize tail-recursion? + return toDouble(((Wrapper)value).unwrap()); + } + else { + return ScriptRuntime.toNumber(value); + } + } + else { + Method meth; + try { + meth = value.getClass().getMethod("doubleValue", + (Class [])null); + } + catch (NoSuchMethodException e) { + meth = null; + } + catch (SecurityException e) { + meth = null; + } + if (meth != null) { + try { + return ((Number)meth.invoke(value, + (Object [])null)).doubleValue(); + } + catch (IllegalAccessException e) { + // XXX: ignore, or error message? + reportConversionError(value, Double.TYPE); + } + catch (InvocationTargetException e) { + // XXX: ignore, or error message? + reportConversionError(value, Double.TYPE); + } + } + return ScriptRuntime.toNumber(value.toString()); + } + } + + private static long toInteger(Object value, Class type, + double min, double max) + { + double d = toDouble(value); + + if (Double.isInfinite(d) || Double.isNaN(d)) { + // Convert to string first, for more readable message + reportConversionError(ScriptRuntime.toString(value), type); + } + + if (d > 0.0) { + d = Math.floor(d); + } + else { + d = Math.ceil(d); + } + + if (d < min || d > max) { + // Convert to string first, for more readable message + reportConversionError(ScriptRuntime.toString(value), type); + } + return (long)d; + } + + static void reportConversionError(Object value, Class type) + { + // It uses String.valueOf(value), not value.toString() since + // value can be null, bug 282447. + throw Context.reportRuntimeError2( + "msg.conversion.not.allowed", + String.valueOf(value), + JavaMembers.javaSignature(type)); + } + + private void writeObject(ObjectOutputStream out) + throws IOException + { + out.defaultWriteObject(); + + out.writeBoolean(isAdapter); + if (isAdapter) { + if (adapter_writeAdapterObject == null) { + throw new IOException(); + } + Object[] args = { javaObject, out }; + try { + adapter_writeAdapterObject.invoke(null, args); + } catch (Exception ex) { + throw new IOException(); + } + } else { + out.writeObject(javaObject); + } + + if (staticType != null) { + out.writeObject(staticType.getClass().getName()); + } else { + out.writeObject(null); + } + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + + isAdapter = in.readBoolean(); + if (isAdapter) { + if (adapter_readAdapterObject == null) + throw new ClassNotFoundException(); + Object[] args = { this, in }; + try { + javaObject = adapter_readAdapterObject.invoke(null, args); + } catch (Exception ex) { + throw new IOException(); + } + } else { + javaObject = in.readObject(); + } + + String className = (String)in.readObject(); + if (className != null) { + staticType = Class.forName(className); + } else { + staticType = null; + } + + initMembers(); + } + + /** + * The prototype of this object. + */ + protected Scriptable prototype; + + /** + * The parent scope of this object. + */ + protected Scriptable parent; + + protected transient Object javaObject; + + protected transient Class staticType; + protected transient JavaMembers members; + private transient Hashtable fieldAndMethods; + private transient boolean isAdapter; + + private static final Object COERCED_INTERFACE_KEY = new Object(); + private static Method adapter_writeAdapterObject; + private static Method adapter_readAdapterObject; + + static { + // Reflection in java is verbose + Class[] sig2 = new Class[2]; + Class cl = Kit.classOrNull("org.mozilla.javascript.JavaAdapter"); + if (cl != null) { + try { + sig2[0] = ScriptRuntime.ObjectClass; + sig2[1] = Kit.classOrNull("java.io.ObjectOutputStream"); + adapter_writeAdapterObject = cl.getMethod("writeAdapterObject", + sig2); + + sig2[0] = ScriptRuntime.ScriptableClass; + sig2[1] = Kit.classOrNull("java.io.ObjectInputStream"); + adapter_readAdapterObject = cl.getMethod("readAdapterObject", + sig2); + + } catch (Exception ex) { + adapter_writeAdapterObject = null; + adapter_readAdapterObject = null; + } + } + } + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaPackage.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaPackage.java new file mode 100644 index 0000000..71f09f7 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaPackage.java @@ -0,0 +1,199 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Frank Mitchell + * Mike Shaver + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class reflects Java packages into the JavaScript environment. We + * lazily reflect classes and subpackages, and use a caching/sharing + * system to ensure that members reflected into one JavaPackage appear + * in all other references to the same package (as with Packages.java.lang + * and java.lang). + * + * @author Mike Shaver + * @see NativeJavaArray + * @see NativeJavaObject + * @see NativeJavaClass + */ + +public class NativeJavaPackage extends ScriptableObject +{ + static final long serialVersionUID = 7445054382212031523L; + + NativeJavaPackage(boolean internalUsage, + String packageName, ClassLoader classLoader) + { + this.packageName = packageName; + this.classLoader = classLoader; + } + + /** + * @deprecated NativeJavaPackage is an internal class, do not use + * it directly. + */ + public NativeJavaPackage(String packageName, ClassLoader classLoader) { + this(false, packageName, classLoader); + } + + /** + * @deprecated NativeJavaPackage is an internal class, do not use + * it directly. + */ + public NativeJavaPackage(String packageName) { + this(false, packageName, + Context.getCurrentContext().getApplicationClassLoader()); + } + + public String getClassName() { + return "JavaPackage"; + } + + public boolean has(String id, Scriptable start) { + return true; + } + + public boolean has(int index, Scriptable start) { + return false; + } + + public void put(String id, Scriptable start, Object value) { + // Can't add properties to Java packages. Sorry. + } + + public void put(int index, Scriptable start, Object value) { + throw Context.reportRuntimeError0("msg.pkg.int"); + } + + public Object get(String id, Scriptable start) { + return getPkgProperty(id, start, true); + } + + public Object get(int index, Scriptable start) { + return NOT_FOUND; + } + + // set up a name which is known to be a package so we don't + // need to look for a class by that name + void forcePackage(String name, Scriptable scope) + { + NativeJavaPackage pkg; + int end = name.indexOf('.'); + if (end == -1) { + end = name.length(); + } + + String id = name.substring(0, end); + Object cached = super.get(id, this); + if (cached != null && cached instanceof NativeJavaPackage) { + pkg = (NativeJavaPackage) cached; + } else { + String newPackage = packageName.length() == 0 + ? id + : packageName + "." + id; + pkg = new NativeJavaPackage(true, newPackage, classLoader); + ScriptRuntime.setObjectProtoAndParent(pkg, scope); + super.put(id, this, pkg); + } + if (end < name.length()) { + pkg.forcePackage(name.substring(end+1), scope); + } + } + + synchronized Object getPkgProperty(String name, Scriptable start, + boolean createPkg) + { + Object cached = super.get(name, start); + if (cached != NOT_FOUND) + return cached; + + String className = (packageName.length() == 0) + ? name : packageName + '.' + name; + Context cx = Context.getContext(); + ClassShutter shutter = cx.getClassShutter(); + Scriptable newValue = null; + if (shutter == null || shutter.visibleToScripts(className)) { + Class cl = null; + if (classLoader != null) { + cl = Kit.classOrNull(classLoader, className); + } else { + cl = Kit.classOrNull(className); + } + if (cl != null) { + newValue = new NativeJavaClass(getTopLevelScope(this), cl); + newValue.setPrototype(getPrototype()); + } + } + if (newValue == null && createPkg) { + NativeJavaPackage pkg; + pkg = new NativeJavaPackage(true, className, classLoader); + ScriptRuntime.setObjectProtoAndParent(pkg, getParentScope()); + newValue = pkg; + } + if (newValue != null) { + // Make it available for fast lookup and sharing of + // lazily-reflected constructors and static members. + super.put(name, start, newValue); + } + return newValue; + } + + public Object getDefaultValue(Class ignored) { + return toString(); + } + + public String toString() { + return "[JavaPackage " + packageName + "]"; + } + + public boolean equals(Object obj) { + if(obj instanceof NativeJavaPackage) { + NativeJavaPackage njp = (NativeJavaPackage)obj; + return packageName.equals(njp.packageName) && classLoader == njp.classLoader; + } + return false; + } + + public int hashCode() { + return packageName.hashCode() ^ (classLoader == null ? 0 : classLoader.hashCode()); + } + + private String packageName; + private ClassLoader classLoader; +}
\ No newline at end of file diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaTopPackage.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaTopPackage.java new file mode 100644 index 0000000..b5c9b49 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeJavaTopPackage.java @@ -0,0 +1,187 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Frank Mitchell + * Mike Shaver + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class reflects Java packages into the JavaScript environment. We + * lazily reflect classes and subpackages, and use a caching/sharing + * system to ensure that members reflected into one JavaPackage appear + * in all other references to the same package (as with Packages.java.lang + * and java.lang). + * + * @author Mike Shaver + * @see NativeJavaArray + * @see NativeJavaObject + * @see NativeJavaClass + */ + +public class NativeJavaTopPackage + extends NativeJavaPackage implements Function, IdFunctionCall +{ + static final long serialVersionUID = -1455787259477709999L; + + // we know these are packages so we can skip the class check + // note that this is ok even if the package isn't present. + private static final String commonPackages = "" + +"java.lang;" + +"java.lang.reflect;" + +"java.io;" + +"java.math;" + +"java.net;" + +"java.util;" + +"java.util.zip;" + +"java.text;" + +"java.text.resources;" + +"java.applet;" + +"javax.swing;" + ; + + NativeJavaTopPackage(ClassLoader loader) + { + super(true, "", loader); + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return construct(cx, scope, args); + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + ClassLoader loader = null; + if (args.length != 0) { + Object arg = args[0]; + if (arg instanceof Wrapper) { + arg = ((Wrapper)arg).unwrap(); + } + if (arg instanceof ClassLoader) { + loader = (ClassLoader)arg; + } + } + if (loader == null) { + Context.reportRuntimeError0("msg.not.classloader"); + return null; + } + return new NativeJavaPackage(true, "", loader); + } + + public static void init(Context cx, Scriptable scope, boolean sealed) + { + ClassLoader loader = cx.getApplicationClassLoader(); + final NativeJavaTopPackage top = new NativeJavaTopPackage(loader); + top.setPrototype(getObjectPrototype(scope)); + top.setParentScope(scope); + + String[] names = Kit.semicolonSplit(commonPackages); + for (int i = 0; i != names.length; ++i) { + top.forcePackage(names[i], scope); + } + + // getClass implementation + IdFunctionObject getClass = new IdFunctionObject(top, FTAG, Id_getClass, + "getClass", 1, scope); + + // We want to get a real alias, and not a distinct JavaPackage + // with the same packageName, so that we share classes and top + // that are underneath. + String[] topNames = { "java", "javax", "org", "com", "edu", "net" }; + NativeJavaPackage[] topPackages = new NativeJavaPackage[topNames.length]; + for (int i=0; i < topNames.length; i++) { + topPackages[i] = (NativeJavaPackage)top.get(topNames[i], top); + } + + // It's safe to downcast here since initStandardObjects takes + // a ScriptableObject. + ScriptableObject global = (ScriptableObject) scope; + + if (sealed) { + getClass.sealObject(); + } + getClass.exportAsScopeProperty(); + global.defineProperty("Packages", top, ScriptableObject.DONTENUM); + for (int i=0; i < topNames.length; i++) { + global.defineProperty(topNames[i], topPackages[i], + ScriptableObject.DONTENUM); + } + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (f.hasTag(FTAG)) { + if (f.methodId() == Id_getClass) { + return js_getClass(cx, scope, args); + } + } + throw f.unknown(); + } + + private Scriptable js_getClass(Context cx, Scriptable scope, Object[] args) + { + if (args.length > 0 && args[0] instanceof Wrapper) { + Scriptable result = this; + Class cl = ((Wrapper) args[0]).unwrap().getClass(); + // Evaluate the class name by getting successive properties of + // the string to find the appropriate NativeJavaClass object + String name = cl.getName(); + int offset = 0; + for (;;) { + int index = name.indexOf('.', offset); + String propName = index == -1 + ? name.substring(offset) + : name.substring(offset, index); + Object prop = result.get(propName, result); + if (!(prop instanceof Scriptable)) + break; // fall through to error + result = (Scriptable) prop; + if (index == -1) + return result; + offset = index+1; + } + } + throw Context.reportRuntimeError0("msg.not.java.obj"); + } + + private static final Object FTAG = new Object(); + private static final int Id_getClass = 1; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeMath.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeMath.java new file mode 100644 index 0000000..36b66b4 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeMath.java @@ -0,0 +1,399 @@ +/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the Math native object. + * See ECMA 15.8. + * @author Norris Boyd + */ + +final class NativeMath extends IdScriptableObject +{ + static final long serialVersionUID = -8838847185801131569L; + + private static final Object MATH_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeMath obj = new NativeMath(); + obj.activatePrototypeMap(MAX_ID); + obj.setPrototype(getObjectPrototype(scope)); + obj.setParentScope(scope); + if (sealed) { obj.sealObject(); } + ScriptableObject.defineProperty(scope, "Math", obj, + ScriptableObject.DONTENUM); + } + + private NativeMath() + { + } + + public String getClassName() { return "Math"; } + + protected void initPrototypeId(int id) + { + if (id <= LAST_METHOD_ID) { + String name; + int arity; + switch (id) { + case Id_toSource: arity = 0; name = "toSource"; break; + case Id_abs: arity = 1; name = "abs"; break; + case Id_acos: arity = 1; name = "acos"; break; + case Id_asin: arity = 1; name = "asin"; break; + case Id_atan: arity = 1; name = "atan"; break; + case Id_atan2: arity = 2; name = "atan2"; break; + case Id_ceil: arity = 1; name = "ceil"; break; + case Id_cos: arity = 1; name = "cos"; break; + case Id_exp: arity = 1; name = "exp"; break; + case Id_floor: arity = 1; name = "floor"; break; + case Id_log: arity = 1; name = "log"; break; + case Id_max: arity = 2; name = "max"; break; + case Id_min: arity = 2; name = "min"; break; + case Id_pow: arity = 2; name = "pow"; break; + case Id_random: arity = 0; name = "random"; break; + case Id_round: arity = 1; name = "round"; break; + case Id_sin: arity = 1; name = "sin"; break; + case Id_sqrt: arity = 1; name = "sqrt"; break; + case Id_tan: arity = 1; name = "tan"; break; + default: throw new IllegalStateException(String.valueOf(id)); + } + initPrototypeMethod(MATH_TAG, id, name, arity); + } else { + String name; + double x; + switch (id) { + case Id_E: x = Math.E; name = "E"; break; + case Id_PI: x = Math.PI; name = "PI"; break; + case Id_LN10: x = 2.302585092994046; name = "LN10"; break; + case Id_LN2: x = 0.6931471805599453; name = "LN2"; break; + case Id_LOG2E: x = 1.4426950408889634; name = "LOG2E"; break; + case Id_LOG10E: x = 0.4342944819032518; name = "LOG10E"; break; + case Id_SQRT1_2: x = 0.7071067811865476; name = "SQRT1_2"; break; + case Id_SQRT2: x = 1.4142135623730951; name = "SQRT2"; break; + default: throw new IllegalStateException(String.valueOf(id)); + } + initPrototypeValue(id, name, ScriptRuntime.wrapNumber(x), + DONTENUM | READONLY | PERMANENT); + } + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(MATH_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + double x; + int methodId = f.methodId(); + switch (methodId) { + case Id_toSource: + return "Math"; + + case Id_abs: + x = ScriptRuntime.toNumber(args, 0); + // abs(-0.0) should be 0.0, but -0.0 < 0.0 == false + x = (x == 0.0) ? 0.0 : (x < 0.0) ? -x : x; + break; + + case Id_acos: + case Id_asin: + x = ScriptRuntime.toNumber(args, 0); + if (x == x && -1.0 <= x && x <= 1.0) { + x = (methodId == Id_acos) ? Math.acos(x) : Math.asin(x); + } else { + x = Double.NaN; + } + break; + + case Id_atan: + x = ScriptRuntime.toNumber(args, 0); + x = Math.atan(x); + break; + + case Id_atan2: + x = ScriptRuntime.toNumber(args, 0); + x = Math.atan2(x, ScriptRuntime.toNumber(args, 1)); + break; + + case Id_ceil: + x = ScriptRuntime.toNumber(args, 0); + x = Math.ceil(x); + break; + + case Id_cos: + x = ScriptRuntime.toNumber(args, 0); + x = (x == Double.POSITIVE_INFINITY + || x == Double.NEGATIVE_INFINITY) + ? Double.NaN : Math.cos(x); + break; + + case Id_exp: + x = ScriptRuntime.toNumber(args, 0); + x = (x == Double.POSITIVE_INFINITY) ? x + : (x == Double.NEGATIVE_INFINITY) ? 0.0 + : Math.exp(x); + break; + + case Id_floor: + x = ScriptRuntime.toNumber(args, 0); + x = Math.floor(x); + break; + + case Id_log: + x = ScriptRuntime.toNumber(args, 0); + // Java's log(<0) = -Infinity; we need NaN + x = (x < 0) ? Double.NaN : Math.log(x); + break; + + case Id_max: + case Id_min: + x = (methodId == Id_max) + ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY; + for (int i = 0; i != args.length; ++i) { + double d = ScriptRuntime.toNumber(args[i]); + if (d != d) { + x = d; // NaN + break; + } + if (methodId == Id_max) { + // if (x < d) x = d; does not work due to -0.0 >= +0.0 + x = Math.max(x, d); + } else { + x = Math.min(x, d); + } + } + break; + + case Id_pow: + x = ScriptRuntime.toNumber(args, 0); + x = js_pow(x, ScriptRuntime.toNumber(args, 1)); + break; + + case Id_random: + x = Math.random(); + break; + + case Id_round: + x = ScriptRuntime.toNumber(args, 0); + if (x == x && x != Double.POSITIVE_INFINITY + && x != Double.NEGATIVE_INFINITY) + { + // Round only finite x + long l = Math.round(x); + if (l != 0) { + x = l; + } else { + // We must propagate the sign of d into the result + if (x < 0.0) { + x = ScriptRuntime.negativeZero; + } else if (x != 0.0) { + x = 0.0; + } + } + } + break; + + case Id_sin: + x = ScriptRuntime.toNumber(args, 0); + x = (x == Double.POSITIVE_INFINITY + || x == Double.NEGATIVE_INFINITY) + ? Double.NaN : Math.sin(x); + break; + + case Id_sqrt: + x = ScriptRuntime.toNumber(args, 0); + x = Math.sqrt(x); + break; + + case Id_tan: + x = ScriptRuntime.toNumber(args, 0); + x = Math.tan(x); + break; + + default: throw new IllegalStateException(String.valueOf(methodId)); + } + return ScriptRuntime.wrapNumber(x); + } + + // See Ecma 15.8.2.13 + private double js_pow(double x, double y) { + double result; + if (y != y) { + // y is NaN, result is always NaN + result = y; + } else if (y == 0) { + // Java's pow(NaN, 0) = NaN; we need 1 + result = 1.0; + } else if (x == 0) { + // Many dirrerences from Java's Math.pow + if (1 / x > 0) { + result = (y > 0) ? 0 : Double.POSITIVE_INFINITY; + } else { + // x is -0, need to check if y is an odd integer + long y_long = (long)y; + if (y_long == y && (y_long & 0x1) != 0) { + result = (y > 0) ? -0.0 : Double.NEGATIVE_INFINITY; + } else { + result = (y > 0) ? 0.0 : Double.POSITIVE_INFINITY; + } + } + } else { + result = Math.pow(x, y); + if (result != result) { + // Check for broken Java implementations that gives NaN + // when they should return something else + if (y == Double.POSITIVE_INFINITY) { + if (x < -1.0 || 1.0 < x) { + result = Double.POSITIVE_INFINITY; + } else if (-1.0 < x && x < 1.0) { + result = 0; + } + } else if (y == Double.NEGATIVE_INFINITY) { + if (x < -1.0 || 1.0 < x) { + result = 0; + } else if (-1.0 < x && x < 1.0) { + result = Double.POSITIVE_INFINITY; + } + } else if (x == Double.POSITIVE_INFINITY) { + result = (y > 0) ? Double.POSITIVE_INFINITY : 0.0; + } else if (x == Double.NEGATIVE_INFINITY) { + long y_long = (long)y; + if (y_long == y && (y_long & 0x1) != 0) { + // y is odd integer + result = (y > 0) ? Double.NEGATIVE_INFINITY : -0.0; + } else { + result = (y > 0) ? Double.POSITIVE_INFINITY : 0.0; + } + } + } + } + return result; + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2004-03-17 13:51:32 CET + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 1: if (s.charAt(0)=='E') {id=Id_E; break L0;} break L; + case 2: if (s.charAt(0)=='P' && s.charAt(1)=='I') {id=Id_PI; break L0;} break L; + case 3: switch (s.charAt(0)) { + case 'L': if (s.charAt(2)=='2' && s.charAt(1)=='N') {id=Id_LN2; break L0;} break L; + case 'a': if (s.charAt(2)=='s' && s.charAt(1)=='b') {id=Id_abs; break L0;} break L; + case 'c': if (s.charAt(2)=='s' && s.charAt(1)=='o') {id=Id_cos; break L0;} break L; + case 'e': if (s.charAt(2)=='p' && s.charAt(1)=='x') {id=Id_exp; break L0;} break L; + case 'l': if (s.charAt(2)=='g' && s.charAt(1)=='o') {id=Id_log; break L0;} break L; + case 'm': c=s.charAt(2); + if (c=='n') { if (s.charAt(1)=='i') {id=Id_min; break L0;} } + else if (c=='x') { if (s.charAt(1)=='a') {id=Id_max; break L0;} } + break L; + case 'p': if (s.charAt(2)=='w' && s.charAt(1)=='o') {id=Id_pow; break L0;} break L; + case 's': if (s.charAt(2)=='n' && s.charAt(1)=='i') {id=Id_sin; break L0;} break L; + case 't': if (s.charAt(2)=='n' && s.charAt(1)=='a') {id=Id_tan; break L0;} break L; + } break L; + case 4: switch (s.charAt(1)) { + case 'N': X="LN10";id=Id_LN10; break L; + case 'c': X="acos";id=Id_acos; break L; + case 'e': X="ceil";id=Id_ceil; break L; + case 'q': X="sqrt";id=Id_sqrt; break L; + case 's': X="asin";id=Id_asin; break L; + case 't': X="atan";id=Id_atan; break L; + } break L; + case 5: switch (s.charAt(0)) { + case 'L': X="LOG2E";id=Id_LOG2E; break L; + case 'S': X="SQRT2";id=Id_SQRT2; break L; + case 'a': X="atan2";id=Id_atan2; break L; + case 'f': X="floor";id=Id_floor; break L; + case 'r': X="round";id=Id_round; break L; + } break L; + case 6: c=s.charAt(0); + if (c=='L') { X="LOG10E";id=Id_LOG10E; } + else if (c=='r') { X="random";id=Id_random; } + break L; + case 7: X="SQRT1_2";id=Id_SQRT1_2; break L; + case 8: X="toSource";id=Id_toSource; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + } +// #/generated# + return id; + } + + private static final int + Id_toSource = 1, + Id_abs = 2, + Id_acos = 3, + Id_asin = 4, + Id_atan = 5, + Id_atan2 = 6, + Id_ceil = 7, + Id_cos = 8, + Id_exp = 9, + Id_floor = 10, + Id_log = 11, + Id_max = 12, + Id_min = 13, + Id_pow = 14, + Id_random = 15, + Id_round = 16, + Id_sin = 17, + Id_sqrt = 18, + Id_tan = 19, + + LAST_METHOD_ID = 19; + + private static final int + Id_E = LAST_METHOD_ID + 1, + Id_PI = LAST_METHOD_ID + 2, + Id_LN10 = LAST_METHOD_ID + 3, + Id_LN2 = LAST_METHOD_ID + 4, + Id_LOG2E = LAST_METHOD_ID + 5, + Id_LOG10E = LAST_METHOD_ID + 6, + Id_SQRT1_2 = LAST_METHOD_ID + 7, + Id_SQRT2 = LAST_METHOD_ID + 8, + + MAX_ID = LAST_METHOD_ID + 8; + +// #/string_id_map# +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeNumber.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeNumber.java new file mode 100644 index 0000000..8fc9fb0 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeNumber.java @@ -0,0 +1,244 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the Number native object. + * + * See ECMA 15.7. + * + * @author Norris Boyd + */ +final class NativeNumber extends IdScriptableObject +{ + static final long serialVersionUID = 3504516769741512101L; + + private static final Object NUMBER_TAG = new Object(); + + private static final int MAX_PRECISION = 100; + + static void init(Scriptable scope, boolean sealed) + { + NativeNumber obj = new NativeNumber(0.0); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + private NativeNumber(double number) + { + doubleValue = number; + } + + public String getClassName() + { + return "Number"; + } + + protected void fillConstructorProperties(IdFunctionObject ctor) + { + final int attr = ScriptableObject.DONTENUM | + ScriptableObject.PERMANENT | + ScriptableObject.READONLY; + + ctor.defineProperty("NaN", ScriptRuntime.NaNobj, attr); + ctor.defineProperty("POSITIVE_INFINITY", + ScriptRuntime.wrapNumber(Double.POSITIVE_INFINITY), + attr); + ctor.defineProperty("NEGATIVE_INFINITY", + ScriptRuntime.wrapNumber(Double.NEGATIVE_INFINITY), + attr); + ctor.defineProperty("MAX_VALUE", + ScriptRuntime.wrapNumber(Double.MAX_VALUE), + attr); + ctor.defineProperty("MIN_VALUE", + ScriptRuntime.wrapNumber(Double.MIN_VALUE), + attr); + + super.fillConstructorProperties(ctor); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=1; s="toString"; break; + case Id_toLocaleString: arity=1; s="toLocaleString"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id_valueOf: arity=0; s="valueOf"; break; + case Id_toFixed: arity=1; s="toFixed"; break; + case Id_toExponential: arity=1; s="toExponential"; break; + case Id_toPrecision: arity=1; s="toPrecision"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(NUMBER_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(NUMBER_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + if (id == Id_constructor) { + double val = (args.length >= 1) + ? ScriptRuntime.toNumber(args[0]) : 0.0; + if (thisObj == null) { + // new Number(val) creates a new Number object. + return new NativeNumber(val); + } + // Number(val) converts val to a number value. + return ScriptRuntime.wrapNumber(val); + } + + // The rest of Number.prototype methods require thisObj to be Number + + if (!(thisObj instanceof NativeNumber)) + throw incompatibleCallError(f); + double value = ((NativeNumber)thisObj).doubleValue; + + switch (id) { + + case Id_toString: + case Id_toLocaleString: + { + // toLocaleString is just an alias for toString for now + int base = (args.length == 0) + ? 10 : ScriptRuntime.toInt32(args[0]); + return ScriptRuntime.numberToString(value, base); + } + + case Id_toSource: + return "(new Number("+ScriptRuntime.toString(value)+"))"; + + case Id_valueOf: + return ScriptRuntime.wrapNumber(value); + + case Id_toFixed: + return num_to(value, args, DToA.DTOSTR_FIXED, + DToA.DTOSTR_FIXED, -20, 0); + + case Id_toExponential: + return num_to(value, args, DToA.DTOSTR_STANDARD_EXPONENTIAL, + DToA.DTOSTR_EXPONENTIAL, 0, 1); + + case Id_toPrecision: + return num_to(value, args, DToA.DTOSTR_STANDARD, + DToA.DTOSTR_PRECISION, 1, 0); + + default: throw new IllegalArgumentException(String.valueOf(id)); + } + } + + public String toString() { + return ScriptRuntime.numberToString(doubleValue, 10); + } + + private static String num_to(double val, + Object[] args, + int zeroArgMode, int oneArgMode, + int precisionMin, int precisionOffset) + { + int precision; + if (args.length == 0) { + precision = 0; + oneArgMode = zeroArgMode; + } else { + /* We allow a larger range of precision than + ECMA requires; this is permitted by ECMA. */ + precision = ScriptRuntime.toInt32(args[0]); + if (precision < precisionMin || precision > MAX_PRECISION) { + String msg = ScriptRuntime.getMessage1( + "msg.bad.precision", ScriptRuntime.toString(args[0])); + throw ScriptRuntime.constructError("RangeError", msg); + } + } + StringBuffer sb = new StringBuffer(); + DToA.JS_dtostr(sb, oneArgMode, precision + precisionOffset, val); + return sb.toString(); + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:50 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 7: c=s.charAt(0); + if (c=='t') { X="toFixed";id=Id_toFixed; } + else if (c=='v') { X="valueOf";id=Id_valueOf; } + break L; + case 8: c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + break L; + case 11: c=s.charAt(0); + if (c=='c') { X="constructor";id=Id_constructor; } + else if (c=='t') { X="toPrecision";id=Id_toPrecision; } + break L; + case 13: X="toExponential";id=Id_toExponential; break L; + case 14: X="toLocaleString";id=Id_toLocaleString; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_toLocaleString = 3, + Id_toSource = 4, + Id_valueOf = 5, + Id_toFixed = 6, + Id_toExponential = 7, + Id_toPrecision = 8, + MAX_PROTOTYPE_ID = 8; + +// #/string_id_map# + + private double doubleValue; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeObject.java new file mode 100644 index 0000000..19aff63 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeObject.java @@ -0,0 +1,316 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Bob Jervis + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the Object native object. + * See ECMA 15.2. + * @author Norris Boyd + */ +public class NativeObject extends IdScriptableObject +{ + static final long serialVersionUID = -6345305608474346996L; + + private static final Object OBJECT_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeObject obj = new NativeObject(); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + public String getClassName() + { + return "Object"; + } + + public String toString() + { + return ScriptRuntime.defaultObjectToString(this); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toLocaleString: arity=0; s="toLocaleString"; break; + case Id_valueOf: arity=0; s="valueOf"; break; + case Id_hasOwnProperty: arity=1; s="hasOwnProperty"; break; + case Id_propertyIsEnumerable: + arity=1; s="propertyIsEnumerable"; break; + case Id_isPrototypeOf: arity=1; s="isPrototypeOf"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id___defineGetter__: + arity=2; s="__defineGetter__"; break; + case Id___defineSetter__: + arity=2; s="__defineSetter__"; break; + case Id___lookupGetter__: + arity=1; s="__lookupGetter__"; break; + case Id___lookupSetter__: + arity=1; s="__lookupSetter__"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(OBJECT_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(OBJECT_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_constructor: { + if (thisObj != null) { + // BaseFunction.construct will set up parent, proto + return f.construct(cx, scope, args); + } + if (args.length == 0 || args[0] == null + || args[0] == Undefined.instance) + { + return new NativeObject(); + } + return ScriptRuntime.toObject(cx, scope, args[0]); + } + + case Id_toLocaleString: // For now just alias toString + case Id_toString: { + if (cx.hasFeature(Context.FEATURE_TO_STRING_AS_SOURCE)) { + String s = ScriptRuntime.defaultObjectToSource(cx, scope, + thisObj, args); + int L = s.length(); + if (L != 0 && s.charAt(0) == '(' && s.charAt(L - 1) == ')') { + // Strip () that surrounds toSource + s = s.substring(1, L - 1); + } + return s; + } + return ScriptRuntime.defaultObjectToString(thisObj); + } + + case Id_valueOf: + return thisObj; + + case Id_hasOwnProperty: { + boolean result; + if (args.length == 0) { + result = false; + } else { + String s = ScriptRuntime.toStringIdOrIndex(cx, args[0]); + if (s == null) { + int index = ScriptRuntime.lastIndexResult(cx); + result = thisObj.has(index, thisObj); + } else { + result = thisObj.has(s, thisObj); + } + } + return ScriptRuntime.wrapBoolean(result); + } + + case Id_propertyIsEnumerable: { + boolean result; + if (args.length == 0) { + result = false; + } else { + String s = ScriptRuntime.toStringIdOrIndex(cx, args[0]); + if (s == null) { + int index = ScriptRuntime.lastIndexResult(cx); + result = thisObj.has(index, thisObj); + if (result && thisObj instanceof ScriptableObject) { + ScriptableObject so = (ScriptableObject)thisObj; + int attrs = so.getAttributes(index); + result = ((attrs & ScriptableObject.DONTENUM) == 0); + } + } else { + result = thisObj.has(s, thisObj); + if (result && thisObj instanceof ScriptableObject) { + ScriptableObject so = (ScriptableObject)thisObj; + int attrs = so.getAttributes(s); + result = ((attrs & ScriptableObject.DONTENUM) == 0); + } + } + } + return ScriptRuntime.wrapBoolean(result); + } + + case Id_isPrototypeOf: { + boolean result = false; + if (args.length != 0 && args[0] instanceof Scriptable) { + Scriptable v = (Scriptable) args[0]; + do { + v = v.getPrototype(); + if (v == thisObj) { + result = true; + break; + } + } while (v != null); + } + return ScriptRuntime.wrapBoolean(result); + } + + case Id_toSource: + return ScriptRuntime.defaultObjectToSource(cx, scope, thisObj, + args); + case Id___defineGetter__: + case Id___defineSetter__: + { + if (args.length < 2 || !(args[1] instanceof Callable)) { + Object badArg = (args.length >= 2 ? args[1] + : Undefined.instance); + throw ScriptRuntime.notFunctionError(badArg); + } + if (!(thisObj instanceof ScriptableObject)) { + throw Context.reportRuntimeError2( + "msg.extend.scriptable", + thisObj.getClass().getName(), + String.valueOf(args[0])); + } + ScriptableObject so = (ScriptableObject)thisObj; + String name = ScriptRuntime.toStringIdOrIndex(cx, args[0]); + int index = (name != null ? 0 + : ScriptRuntime.lastIndexResult(cx)); + Callable getterOrSetter = (Callable)args[1]; + boolean isSetter = (id == Id___defineSetter__); + so.setGetterOrSetter(name, index, getterOrSetter, isSetter); + if (so instanceof NativeArray) + ((NativeArray)so).setDenseOnly(false); + } + return Undefined.instance; + + case Id___lookupGetter__: + case Id___lookupSetter__: + { + if (args.length < 1 || + !(thisObj instanceof ScriptableObject)) + return Undefined.instance; + + ScriptableObject so = (ScriptableObject)thisObj; + String name = ScriptRuntime.toStringIdOrIndex(cx, args[0]); + int index = (name != null ? 0 + : ScriptRuntime.lastIndexResult(cx)); + boolean isSetter = (id == Id___lookupSetter__); + Object gs; + for (;;) { + gs = so.getGetterOrSetter(name, index, isSetter); + if (gs != null) + break; + // If there is no getter or setter for the object itself, + // how about the prototype? + Scriptable v = so.getPrototype(); + if (v == null) + break; + if (v instanceof ScriptableObject) + so = (ScriptableObject)v; + else + break; + } + if (gs != null) + return gs; + } + return Undefined.instance; + + default: + throw new IllegalArgumentException(String.valueOf(id)); + } + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:15:55 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 7: X="valueOf";id=Id_valueOf; break L; + case 8: c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + break L; + case 11: X="constructor";id=Id_constructor; break L; + case 13: X="isPrototypeOf";id=Id_isPrototypeOf; break L; + case 14: c=s.charAt(0); + if (c=='h') { X="hasOwnProperty";id=Id_hasOwnProperty; } + else if (c=='t') { X="toLocaleString";id=Id_toLocaleString; } + break L; + case 16: c=s.charAt(2); + if (c=='d') { + c=s.charAt(8); + if (c=='G') { X="__defineGetter__";id=Id___defineGetter__; } + else if (c=='S') { X="__defineSetter__";id=Id___defineSetter__; } + } + else if (c=='l') { + c=s.charAt(8); + if (c=='G') { X="__lookupGetter__";id=Id___lookupGetter__; } + else if (c=='S') { X="__lookupSetter__";id=Id___lookupSetter__; } + } + break L; + case 20: X="propertyIsEnumerable";id=Id_propertyIsEnumerable; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_toLocaleString = 3, + Id_valueOf = 4, + Id_hasOwnProperty = 5, + Id_propertyIsEnumerable = 6, + Id_isPrototypeOf = 7, + Id_toSource = 8, + Id___defineGetter__ = 9, + Id___defineSetter__ = 10, + Id___lookupGetter__ = 11, + Id___lookupSetter__ = 12, + MAX_PROTOTYPE_ID = 12; + +// #/string_id_map# +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeScript.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeScript.java new file mode 100644 index 0000000..7b5191e --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeScript.java @@ -0,0 +1,221 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Roger Lawrence + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * The JavaScript Script object. + * + * Note that the C version of the engine uses XDR as the format used + * by freeze and thaw. Since this depends on the internal format of + * structures in the C runtime, we cannot duplicate it. + * + * Since we cannot replace 'this' as a result of the compile method, + * will forward requests to execute to the nonnull 'script' field. + * + * @since 1.3 + * @author Norris Boyd + */ + +class NativeScript extends BaseFunction +{ + static final long serialVersionUID = -6795101161980121700L; + + private static final Object SCRIPT_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeScript obj = new NativeScript(null); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + private NativeScript(Script script) + { + this.script = script; + } + + /** + * Returns the name of this JavaScript class, "Script". + */ + public String getClassName() + { + return "Script"; + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + if (script != null) { + return script.exec(cx, scope); + } + return Undefined.instance; + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + throw Context.reportRuntimeError0("msg.script.is.not.constructor"); + } + + public int getLength() + { + return 0; + } + + public int getArity() + { + return 0; + } + + String decompile(int indent, int flags) + { + if (script instanceof NativeFunction) { + return ((NativeFunction)script).decompile(indent, flags); + } + return super.decompile(indent, flags); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_exec: arity=0; s="exec"; break; + case Id_compile: arity=1; s="compile"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(SCRIPT_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(SCRIPT_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_constructor: { + String source = (args.length == 0) + ? "" + : ScriptRuntime.toString(args[0]); + Script script = compile(cx, source); + NativeScript nscript = new NativeScript(script); + ScriptRuntime.setObjectProtoAndParent(nscript, scope); + return nscript; + } + + case Id_toString: { + NativeScript real = realThis(thisObj, f); + Script realScript = real.script; + if (realScript == null) { return ""; } + return cx.decompileScript(realScript, 0); + } + + case Id_exec: { + throw Context.reportRuntimeError1( + "msg.cant.call.indirect", "exec"); + } + + case Id_compile: { + NativeScript real = realThis(thisObj, f); + String source = ScriptRuntime.toString(args, 0); + real.script = compile(cx, source); + return real; + } + } + throw new IllegalArgumentException(String.valueOf(id)); + } + + private static NativeScript realThis(Scriptable thisObj, IdFunctionObject f) + { + if (!(thisObj instanceof NativeScript)) + throw incompatibleCallError(f); + return (NativeScript)thisObj; + } + + private static Script compile(Context cx, String source) + { + int[] linep = { 0 }; + String filename = Context.getSourcePositionFromStack(linep); + if (filename == null) { + filename = "<Script object>"; + linep[0] = 1; + } + ErrorReporter reporter; + reporter = DefaultErrorReporter.forEval(cx.getErrorReporter()); + return cx.compileString(source, null, reporter, filename, + linep[0], null); + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:16:01 EDT + L0: { id = 0; String X = null; + L: switch (s.length()) { + case 4: X="exec";id=Id_exec; break L; + case 7: X="compile";id=Id_compile; break L; + case 8: X="toString";id=Id_toString; break L; + case 11: X="constructor";id=Id_constructor; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + Id_toString = 2, + Id_compile = 3, + Id_exec = 4, + MAX_PROTOTYPE_ID = 4; + +// #/string_id_map# + + private Script script; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeString.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeString.java new file mode 100644 index 0000000..972415d --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeString.java @@ -0,0 +1,983 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Tom Beauvais + * Norris Boyd + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.text.Collator; + +/** + * This class implements the String native object. + * + * See ECMA 15.5. + * + * String methods for dealing with regular expressions are + * ported directly from C. Latest port is from version 1.40.12.19 + * in the JSFUN13_BRANCH. + * + * @author Mike McCabe + * @author Norris Boyd + */ +final class NativeString extends IdScriptableObject +{ + static final long serialVersionUID = 920268368584188687L; + + private static final Object STRING_TAG = new Object(); + + static void init(Scriptable scope, boolean sealed) + { + NativeString obj = new NativeString(""); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + private NativeString(String s) { + string = s; + } + + public String getClassName() { + return "String"; + } + + private static final int + Id_length = 1, + MAX_INSTANCE_ID = 1; + + protected int getMaxInstanceId() + { + return MAX_INSTANCE_ID; + } + + protected int findInstanceIdInfo(String s) + { + if (s.equals("length")) { + return instanceIdInfo(DONTENUM | READONLY | PERMANENT, Id_length); + } + return super.findInstanceIdInfo(s); + } + + protected String getInstanceIdName(int id) + { + if (id == Id_length) { return "length"; } + return super.getInstanceIdName(id); + } + + protected Object getInstanceIdValue(int id) + { + if (id == Id_length) { + return ScriptRuntime.wrapInt(string.length()); + } + return super.getInstanceIdValue(id); + } + + protected void fillConstructorProperties(IdFunctionObject ctor) + { + addIdFunctionProperty(ctor, STRING_TAG, ConstructorId_fromCharCode, + "fromCharCode", 1); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_charAt, "charAt", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_charCodeAt, "charCodeAt", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_indexOf, "indexOf", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_lastIndexOf, "lastIndexOf", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_split, "split", 3); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_substring, "substring", 3); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_toLowerCase, "toLowerCase", 1); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_toUpperCase, "toUpperCase", 1); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_substr, "substr", 3); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_concat, "concat", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_slice, "slice", 3); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_equalsIgnoreCase, "equalsIgnoreCase", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_match, "match", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_search, "search", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_replace, "replace", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_localeCompare, "localeCompare", 2); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_toLocaleLowerCase, "toLocaleLowerCase", 1); + addIdFunctionProperty(ctor, STRING_TAG, + ConstructorId_fromCharCode, "fromCharCode", 1); + super.fillConstructorProperties(ctor); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=1; s="constructor"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id_valueOf: arity=0; s="valueOf"; break; + case Id_charAt: arity=1; s="charAt"; break; + case Id_charCodeAt: arity=1; s="charCodeAt"; break; + case Id_indexOf: arity=1; s="indexOf"; break; + case Id_lastIndexOf: arity=1; s="lastIndexOf"; break; + case Id_split: arity=2; s="split"; break; + case Id_substring: arity=2; s="substring"; break; + case Id_toLowerCase: arity=0; s="toLowerCase"; break; + case Id_toUpperCase: arity=0; s="toUpperCase"; break; + case Id_substr: arity=2; s="substr"; break; + case Id_concat: arity=1; s="concat"; break; + case Id_slice: arity=2; s="slice"; break; + case Id_bold: arity=0; s="bold"; break; + case Id_italics: arity=0; s="italics"; break; + case Id_fixed: arity=0; s="fixed"; break; + case Id_strike: arity=0; s="strike"; break; + case Id_small: arity=0; s="small"; break; + case Id_big: arity=0; s="big"; break; + case Id_blink: arity=0; s="blink"; break; + case Id_sup: arity=0; s="sup"; break; + case Id_sub: arity=0; s="sub"; break; + case Id_fontsize: arity=0; s="fontsize"; break; + case Id_fontcolor: arity=0; s="fontcolor"; break; + case Id_link: arity=0; s="link"; break; + case Id_anchor: arity=0; s="anchor"; break; + case Id_equals: arity=1; s="equals"; break; + case Id_equalsIgnoreCase: arity=1; s="equalsIgnoreCase"; break; + case Id_match: arity=1; s="match"; break; + case Id_search: arity=1; s="search"; break; + case Id_replace: arity=1; s="replace"; break; + case Id_localeCompare: arity=1; s="localeCompare"; break; + case Id_toLocaleLowerCase: arity=0; s="toLocaleLowerCase"; break; + case Id_toLocaleUpperCase: arity=0; s="toLocaleUpperCase"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(STRING_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(STRING_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + again: + for(;;) { + switch (id) { + case ConstructorId_charAt: + case ConstructorId_charCodeAt: + case ConstructorId_indexOf: + case ConstructorId_lastIndexOf: + case ConstructorId_split: + case ConstructorId_substring: + case ConstructorId_toLowerCase: + case ConstructorId_toUpperCase: + case ConstructorId_substr: + case ConstructorId_concat: + case ConstructorId_slice: + case ConstructorId_equalsIgnoreCase: + case ConstructorId_match: + case ConstructorId_search: + case ConstructorId_replace: + case ConstructorId_localeCompare: + case ConstructorId_toLocaleLowerCase: { + thisObj = ScriptRuntime.toObject(scope, + ScriptRuntime.toString(args[0])); + Object[] newArgs = new Object[args.length-1]; + for (int i=0; i < newArgs.length; i++) + newArgs[i] = args[i+1]; + args = newArgs; + id = -id; + continue again; + } + + case ConstructorId_fromCharCode: { + int N = args.length; + if (N < 1) + return ""; + StringBuffer sb = new StringBuffer(N); + for (int i = 0; i != N; ++i) { + sb.append(ScriptRuntime.toUint16(args[i])); + } + return sb.toString(); + } + + case Id_constructor: { + String s = (args.length >= 1) + ? ScriptRuntime.toString(args[0]) : ""; + if (thisObj == null) { + // new String(val) creates a new String object. + return new NativeString(s); + } + // String(val) converts val to a string value. + return s; + } + + case Id_toString: + case Id_valueOf: + // ECMA 15.5.4.2: 'the toString function is not generic. + return realThis(thisObj, f).string; + + case Id_toSource: { + String s = realThis(thisObj, f).string; + return "(new String(\""+ScriptRuntime.escapeString(s)+"\"))"; + } + + case Id_charAt: + case Id_charCodeAt: { + // See ECMA 15.5.4.[4,5] + String target = ScriptRuntime.toString(thisObj); + double pos = ScriptRuntime.toInteger(args, 0); + if (pos < 0 || pos >= target.length()) { + if (id == Id_charAt) return ""; + else return ScriptRuntime.NaNobj; + } + char c = target.charAt((int)pos); + if (id == Id_charAt) return String.valueOf(c); + else return ScriptRuntime.wrapInt(c); + } + + case Id_indexOf: + return ScriptRuntime.wrapInt(js_indexOf( + ScriptRuntime.toString(thisObj), args)); + + case Id_lastIndexOf: + return ScriptRuntime.wrapInt(js_lastIndexOf( + ScriptRuntime.toString(thisObj), args)); + + case Id_split: + return js_split(cx, scope, ScriptRuntime.toString(thisObj), + args); + + case Id_substring: + return js_substring(cx, ScriptRuntime.toString(thisObj), args); + + case Id_toLowerCase: + // See ECMA 15.5.4.11 + return ScriptRuntime.toString(thisObj).toLowerCase(); + + case Id_toUpperCase: + // See ECMA 15.5.4.12 + return ScriptRuntime.toString(thisObj).toUpperCase(); + + case Id_substr: + return js_substr(ScriptRuntime.toString(thisObj), args); + + case Id_concat: + return js_concat(ScriptRuntime.toString(thisObj), args); + + case Id_slice: + return js_slice(ScriptRuntime.toString(thisObj), args); + + case Id_bold: + return tagify(thisObj, "b", null, null); + + case Id_italics: + return tagify(thisObj, "i", null, null); + + case Id_fixed: + return tagify(thisObj, "tt", null, null); + + case Id_strike: + return tagify(thisObj, "strike", null, null); + + case Id_small: + return tagify(thisObj, "small", null, null); + + case Id_big: + return tagify(thisObj, "big", null, null); + + case Id_blink: + return tagify(thisObj, "blink", null, null); + + case Id_sup: + return tagify(thisObj, "sup", null, null); + + case Id_sub: + return tagify(thisObj, "sub", null, null); + + case Id_fontsize: + return tagify(thisObj, "font", "size", args); + + case Id_fontcolor: + return tagify(thisObj, "font", "color", args); + + case Id_link: + return tagify(thisObj, "a", "href", args); + + case Id_anchor: + return tagify(thisObj, "a", "name", args); + + case Id_equals: + case Id_equalsIgnoreCase: { + String s1 = ScriptRuntime.toString(thisObj); + String s2 = ScriptRuntime.toString(args, 0); + return ScriptRuntime.wrapBoolean( + (id == Id_equals) ? s1.equals(s2) + : s1.equalsIgnoreCase(s2)); + } + + case Id_match: + case Id_search: + case Id_replace: + { + int actionType; + if (id == Id_match) { + actionType = RegExpProxy.RA_MATCH; + } else if (id == Id_search) { + actionType = RegExpProxy.RA_SEARCH; + } else { + actionType = RegExpProxy.RA_REPLACE; + } + return ScriptRuntime.checkRegExpProxy(cx). + action(cx, scope, thisObj, args, actionType); + } + // ECMA-262 1 5.5.4.9 + case Id_localeCompare: + { + // For now, create and configure a collator instance. I can't + // actually imagine that this'd be slower than caching them + // a la ClassCache, so we aren't trying to outsmart ourselves + // with a caching mechanism for now. + Collator collator = Collator.getInstance(cx.getLocale()); + collator.setStrength(Collator.IDENTICAL); + collator.setDecomposition(Collator.CANONICAL_DECOMPOSITION); + return ScriptRuntime.wrapNumber(collator.compare( + ScriptRuntime.toString(thisObj), + ScriptRuntime.toString(args, 0))); + } + case Id_toLocaleLowerCase: + { + return ScriptRuntime.toString(thisObj) + .toLowerCase(cx.getLocale()); + } + case Id_toLocaleUpperCase: + { + return ScriptRuntime.toString(thisObj) + .toUpperCase(cx.getLocale()); + } + } + throw new IllegalArgumentException(String.valueOf(id)); + } + } + + private static NativeString realThis(Scriptable thisObj, IdFunctionObject f) + { + if (!(thisObj instanceof NativeString)) + throw incompatibleCallError(f); + return (NativeString)thisObj; + } + + /* + * HTML composition aids. + */ + private static String tagify(Object thisObj, String tag, + String attribute, Object[] args) + { + String str = ScriptRuntime.toString(thisObj); + StringBuffer result = new StringBuffer(); + result.append('<'); + result.append(tag); + if (attribute != null) { + result.append(' '); + result.append(attribute); + result.append("=\""); + result.append(ScriptRuntime.toString(args, 0)); + result.append('"'); + } + result.append('>'); + result.append(str); + result.append("</"); + result.append(tag); + result.append('>'); + return result.toString(); + } + + public String toString() { + return string; + } + + /* Make array-style property lookup work for strings. + * XXX is this ECMA? A version check is probably needed. In js too. + */ + public Object get(int index, Scriptable start) { + if (0 <= index && index < string.length()) { + return string.substring(index, index + 1); + } + return super.get(index, start); + } + + public void put(int index, Scriptable start, Object value) { + if (0 <= index && index < string.length()) { + return; + } + super.put(index, start, value); + } + + /* + * + * See ECMA 15.5.4.6. Uses Java String.indexOf() + * OPT to add - BMH searching from jsstr.c. + */ + private static int js_indexOf(String target, Object[] args) { + String search = ScriptRuntime.toString(args, 0); + double begin = ScriptRuntime.toInteger(args, 1); + + if (begin > target.length()) { + return -1; + } else { + if (begin < 0) + begin = 0; + return target.indexOf(search, (int)begin); + } + } + + /* + * + * See ECMA 15.5.4.7 + * + */ + private static int js_lastIndexOf(String target, Object[] args) { + String search = ScriptRuntime.toString(args, 0); + double end = ScriptRuntime.toNumber(args, 1); + + if (end != end || end > target.length()) + end = target.length(); + else if (end < 0) + end = 0; + + return target.lastIndexOf(search, (int)end); + } + + /* + * Used by js_split to find the next split point in target, + * starting at offset ip and looking either for the given + * separator substring, or for the next re match. ip and + * matchlen must be reference variables (assumed to be arrays of + * length 1) so they can be updated in the leading whitespace or + * re case. + * + * Return -1 on end of string, >= 0 for a valid index of the next + * separator occurrence if found, or the string length if no + * separator is found. + */ + private static int find_split(Context cx, Scriptable scope, String target, + String separator, int version, + RegExpProxy reProxy, Scriptable re, + int[] ip, int[] matchlen, boolean[] matched, + String[][] parensp) + { + int i = ip[0]; + int length = target.length(); + + /* + * Perl4 special case for str.split(' '), only if the user has selected + * JavaScript1.2 explicitly. Split on whitespace, and skip leading w/s. + * Strange but true, apparently modeled after awk. + */ + if (version == Context.VERSION_1_2 && + re == null && separator.length() == 1 && separator.charAt(0) == ' ') + { + /* Skip leading whitespace if at front of str. */ + if (i == 0) { + while (i < length && Character.isWhitespace(target.charAt(i))) + i++; + ip[0] = i; + } + + /* Don't delimit whitespace at end of string. */ + if (i == length) + return -1; + + /* Skip over the non-whitespace chars. */ + while (i < length + && !Character.isWhitespace(target.charAt(i))) + i++; + + /* Now skip the next run of whitespace. */ + int j = i; + while (j < length && Character.isWhitespace(target.charAt(j))) + j++; + + /* Update matchlen to count delimiter chars. */ + matchlen[0] = j - i; + return i; + } + + /* + * Stop if past end of string. If at end of string, we will + * return target length, so that + * + * "ab,".split(',') => new Array("ab", "") + * + * and the resulting array converts back to the string "ab," + * for symmetry. NB: This differs from perl, which drops the + * trailing empty substring if the LIMIT argument is omitted. + */ + if (i > length) + return -1; + + /* + * Match a regular expression against the separator at or + * above index i. Return -1 at end of string instead of + * trying for a match, so we don't get stuck in a loop. + */ + if (re != null) { + return reProxy.find_split(cx, scope, target, separator, re, + ip, matchlen, matched, parensp); + } + + /* + * Deviate from ECMA by never splitting an empty string by any separator + * string into a non-empty array (an array of length 1 that contains the + * empty string). + */ + if (version != Context.VERSION_DEFAULT && version < Context.VERSION_1_3 + && length == 0) + return -1; + + /* + * Special case: if sep is the empty string, split str into + * one character substrings. Let our caller worry about + * whether to split once at end of string into an empty + * substring. + * + * For 1.2 compatibility, at the end of the string, we return the length as + * the result, and set the separator length to 1 -- this allows the caller + * to include an additional null string at the end of the substring list. + */ + if (separator.length() == 0) { + if (version == Context.VERSION_1_2) { + if (i == length) { + matchlen[0] = 1; + return i; + } + return i + 1; + } + return (i == length) ? -1 : i + 1; + } + + /* Punt to j.l.s.indexOf; return target length if separator is + * not found. + */ + if (ip[0] >= length) + return length; + + i = target.indexOf(separator, ip[0]); + + return (i != -1) ? i : length; + } + + /* + * See ECMA 15.5.4.8. Modified to match JS 1.2 - optionally takes + * a limit argument and accepts a regular expression as the split + * argument. + */ + private static Object js_split(Context cx, Scriptable scope, + String target, Object[] args) + { + // create an empty Array to return; + Scriptable top = getTopLevelScope(scope); + Scriptable result = ScriptRuntime.newObject(cx, top, "Array", null); + + // return an array consisting of the target if no separator given + // don't check against undefined, because we want + // 'fooundefinedbar'.split(void 0) to split to ['foo', 'bar'] + if (args.length < 1) { + result.put(0, result, target); + return result; + } + + // Use the second argument as the split limit, if given. + boolean limited = (args.length > 1) && (args[1] != Undefined.instance); + long limit = 0; // Initialize to avoid warning. + if (limited) { + /* Clamp limit between 0 and 1 + string length. */ + limit = ScriptRuntime.toUint32(args[1]); + if (limit > target.length()) + limit = 1 + target.length(); + } + + String separator = null; + int[] matchlen = new int[1]; + Scriptable re = null; + RegExpProxy reProxy = null; + if (args[0] instanceof Scriptable) { + reProxy = ScriptRuntime.getRegExpProxy(cx); + if (reProxy != null) { + Scriptable test = (Scriptable)args[0]; + if (reProxy.isRegExp(test)) { + re = test; + } + } + } + if (re == null) { + separator = ScriptRuntime.toString(args[0]); + matchlen[0] = separator.length(); + } + + // split target with separator or re + int[] ip = { 0 }; + int match; + int len = 0; + boolean[] matched = { false }; + String[][] parens = { null }; + int version = cx.getLanguageVersion(); + while ((match = find_split(cx, scope, target, separator, version, + reProxy, re, ip, matchlen, matched, parens)) + >= 0) + { + if ((limited && len >= limit) || (match > target.length())) + break; + + String substr; + if (target.length() == 0) + substr = target; + else + substr = target.substring(ip[0], match); + + result.put(len, result, substr); + len++; + /* + * Imitate perl's feature of including parenthesized substrings + * that matched part of the delimiter in the new array, after the + * split substring that was delimited. + */ + if (re != null && matched[0] == true) { + int size = parens[0].length; + for (int num = 0; num < size; num++) { + if (limited && len >= limit) + break; + result.put(len, result, parens[0][num]); + len++; + } + matched[0] = false; + } + ip[0] = match + matchlen[0]; + + if (version < Context.VERSION_1_3 + && version != Context.VERSION_DEFAULT) + { + /* + * Deviate from ECMA to imitate Perl, which omits a final + * split unless a limit argument is given and big enough. + */ + if (!limited && ip[0] == target.length()) + break; + } + } + return result; + } + + /* + * See ECMA 15.5.4.15 + */ + private static String js_substring(Context cx, String target, + Object[] args) + { + int length = target.length(); + double start = ScriptRuntime.toInteger(args, 0); + double end; + + if (start < 0) + start = 0; + else if (start > length) + start = length; + + if (args.length <= 1 || args[1] == Undefined.instance) { + end = length; + } else { + end = ScriptRuntime.toInteger(args[1]); + if (end < 0) + end = 0; + else if (end > length) + end = length; + + // swap if end < start + if (end < start) { + if (cx.getLanguageVersion() != Context.VERSION_1_2) { + double temp = start; + start = end; + end = temp; + } else { + // Emulate old JDK1.0 java.lang.String.substring() + end = start; + } + } + } + return target.substring((int)start, (int)end); + } + + int getLength() { + return string.length(); + } + + /* + * Non-ECMA methods. + */ + private static String js_substr(String target, Object[] args) { + if (args.length < 1) + return target; + + double begin = ScriptRuntime.toInteger(args[0]); + double end; + int length = target.length(); + + if (begin < 0) { + begin += length; + if (begin < 0) + begin = 0; + } else if (begin > length) { + begin = length; + } + + if (args.length == 1) { + end = length; + } else { + end = ScriptRuntime.toInteger(args[1]); + if (end < 0) + end = 0; + end += begin; + if (end > length) + end = length; + } + + return target.substring((int)begin, (int)end); + } + + /* + * Python-esque sequence operations. + */ + private static String js_concat(String target, Object[] args) { + int N = args.length; + if (N == 0) { return target; } + else if (N == 1) { + String arg = ScriptRuntime.toString(args[0]); + return target.concat(arg); + } + + // Find total capacity for the final string to avoid unnecessary + // re-allocations in StringBuffer + int size = target.length(); + String[] argsAsStrings = new String[N]; + for (int i = 0; i != N; ++i) { + String s = ScriptRuntime.toString(args[i]); + argsAsStrings[i] = s; + size += s.length(); + } + + StringBuffer result = new StringBuffer(size); + result.append(target); + for (int i = 0; i != N; ++i) { + result.append(argsAsStrings[i]); + } + return result.toString(); + } + + private static String js_slice(String target, Object[] args) { + if (args.length != 0) { + double begin = ScriptRuntime.toInteger(args[0]); + double end; + int length = target.length(); + if (begin < 0) { + begin += length; + if (begin < 0) + begin = 0; + } else if (begin > length) { + begin = length; + } + + if (args.length == 1) { + end = length; + } else { + end = ScriptRuntime.toInteger(args[1]); + if (end < 0) { + end += length; + if (end < 0) + end = 0; + } else if (end > length) { + end = length; + } + if (end < begin) + end = begin; + } + return target.substring((int)begin, (int)end); + } + return target; + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-01 22:11:49 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 3: c=s.charAt(2); + if (c=='b') { if (s.charAt(0)=='s' && s.charAt(1)=='u') {id=Id_sub; break L0;} } + else if (c=='g') { if (s.charAt(0)=='b' && s.charAt(1)=='i') {id=Id_big; break L0;} } + else if (c=='p') { if (s.charAt(0)=='s' && s.charAt(1)=='u') {id=Id_sup; break L0;} } + break L; + case 4: c=s.charAt(0); + if (c=='b') { X="bold";id=Id_bold; } + else if (c=='l') { X="link";id=Id_link; } + break L; + case 5: switch (s.charAt(4)) { + case 'd': X="fixed";id=Id_fixed; break L; + case 'e': X="slice";id=Id_slice; break L; + case 'h': X="match";id=Id_match; break L; + case 'k': X="blink";id=Id_blink; break L; + case 'l': X="small";id=Id_small; break L; + case 't': X="split";id=Id_split; break L; + } break L; + case 6: switch (s.charAt(1)) { + case 'e': X="search";id=Id_search; break L; + case 'h': X="charAt";id=Id_charAt; break L; + case 'n': X="anchor";id=Id_anchor; break L; + case 'o': X="concat";id=Id_concat; break L; + case 'q': X="equals";id=Id_equals; break L; + case 't': X="strike";id=Id_strike; break L; + case 'u': X="substr";id=Id_substr; break L; + } break L; + case 7: switch (s.charAt(1)) { + case 'a': X="valueOf";id=Id_valueOf; break L; + case 'e': X="replace";id=Id_replace; break L; + case 'n': X="indexOf";id=Id_indexOf; break L; + case 't': X="italics";id=Id_italics; break L; + } break L; + case 8: c=s.charAt(4); + if (c=='r') { X="toString";id=Id_toString; } + else if (c=='s') { X="fontsize";id=Id_fontsize; } + else if (c=='u') { X="toSource";id=Id_toSource; } + break L; + case 9: c=s.charAt(0); + if (c=='f') { X="fontcolor";id=Id_fontcolor; } + else if (c=='s') { X="substring";id=Id_substring; } + break L; + case 10: X="charCodeAt";id=Id_charCodeAt; break L; + case 11: switch (s.charAt(2)) { + case 'L': X="toLowerCase";id=Id_toLowerCase; break L; + case 'U': X="toUpperCase";id=Id_toUpperCase; break L; + case 'n': X="constructor";id=Id_constructor; break L; + case 's': X="lastIndexOf";id=Id_lastIndexOf; break L; + } break L; + case 13: X="localeCompare";id=Id_localeCompare; break L; + case 16: X="equalsIgnoreCase";id=Id_equalsIgnoreCase; break L; + case 17: c=s.charAt(8); + if (c=='L') { X="toLocaleLowerCase";id=Id_toLocaleLowerCase; } + else if (c=='U') { X="toLocaleUpperCase";id=Id_toLocaleUpperCase; } + break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + ConstructorId_fromCharCode = -1, + + Id_constructor = 1, + Id_toString = 2, + Id_toSource = 3, + Id_valueOf = 4, + Id_charAt = 5, + Id_charCodeAt = 6, + Id_indexOf = 7, + Id_lastIndexOf = 8, + Id_split = 9, + Id_substring = 10, + Id_toLowerCase = 11, + Id_toUpperCase = 12, + Id_substr = 13, + Id_concat = 14, + Id_slice = 15, + Id_bold = 16, + Id_italics = 17, + Id_fixed = 18, + Id_strike = 19, + Id_small = 20, + Id_big = 21, + Id_blink = 22, + Id_sup = 23, + Id_sub = 24, + Id_fontsize = 25, + Id_fontcolor = 26, + Id_link = 27, + Id_anchor = 28, + Id_equals = 29, + Id_equalsIgnoreCase = 30, + Id_match = 31, + Id_search = 32, + Id_replace = 33, + Id_localeCompare = 34, + Id_toLocaleLowerCase = 35, + Id_toLocaleUpperCase = 36, + MAX_PROTOTYPE_ID = 36; + +// #/string_id_map# + + private static final int + ConstructorId_charAt = -Id_charAt, + ConstructorId_charCodeAt = -Id_charCodeAt, + ConstructorId_indexOf = -Id_indexOf, + ConstructorId_lastIndexOf = -Id_lastIndexOf, + ConstructorId_split = -Id_split, + ConstructorId_substring = -Id_substring, + ConstructorId_toLowerCase = -Id_toLowerCase, + ConstructorId_toUpperCase = -Id_toUpperCase, + ConstructorId_substr = -Id_substr, + ConstructorId_concat = -Id_concat, + ConstructorId_slice = -Id_slice, + ConstructorId_equalsIgnoreCase = -Id_equalsIgnoreCase, + ConstructorId_match = -Id_match, + ConstructorId_search = -Id_search, + ConstructorId_replace = -Id_replace, + ConstructorId_localeCompare = -Id_localeCompare, + ConstructorId_toLocaleLowerCase = -Id_toLocaleLowerCase; + + private String string; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeWith.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeWith.java new file mode 100644 index 0000000..83683b2 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NativeWith.java @@ -0,0 +1,207 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; + +/** + * This class implements the object lookup required for the + * <code>with</code> statement. + * It simply delegates every action to its prototype except + * for operations on its parent. + */ +public class NativeWith implements Scriptable, IdFunctionCall, Serializable { + + private static final long serialVersionUID = 1L; + + static void init(Scriptable scope, boolean sealed) + { + NativeWith obj = new NativeWith(); + + obj.setParentScope(scope); + obj.setPrototype(ScriptableObject.getObjectPrototype(scope)); + + IdFunctionObject ctor = new IdFunctionObject(obj, FTAG, Id_constructor, + "With", 0, scope); + ctor.markAsConstructor(obj); + if (sealed) { + ctor.sealObject(); + } + ctor.exportAsScopeProperty(); + } + + private NativeWith() { + } + + protected NativeWith(Scriptable parent, Scriptable prototype) { + this.parent = parent; + this.prototype = prototype; + } + + public String getClassName() { + return "With"; + } + + public boolean has(String id, Scriptable start) + { + return prototype.has(id, prototype); + } + + public boolean has(int index, Scriptable start) + { + return prototype.has(index, prototype); + } + + public Object get(String id, Scriptable start) + { + if (start == this) + start = prototype; + return prototype.get(id, start); + } + + public Object get(int index, Scriptable start) + { + if (start == this) + start = prototype; + return prototype.get(index, start); + } + + public void put(String id, Scriptable start, Object value) + { + if (start == this) + start = prototype; + prototype.put(id, start, value); + } + + public void put(int index, Scriptable start, Object value) + { + if (start == this) + start = prototype; + prototype.put(index, start, value); + } + + public void delete(String id) + { + prototype.delete(id); + } + + public void delete(int index) + { + prototype.delete(index); + } + + public Scriptable getPrototype() { + return prototype; + } + + public void setPrototype(Scriptable prototype) { + this.prototype = prototype; + } + + public Scriptable getParentScope() { + return parent; + } + + public void setParentScope(Scriptable parent) { + this.parent = parent; + } + + public Object[] getIds() { + return prototype.getIds(); + } + + public Object getDefaultValue(Class typeHint) { + return prototype.getDefaultValue(typeHint); + } + + public boolean hasInstance(Scriptable value) { + return prototype.hasInstance(value); + } + + /** + * Must return null to continue looping or the final collection result. + */ + protected Object updateDotQuery(boolean value) + { + // NativeWith itself does not support it + throw new IllegalStateException(); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (f.hasTag(FTAG)) { + if (f.methodId() == Id_constructor) { + throw Context.reportRuntimeError1("msg.cant.call.indirect", "With"); + } + } + throw f.unknown(); + } + + static boolean isWithFunction(Object functionObj) + { + if (functionObj instanceof IdFunctionObject) { + IdFunctionObject f = (IdFunctionObject)functionObj; + return f.hasTag(FTAG) && f.methodId() == Id_constructor; + } + return false; + } + + static Object newWithSpecial(Context cx, Scriptable scope, Object[] args) + { + ScriptRuntime.checkDeprecated(cx, "With"); + scope = ScriptableObject.getTopLevelScope(scope); + NativeWith thisObj = new NativeWith(); + thisObj.setPrototype(args.length == 0 + ? ScriptableObject.getClassPrototype(scope, + "Object") + : ScriptRuntime.toObject(cx, scope, args[0])); + thisObj.setParentScope(scope); + return thisObj; + } + + private static final Object FTAG = new Object(); + + private static final int + Id_constructor = 1; + + protected Scriptable prototype; + protected Scriptable parent; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Node.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Node.java new file mode 100644 index 0000000..4298388 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Node.java @@ -0,0 +1,1394 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roshan James + * Roger Lawrence + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.Map; +import java.util.LinkedHashMap; +import java.util.Iterator; +import java.util.Collections; + +/** + * This class implements the root of the intermediate representation. + * + * @author Norris Boyd + * @author Mike McCabe + */ + +public class Node +{ + public static final int + FUNCTION_PROP = 1, + LOCAL_PROP = 2, + LOCAL_BLOCK_PROP = 3, + REGEXP_PROP = 4, + CASEARRAY_PROP = 5, + /* + the following properties are defined and manipulated by the + optimizer - + TARGETBLOCK_PROP - the block referenced by a branch node + VARIABLE_PROP - the variable referenced by a BIND or NAME node + ISNUMBER_PROP - this node generates code on Number children and + delivers a Number result (as opposed to Objects) + DIRECTCALL_PROP - this call node should emit code to test the function + object against the known class and call diret if it + matches. + */ + + TARGETBLOCK_PROP = 6, + VARIABLE_PROP = 7, + ISNUMBER_PROP = 8, + DIRECTCALL_PROP = 9, + SPECIALCALL_PROP = 10, + SKIP_INDEXES_PROP = 11, // array of skipped indexes of array literal + OBJECT_IDS_PROP = 12, // array of properties for object literal + INCRDECR_PROP = 13, // pre or post type of increment/decerement + CATCH_SCOPE_PROP = 14, // index of catch scope block in catch + LABEL_ID_PROP = 15, // label id: code generation uses it + MEMBER_TYPE_PROP = 16, // type of element access operation + NAME_PROP = 17, // property name + CONTROL_BLOCK_PROP = 18, // flags a control block that can drop off + PARENTHESIZED_PROP = 19, // expression is parenthesized + GENERATOR_END_PROP = 20, + DESTRUCTURING_ARRAY_LENGTH = 21, + DESTRUCTURING_NAMES= 22, + LAST_PROP = 22; + + // values of ISNUMBER_PROP to specify + // which of the children are Number types + public static final int + BOTH = 0, + LEFT = 1, + RIGHT = 2; + + public static final int // values for SPECIALCALL_PROP + NON_SPECIALCALL = 0, + SPECIALCALL_EVAL = 1, + SPECIALCALL_WITH = 2; + + public static final int // flags for INCRDECR_PROP + DECR_FLAG = 0x1, + POST_FLAG = 0x2; + + public static final int // flags for MEMBER_TYPE_PROP + PROPERTY_FLAG = 0x1, // property access: element is valid name + ATTRIBUTE_FLAG = 0x2, // x.@y or x..@y + DESCENDANTS_FLAG = 0x4; // x..y or x..@i + + private static class NumberNode extends Node + { + NumberNode(double number) + { + super(Token.NUMBER); + this.number = number; + } + + double number; + } + + private static class StringNode extends Node + { + StringNode(int type, String str) { + super(type); + this.str = str; + } + + String str; + Node.Scope scope; + } + + public static class Jump extends Node + { + public Jump(int type) + { + super(type); + } + + Jump(int type, int lineno) + { + super(type, lineno); + } + + Jump(int type, Node child) + { + super(type, child); + } + + Jump(int type, Node child, int lineno) + { + super(type, child, lineno); + } + + public final Jump getJumpStatement() + { + if (!(type == Token.BREAK || type == Token.CONTINUE)) Kit.codeBug(); + return jumpNode; + } + + public final void setJumpStatement(Jump jumpStatement) + { + if (!(type == Token.BREAK || type == Token.CONTINUE)) Kit.codeBug(); + if (jumpStatement == null) Kit.codeBug(); + if (this.jumpNode != null) Kit.codeBug(); //only once + this.jumpNode = jumpStatement; + } + + public final Node getDefault() + { + if (!(type == Token.SWITCH)) Kit.codeBug(); + return target2; + } + + public final void setDefault(Node defaultTarget) + { + if (!(type == Token.SWITCH)) Kit.codeBug(); + if (defaultTarget.type != Token.TARGET) Kit.codeBug(); + if (target2 != null) Kit.codeBug(); //only once + target2 = defaultTarget; + } + + public final Node getFinally() + { + if (!(type == Token.TRY)) Kit.codeBug(); + return target2; + } + + public final void setFinally(Node finallyTarget) + { + if (!(type == Token.TRY)) Kit.codeBug(); + if (finallyTarget.type != Token.TARGET) Kit.codeBug(); + if (target2 != null) Kit.codeBug(); //only once + target2 = finallyTarget; + } + + public final Jump getLoop() + { + if (!(type == Token.LABEL)) Kit.codeBug(); + return jumpNode; + } + + public final void setLoop(Jump loop) + { + if (!(type == Token.LABEL)) Kit.codeBug(); + if (loop == null) Kit.codeBug(); + if (jumpNode != null) Kit.codeBug(); //only once + jumpNode = loop; + } + + public final Node getContinue() + { + if (type != Token.LOOP) Kit.codeBug(); + return target2; + } + + public final void setContinue(Node continueTarget) + { + if (type != Token.LOOP) Kit.codeBug(); + if (continueTarget.type != Token.TARGET) Kit.codeBug(); + if (target2 != null) Kit.codeBug(); //only once + target2 = continueTarget; + } + + public Node target; + private Node target2; + private Jump jumpNode; + } + + static class Symbol { + Symbol(int declType, String name) { + this.declType = declType; + this.name = name; + this.index = -1; + } + /** + * One of Token.FUNCTION, Token.LP (for parameters), Token.VAR, + * Token.LET, or Token.CONST + */ + int declType; + int index; + String name; + Node.Scope containingTable; + } + + static class Scope extends Jump { + public Scope(int nodeType) { + super(nodeType); + } + + public Scope(int nodeType, int lineno) { + super(nodeType, lineno); + } + + public Scope(int nodeType, Node n, int lineno) { + super(nodeType, n, lineno); + } + + /* + * Creates a new scope node, moving symbol table information + * from "scope" to the new node, and making "scope" a nested + * scope contained by the new node. + * Useful for injecting a new scope in a scope chain. + */ + public static Scope splitScope(Scope scope) { + Scope result = new Scope(scope.getType()); + result.symbolTable = scope.symbolTable; + scope.symbolTable = null; + result.parent = scope.parent; + scope.parent = result; + result.top = scope.top; + return result; + } + + public static void joinScopes(Scope source, Scope dest) { + source.ensureSymbolTable(); + dest.ensureSymbolTable(); + if (!Collections.disjoint(source.symbolTable.keySet(), + dest.symbolTable.keySet())) + { + throw Kit.codeBug(); + } + dest.symbolTable.putAll(source.symbolTable); + } + + public void setParent(Scope parent) { + this.parent = parent; + this.top = parent == null ? (ScriptOrFnNode)this : parent.top; + } + + public Scope getParentScope() { + return parent; + } + + public Scope getDefiningScope(String name) { + for (Scope sn=this; sn != null; sn = sn.parent) { + if (sn.symbolTable == null) + continue; + if (sn.symbolTable.containsKey(name)) + return sn; + } + return null; + } + + public Symbol getSymbol(String name) { + return symbolTable == null ? null : symbolTable.get(name); + } + + public void putSymbol(String name, Symbol symbol) { + ensureSymbolTable(); + symbolTable.put(name, symbol); + symbol.containingTable = this; + top.addSymbol(symbol); + } + + public Map<String,Symbol> getSymbolTable() { + return symbolTable; + } + + private void ensureSymbolTable() { + if (symbolTable == null) { + symbolTable = new LinkedHashMap<String,Symbol>(5); + } + } + + // Use LinkedHashMap so that the iteration order is the insertion order + protected LinkedHashMap<String,Symbol> symbolTable; + private Scope parent; + private ScriptOrFnNode top; + } + + private static class PropListItem + { + PropListItem next; + int type; + int intValue; + Object objectValue; + } + + + public Node(int nodeType) { + type = nodeType; + } + + public Node(int nodeType, Node child) { + type = nodeType; + first = last = child; + child.next = null; + } + + public Node(int nodeType, Node left, Node right) { + type = nodeType; + first = left; + last = right; + left.next = right; + right.next = null; + } + + public Node(int nodeType, Node left, Node mid, Node right) { + type = nodeType; + first = left; + last = right; + left.next = mid; + mid.next = right; + right.next = null; + } + + public Node(int nodeType, int line) { + type = nodeType; + lineno = line; + } + + public Node(int nodeType, Node child, int line) { + this(nodeType, child); + lineno = line; + } + + public Node(int nodeType, Node left, Node right, int line) { + this(nodeType, left, right); + lineno = line; + } + + public Node(int nodeType, Node left, Node mid, Node right, int line) { + this(nodeType, left, mid, right); + lineno = line; + } + + public static Node newNumber(double number) { + return new NumberNode(number); + } + + public static Node newString(String str) { + return new StringNode(Token.STRING, str); + } + + public static Node newString(int type, String str) { + return new StringNode(type, str); + } + + public int getType() { + return type; + } + + public void setType(int type) { + this.type = type; + } + + public boolean hasChildren() { + return first != null; + } + + public Node getFirstChild() { + return first; + } + + public Node getLastChild() { + return last; + } + + public Node getNext() { + return next; + } + + public Node getChildBefore(Node child) { + if (child == first) + return null; + Node n = first; + while (n.next != child) { + n = n.next; + if (n == null) + throw new RuntimeException("node is not a child"); + } + return n; + } + + public Node getLastSibling() { + Node n = this; + while (n.next != null) { + n = n.next; + } + return n; + } + + public void addChildToFront(Node child) { + child.next = first; + first = child; + if (last == null) { + last = child; + } + } + + public void addChildToBack(Node child) { + child.next = null; + if (last == null) { + first = last = child; + return; + } + last.next = child; + last = child; + } + + public void addChildrenToFront(Node children) { + Node lastSib = children.getLastSibling(); + lastSib.next = first; + first = children; + if (last == null) { + last = lastSib; + } + } + + public void addChildrenToBack(Node children) { + if (last != null) { + last.next = children; + } + last = children.getLastSibling(); + if (first == null) { + first = children; + } + } + + /** + * Add 'child' before 'node'. + */ + public void addChildBefore(Node newChild, Node node) { + if (newChild.next != null) + throw new RuntimeException( + "newChild had siblings in addChildBefore"); + if (first == node) { + newChild.next = first; + first = newChild; + return; + } + Node prev = getChildBefore(node); + addChildAfter(newChild, prev); + } + + /** + * Add 'child' after 'node'. + */ + public void addChildAfter(Node newChild, Node node) { + if (newChild.next != null) + throw new RuntimeException( + "newChild had siblings in addChildAfter"); + newChild.next = node.next; + node.next = newChild; + if (last == node) + last = newChild; + } + + public void removeChild(Node child) { + Node prev = getChildBefore(child); + if (prev == null) + first = first.next; + else + prev.next = child.next; + if (child == last) last = prev; + child.next = null; + } + + public void replaceChild(Node child, Node newChild) { + newChild.next = child.next; + if (child == first) { + first = newChild; + } else { + Node prev = getChildBefore(child); + prev.next = newChild; + } + if (child == last) + last = newChild; + child.next = null; + } + + public void replaceChildAfter(Node prevChild, Node newChild) { + Node child = prevChild.next; + newChild.next = child.next; + prevChild.next = newChild; + if (child == last) + last = newChild; + child.next = null; + } + + private static final String propToString(int propType) + { + if (Token.printTrees) { + // If Context.printTrees is false, the compiler + // can remove all these strings. + switch (propType) { + case FUNCTION_PROP: return "function"; + case LOCAL_PROP: return "local"; + case LOCAL_BLOCK_PROP: return "local_block"; + case REGEXP_PROP: return "regexp"; + case CASEARRAY_PROP: return "casearray"; + + case TARGETBLOCK_PROP: return "targetblock"; + case VARIABLE_PROP: return "variable"; + case ISNUMBER_PROP: return "isnumber"; + case DIRECTCALL_PROP: return "directcall"; + + case SPECIALCALL_PROP: return "specialcall"; + case SKIP_INDEXES_PROP: return "skip_indexes"; + case OBJECT_IDS_PROP: return "object_ids_prop"; + case INCRDECR_PROP: return "incrdecr_prop"; + case CATCH_SCOPE_PROP: return "catch_scope_prop"; + case LABEL_ID_PROP: return "label_id_prop"; + case MEMBER_TYPE_PROP: return "member_type_prop"; + case NAME_PROP: return "name_prop"; + case CONTROL_BLOCK_PROP: return "control_block_prop"; + case PARENTHESIZED_PROP: return "parenthesized_prop"; + case GENERATOR_END_PROP: return "generator_end"; + case DESTRUCTURING_ARRAY_LENGTH: + return "destructuring_array_length"; + case DESTRUCTURING_NAMES:return "destructuring_names"; + + default: Kit.codeBug(); + } + } + return null; + } + + private PropListItem lookupProperty(int propType) + { + PropListItem x = propListHead; + while (x != null && propType != x.type) { + x = x.next; + } + return x; + } + + private PropListItem ensureProperty(int propType) + { + PropListItem item = lookupProperty(propType); + if (item == null) { + item = new PropListItem(); + item.type = propType; + item.next = propListHead; + propListHead = item; + } + return item; + } + + public void removeProp(int propType) + { + PropListItem x = propListHead; + if (x != null) { + PropListItem prev = null; + while (x.type != propType) { + prev = x; + x = x.next; + if (x == null) { return; } + } + if (prev == null) { + propListHead = x.next; + } else { + prev.next = x.next; + } + } + } + + public Object getProp(int propType) + { + PropListItem item = lookupProperty(propType); + if (item == null) { return null; } + return item.objectValue; + } + + public int getIntProp(int propType, int defaultValue) + { + PropListItem item = lookupProperty(propType); + if (item == null) { return defaultValue; } + return item.intValue; + } + + public int getExistingIntProp(int propType) + { + PropListItem item = lookupProperty(propType); + if (item == null) { Kit.codeBug(); } + return item.intValue; + } + + public void putProp(int propType, Object prop) + { + if (prop == null) { + removeProp(propType); + } else { + PropListItem item = ensureProperty(propType); + item.objectValue = prop; + } + } + + public void putIntProp(int propType, int prop) + { + PropListItem item = ensureProperty(propType); + item.intValue = prop; + } + + public int getLineno() { + return lineno; + } + + /** Can only be called when <tt>getType() == Token.NUMBER</tt> */ + public final double getDouble() { + return ((NumberNode)this).number; + } + + public final void setDouble(double number) { + ((NumberNode)this).number = number; + } + + /** Can only be called when node has String context. */ + public final String getString() { + return ((StringNode)this).str; + } + + /** Can only be called when node has String context. */ + public final void setString(String s) { + if (s == null) Kit.codeBug(); + ((StringNode)this).str = s; + } + + /** Can only be called when node has String context. */ + public final Scope getScope() { + return ((StringNode)this).scope; + } + + /** Can only be called when node has String context. */ + public final void setScope(Scope s) { + if (s == null) Kit.codeBug(); + if (!(this instanceof StringNode)) { + throw Kit.codeBug(); + } + ((StringNode)this).scope = s; + } + + public static Node newTarget() + { + return new Node(Token.TARGET); + } + + public final int labelId() + { + if (type != Token.TARGET && type != Token.YIELD) Kit.codeBug(); + return getIntProp(LABEL_ID_PROP, -1); + } + + public void labelId(int labelId) + { + if (type != Token.TARGET && type != Token.YIELD) Kit.codeBug(); + putIntProp(LABEL_ID_PROP, labelId); + } + + + /** + * Does consistent-return analysis on the function body when strict mode is + * enabled. + * + * function (x) { return (x+1) } + * is ok, but + * function (x) { if (x < 0) return (x+1); } + * is not becuase the function can potentially return a value when the + * condition is satisfied and if not, the function does not explicitly + * return value. + * + * This extends to checking mismatches such as "return" and "return <value>" + * used in the same function. Warnings are not emitted if inconsistent + * returns exist in code that can be statically shown to be unreachable. + * Ex. + * function (x) { while (true) { ... if (..) { return value } ... } } + * emits no warning. However if the loop had a break statement, then a + * warning would be emitted. + * + * The consistency analysis looks at control structures such as loops, ifs, + * switch, try-catch-finally blocks, examines the reachable code paths and + * warns the user about an inconsistent set of termination possibilities. + * + * Caveat: Since the parser flattens many control structures into almost + * straight-line code with gotos, it makes such analysis hard. Hence this + * analyser is written to taken advantage of patterns of code generated by + * the parser (for loops, try blocks and such) and does not do a full + * control flow analysis of the gotos and break/continue statements. + * Future changes to the parser will affect this analysis. + */ + + /** + * These flags enumerate the possible ways a statement/function can + * terminate. These flags are used by endCheck() and by the Parser to + * detect inconsistent return usage. + * + * END_UNREACHED is reserved for code paths that are assumed to always be + * able to execute (example: throw, continue) + * + * END_DROPS_OFF indicates if the statement can transfer control to the + * next one. Statement such as return dont. A compound statement may have + * some branch that drops off control to the next statement. + * + * END_RETURNS indicates that the statement can return (without arguments) + * END_RETURNS_VALUE indicates that the statement can return a value. + * + * A compound statement such as + * if (condition) { + * return value; + * } + * Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck() + */ + static final int END_UNREACHED = 0; + static final int END_DROPS_OFF = 1; + static final int END_RETURNS = 2; + static final int END_RETURNS_VALUE = 4; + static final int END_YIELDS = 8; + + /** + * Checks that every return usage in a function body is consistent with the + * requirements of strict-mode. + * @return true if the function satisfies strict mode requirement. + */ + public boolean hasConsistentReturnUsage() + { + int n = endCheck(); + return (n & END_RETURNS_VALUE) == 0 || + (n & (END_DROPS_OFF|END_RETURNS|END_YIELDS)) == 0; + } + + /** + * Returns in the then and else blocks must be consistent with each other. + * If there is no else block, then the return statement can fall through. + * @return logical OR of END_* flags + */ + private int endCheckIf() + { + Node th, el; + int rv = END_UNREACHED; + + th = next; + el = ((Jump)this).target; + + rv = th.endCheck(); + + if (el != null) + rv |= el.endCheck(); + else + rv |= END_DROPS_OFF; + + return rv; + } + + /** + * Consistency of return statements is checked between the case statements. + * If there is no default, then the switch can fall through. If there is a + * default,we check to see if all code paths in the default return or if + * there is a code path that can fall through. + * @return logical OR of END_* flags + */ + private int endCheckSwitch() + { + Node n; + int rv = END_UNREACHED; + + // examine the cases + for (n = first.next; n != null; n = n.next) + { + if (n.type == Token.CASE) { + rv |= ((Jump)n).target.endCheck(); + } else + break; + } + + // we don't care how the cases drop into each other + rv &= ~END_DROPS_OFF; + + // examine the default + n = ((Jump)this).getDefault(); + if (n != null) + rv |= n.endCheck(); + else + rv |= END_DROPS_OFF; + + // remove the switch block + rv |= getIntProp(CONTROL_BLOCK_PROP, END_UNREACHED); + + return rv; + } + + /** + * If the block has a finally, return consistency is checked in the + * finally block. If all code paths in the finally returns, then the + * returns in the try-catch blocks don't matter. If there is a code path + * that does not return or if there is no finally block, the returns + * of the try and catch blocks are checked for mismatch. + * @return logical OR of END_* flags + */ + private int endCheckTry() + { + Node n; + int rv = END_UNREACHED; + + // check the finally if it exists + n = ((Jump)this).getFinally(); + if(n != null) { + rv = n.next.first.endCheck(); + } else { + rv = END_DROPS_OFF; + } + + // if the finally block always returns, then none of the returns + // in the try or catch blocks matter + if ((rv & END_DROPS_OFF) != 0) { + rv &= ~END_DROPS_OFF; + + // examine the try block + rv |= first.endCheck(); + + // check each catch block + n = ((Jump)this).target; + if (n != null) + { + // point to the first catch_scope + for (n = n.next.first; n != null; n = n.next.next) + { + // check the block of user code in the catch_scope + rv |= n.next.first.next.first.endCheck(); + } + } + } + + return rv; + } + + /** + * Return statement in the loop body must be consistent. The default + * assumption for any kind of a loop is that it will eventually terminate. + * The only exception is a loop with a constant true condition. Code that + * follows such a loop is examined only if one can statically determine + * that there is a break out of the loop. + * for(<> ; <>; <>) {} + * for(<> in <> ) {} + * while(<>) { } + * do { } while(<>) + * @return logical OR of END_* flags + */ + private int endCheckLoop() + { + Node n; + int rv = END_UNREACHED; + + // To find the loop body, we look at the second to last node of the + // loop node, which should be the predicate that the loop should + // satisfy. + // The target of the predicate is the loop-body for all 4 kinds of + // loops. + for (n = first; n.next != last; n = n.next) { + /* skip */ + } + if (n.type != Token.IFEQ) + return END_DROPS_OFF; + + // The target's next is the loop body block + rv = ((Jump)n).target.next.endCheck(); + + // check to see if the loop condition is true + if (n.first.type == Token.TRUE) + rv &= ~END_DROPS_OFF; + + // look for effect of breaks + rv |= getIntProp(CONTROL_BLOCK_PROP, END_UNREACHED); + + return rv; + } + + + /** + * A general block of code is examined statement by statement. If any + * statement (even compound ones) returns in all branches, then subsequent + * statements are not examined. + * @return logical OR of END_* flags + */ + private int endCheckBlock() + { + Node n; + int rv = END_DROPS_OFF; + + // check each statment and if the statement can continue onto the next + // one, then check the next statement + for (n=first; ((rv & END_DROPS_OFF) != 0) && n != null; n = n.next) + { + rv &= ~END_DROPS_OFF; + rv |= n.endCheck(); + } + return rv; + } + + /** + * A labelled statement implies that there maybe a break to the label. The + * function processes the labelled statement and then checks the + * CONTROL_BLOCK_PROP property to see if there is ever a break to the + * particular label. + * @return logical OR of END_* flags + */ + private int endCheckLabel() + { + int rv = END_UNREACHED; + + rv = next.endCheck(); + rv |= getIntProp(CONTROL_BLOCK_PROP, END_UNREACHED); + + return rv; + } + + /** + * When a break is encountered annotate the statement being broken + * out of by setting its CONTROL_BLOCK_PROP property. + * @return logical OR of END_* flags + */ + private int endCheckBreak() + { + Node n = ((Jump) this).jumpNode; + n.putIntProp(CONTROL_BLOCK_PROP, END_DROPS_OFF); + return END_UNREACHED; + } + + /** + * endCheck() examines the body of a function, doing a basic reachability + * analysis and returns a combination of flags END_* flags that indicate + * how the function execution can terminate. These constitute only the + * pessimistic set of termination conditions. It is possible that at + * runtime certain code paths will never be actually taken. Hence this + * analysis will flag errors in cases where there may not be errors. + * @return logical OR of END_* flags + */ + private int endCheck() + { + switch(type) + { + case Token.BREAK: + return endCheckBreak(); + + case Token.EXPR_VOID: + if (this.first != null) + return first.endCheck(); + return END_DROPS_OFF; + + case Token.YIELD: + return END_YIELDS; + + case Token.CONTINUE: + case Token.THROW: + return END_UNREACHED; + + case Token.RETURN: + if (this.first != null) + return END_RETURNS_VALUE; + else + return END_RETURNS; + + case Token.TARGET: + if (next != null) + return next.endCheck(); + else + return END_DROPS_OFF; + + case Token.LOOP: + return endCheckLoop(); + + case Token.LOCAL_BLOCK: + case Token.BLOCK: + // there are several special kinds of blocks + if (first == null) + return END_DROPS_OFF; + + switch(first.type) { + case Token.LABEL: + return first.endCheckLabel(); + + case Token.IFNE: + return first.endCheckIf(); + + case Token.SWITCH: + return first.endCheckSwitch(); + + case Token.TRY: + return first.endCheckTry(); + + default: + return endCheckBlock(); + } + + default: + return END_DROPS_OFF; + } + } + + public boolean hasSideEffects() + { + switch (type) { + case Token.EXPR_VOID: + case Token.COMMA: + if (last != null) + return last.hasSideEffects(); + else + return true; + + case Token.HOOK: + if (first == null || + first.next == null || + first.next.next == null) + Kit.codeBug(); + return first.next.hasSideEffects() && + first.next.next.hasSideEffects(); + + case Token.ERROR: // Avoid cascaded error messages + case Token.EXPR_RESULT: + case Token.ASSIGN: + case Token.ASSIGN_ADD: + case Token.ASSIGN_SUB: + case Token.ASSIGN_MUL: + case Token.ASSIGN_DIV: + case Token.ASSIGN_MOD: + case Token.ASSIGN_BITOR: + case Token.ASSIGN_BITXOR: + case Token.ASSIGN_BITAND: + case Token.ASSIGN_LSH: + case Token.ASSIGN_RSH: + case Token.ASSIGN_URSH: + case Token.ENTERWITH: + case Token.LEAVEWITH: + case Token.RETURN: + case Token.GOTO: + case Token.IFEQ: + case Token.IFNE: + case Token.NEW: + case Token.DELPROP: + case Token.SETNAME: + case Token.SETPROP: + case Token.SETELEM: + case Token.CALL: + case Token.THROW: + case Token.RETHROW: + case Token.SETVAR: + case Token.CATCH_SCOPE: + case Token.RETURN_RESULT: + case Token.SET_REF: + case Token.DEL_REF: + case Token.REF_CALL: + case Token.TRY: + case Token.SEMI: + case Token.INC: + case Token.DEC: + case Token.EXPORT: + case Token.IMPORT: + case Token.IF: + case Token.ELSE: + case Token.SWITCH: + case Token.WHILE: + case Token.DO: + case Token.FOR: + case Token.BREAK: + case Token.CONTINUE: + case Token.VAR: + case Token.CONST: + case Token.LET: + case Token.LETEXPR: + case Token.WITH: + case Token.WITHEXPR: + case Token.CATCH: + case Token.FINALLY: + case Token.BLOCK: + case Token.LABEL: + case Token.TARGET: + case Token.LOOP: + case Token.JSR: + case Token.SETPROP_OP: + case Token.SETELEM_OP: + case Token.LOCAL_BLOCK: + case Token.SET_REF_OP: + case Token.YIELD: + return true; + + default: + return false; + } + } + + public String toString() + { + if (Token.printTrees) { + StringBuffer sb = new StringBuffer(); + toString(new ObjToIntMap(), sb); + return sb.toString(); + } + return String.valueOf(type); + } + + private void toString(ObjToIntMap printIds, StringBuffer sb) + { + if (Token.printTrees) { + sb.append(Token.name(type)); + if (this instanceof StringNode) { + sb.append(' '); + sb.append(getString()); + Scope scope = getScope(); + if (scope != null) { + sb.append("[scope: "); + appendPrintId(scope, printIds, sb); + sb.append("]"); + } + } else if (this instanceof Node.Scope) { + if (this instanceof ScriptOrFnNode) { + ScriptOrFnNode sof = (ScriptOrFnNode)this; + if (this instanceof FunctionNode) { + FunctionNode fn = (FunctionNode)this; + sb.append(' '); + sb.append(fn.getFunctionName()); + } + sb.append(" [source name: "); + sb.append(sof.getSourceName()); + sb.append("] [encoded source length: "); + sb.append(sof.getEncodedSourceEnd() + - sof.getEncodedSourceStart()); + sb.append("] [base line: "); + sb.append(sof.getBaseLineno()); + sb.append("] [end line: "); + sb.append(sof.getEndLineno()); + sb.append(']'); + } + if (((Node.Scope)this).symbolTable != null) { + sb.append(" [scope "); + appendPrintId(this, printIds, sb); + sb.append(": "); + Iterator iter = ((Node.Scope) this).symbolTable.keySet() + .iterator(); + while (iter.hasNext()) { + sb.append(iter.next()); + sb.append(" "); + } + sb.append("]"); + } + } else if (this instanceof Jump) { + Jump jump = (Jump)this; + if (type == Token.BREAK || type == Token.CONTINUE) { + sb.append(" [label: "); + appendPrintId(jump.getJumpStatement(), printIds, sb); + sb.append(']'); + } else if (type == Token.TRY) { + Node catchNode = jump.target; + Node finallyTarget = jump.getFinally(); + if (catchNode != null) { + sb.append(" [catch: "); + appendPrintId(catchNode, printIds, sb); + sb.append(']'); + } + if (finallyTarget != null) { + sb.append(" [finally: "); + appendPrintId(finallyTarget, printIds, sb); + sb.append(']'); + } + } else if (type == Token.LABEL || type == Token.LOOP + || type == Token.SWITCH) + { + sb.append(" [break: "); + appendPrintId(jump.target, printIds, sb); + sb.append(']'); + if (type == Token.LOOP) { + sb.append(" [continue: "); + appendPrintId(jump.getContinue(), printIds, sb); + sb.append(']'); + } + } else { + sb.append(" [target: "); + appendPrintId(jump.target, printIds, sb); + sb.append(']'); + } + } else if (type == Token.NUMBER) { + sb.append(' '); + sb.append(getDouble()); + } else if (type == Token.TARGET) { + sb.append(' '); + appendPrintId(this, printIds, sb); + } + if (lineno != -1) { + sb.append(' '); + sb.append(lineno); + } + + for (PropListItem x = propListHead; x != null; x = x.next) { + int type = x.type; + sb.append(" ["); + sb.append(propToString(type)); + sb.append(": "); + String value; + switch (type) { + case TARGETBLOCK_PROP : // can't add this as it recurses + value = "target block property"; + break; + case LOCAL_BLOCK_PROP : // can't add this as it is dull + value = "last local block"; + break; + case ISNUMBER_PROP: + switch (x.intValue) { + case BOTH: + value = "both"; + break; + case RIGHT: + value = "right"; + break; + case LEFT: + value = "left"; + break; + default: + throw Kit.codeBug(); + } + break; + case SPECIALCALL_PROP: + switch (x.intValue) { + case SPECIALCALL_EVAL: + value = "eval"; + break; + case SPECIALCALL_WITH: + value = "with"; + break; + default: + // NON_SPECIALCALL should not be stored + throw Kit.codeBug(); + } + break; + case OBJECT_IDS_PROP: { + Object[] a = (Object[]) x.objectValue; + value = "["; + for (int i=0; i < a.length; i++) { + value += a[i].toString(); + if (i+1 < a.length) + value += ", "; + } + value += "]"; + break; + } + default : + Object obj = x.objectValue; + if (obj != null) { + value = obj.toString(); + } else { + value = String.valueOf(x.intValue); + } + break; + } + sb.append(value); + sb.append(']'); + } + } + } + + public String toStringTree(ScriptOrFnNode treeTop) { + if (Token.printTrees) { + StringBuffer sb = new StringBuffer(); + toStringTreeHelper(treeTop, this, null, 0, sb); + return sb.toString(); + } + return null; + } + + private static void toStringTreeHelper(ScriptOrFnNode treeTop, Node n, + ObjToIntMap printIds, + int level, StringBuffer sb) + { + if (Token.printTrees) { + if (printIds == null) { + printIds = new ObjToIntMap(); + generatePrintIds(treeTop, printIds); + } + for (int i = 0; i != level; ++i) { + sb.append(" "); + } + n.toString(printIds, sb); + sb.append('\n'); + for (Node cursor = n.getFirstChild(); cursor != null; + cursor = cursor.getNext()) + { + if (cursor.getType() == Token.FUNCTION) { + int fnIndex = cursor.getExistingIntProp(Node.FUNCTION_PROP); + FunctionNode fn = treeTop.getFunctionNode(fnIndex); + toStringTreeHelper(fn, fn, null, level + 1, sb); + } else { + toStringTreeHelper(treeTop, cursor, printIds, level + 1, sb); + } + } + } + } + + private static void generatePrintIds(Node n, ObjToIntMap map) + { + if (Token.printTrees) { + map.put(n, map.size()); + for (Node cursor = n.getFirstChild(); cursor != null; + cursor = cursor.getNext()) + { + generatePrintIds(cursor, map); + } + } + } + + private static void appendPrintId(Node n, ObjToIntMap printIds, + StringBuffer sb) + { + if (Token.printTrees) { + if (n != null) { + int id = printIds.get(n, -1); + sb.append('#'); + if (id != -1) { + sb.append(id + 1); + } else { + sb.append("<not_available>"); + } + } + } + } + + int type; // type of the node; Token.NAME for example + Node next; // next sibling + private Node first; // first element of a linked list of children + private Node last; // last element of a linked list of children + protected int lineno = -1; + + /*APPJET*/public int statementEndLineNum = -1; + + /** + * Linked list of properties. Since vast majority of nodes would have + * no more then 2 properties, linked list saves memory and provides + * fast lookup. If this does not holds, propListHead can be replaced + * by UintMap. + */ + private PropListItem propListHead; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NodeTransformer.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NodeTransformer.java new file mode 100644 index 0000000..201c6f2 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/NodeTransformer.java @@ -0,0 +1,565 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Bob Jervis + * Roger Lawrence + * Mike McCabe + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.ArrayList; +import java.util.List; + +/** + * This class transforms a tree to a lower-level representation for codegen. + * + * @see Node + * @author Norris Boyd + */ + +public class NodeTransformer +{ + + public NodeTransformer() + { + } + + public final void transform(ScriptOrFnNode tree) + { + transformCompilationUnit(tree); + for (int i = 0; i != tree.getFunctionCount(); ++i) { + FunctionNode fn = tree.getFunctionNode(i); + transform(fn); + } + } + + private void transformCompilationUnit(ScriptOrFnNode tree) + { + loops = new ObjArray(); + loopEnds = new ObjArray(); + + // to save against upchecks if no finally blocks are used. + hasFinally = false; + + // Flatten all only if we are not using scope objects for block scope + boolean createScopeObjects = tree.getType() != Token.FUNCTION || + ((FunctionNode)tree).requiresActivation(); + tree.flattenSymbolTable(!createScopeObjects); + + //uncomment to print tree before transformation + //if (Token.printTrees) System.out.println(tree.toStringTree(tree)); + transformCompilationUnit_r(tree, tree, tree, createScopeObjects); + } + + private void transformCompilationUnit_r(final ScriptOrFnNode tree, + final Node parent, + Node.Scope scope, + boolean createScopeObjects) + { + Node node = null; + siblingLoop: + for (;;) { + Node previous = null; + if (node == null) { + node = parent.getFirstChild(); + } else { + previous = node; + node = node.getNext(); + } + if (node == null) { + break; + } + + int type = node.getType(); + if (createScopeObjects && + (type == Token.BLOCK || type == Token.LOOP || + type == Token.ARRAYCOMP) && + (node instanceof Node.Scope)) + { + Node.Scope newScope = (Node.Scope) node; + if (newScope.symbolTable != null) { + // transform to let statement so we get a with statement + // created to contain scoped let variables + Node let = new Node(type == Token.ARRAYCOMP ? Token.LETEXPR + : Token.LET); + Node innerLet = new Node(Token.LET); + let.addChildToBack(innerLet); + for (String name: newScope.symbolTable.keySet()) { + innerLet.addChildToBack(Node.newString(Token.NAME, name)); + } + newScope.symbolTable = null; // so we don't transform again + Node oldNode = node; + node = replaceCurrent(parent, previous, node, let); + type = node.getType(); + let.addChildToBack(oldNode); + } + } + + switch (type) { + + case Token.LABEL: + case Token.SWITCH: + case Token.LOOP: + loops.push(node); + loopEnds.push(((Node.Jump)node).target); + break; + + case Token.WITH: + { + loops.push(node); + Node leave = node.getNext(); + if (leave.getType() != Token.LEAVEWITH) { + Kit.codeBug(); + } + loopEnds.push(leave); + break; + } + + case Token.TRY: + { + Node.Jump jump = (Node.Jump)node; + Node finallytarget = jump.getFinally(); + if (finallytarget != null) { + hasFinally = true; + loops.push(node); + loopEnds.push(finallytarget); + } + break; + } + + case Token.TARGET: + case Token.LEAVEWITH: + if (!loopEnds.isEmpty() && loopEnds.peek() == node) { + loopEnds.pop(); + loops.pop(); + } + break; + + case Token.YIELD: + ((FunctionNode)tree).addResumptionPoint(node); + break; + + case Token.RETURN: + { + boolean isGenerator = tree.getType() == Token.FUNCTION + && ((FunctionNode)tree).isGenerator(); + if (isGenerator) { + node.putIntProp(Node.GENERATOR_END_PROP, 1); + } + /* If we didn't support try/finally, it wouldn't be + * necessary to put LEAVEWITH nodes here... but as + * we do need a series of JSR FINALLY nodes before + * each RETURN, we need to ensure that each finally + * block gets the correct scope... which could mean + * that some LEAVEWITH nodes are necessary. + */ + if (!hasFinally) + break; // skip the whole mess. + Node unwindBlock = null; + for (int i=loops.size()-1; i >= 0; i--) { + Node n = (Node) loops.get(i); + int elemtype = n.getType(); + if (elemtype == Token.TRY || elemtype == Token.WITH) { + Node unwind; + if (elemtype == Token.TRY) { + Node.Jump jsrnode = new Node.Jump(Token.JSR); + Node jsrtarget = ((Node.Jump)n).getFinally(); + jsrnode.target = jsrtarget; + unwind = jsrnode; + } else { + unwind = new Node(Token.LEAVEWITH); + } + if (unwindBlock == null) { + unwindBlock = new Node(Token.BLOCK, + node.getLineno()); + } + unwindBlock.addChildToBack(unwind); + } + } + if (unwindBlock != null) { + Node returnNode = node; + Node returnExpr = returnNode.getFirstChild(); + node = replaceCurrent(parent, previous, node, unwindBlock); + if (returnExpr == null || isGenerator) { + unwindBlock.addChildToBack(returnNode); + } else { + Node store = new Node(Token.EXPR_RESULT, returnExpr); + unwindBlock.addChildToFront(store); + returnNode = new Node(Token.RETURN_RESULT); + unwindBlock.addChildToBack(returnNode); + // transform return expression + transformCompilationUnit_r(tree, store, scope, + createScopeObjects); + } + // skip transformCompilationUnit_r to avoid infinite loop + continue siblingLoop; + } + break; + } + + case Token.BREAK: + case Token.CONTINUE: + { + Node.Jump jump = (Node.Jump)node; + Node.Jump jumpStatement = jump.getJumpStatement(); + if (jumpStatement == null) Kit.codeBug(); + + for (int i = loops.size(); ;) { + if (i == 0) { + // Parser/IRFactory ensure that break/continue + // always has a jump statement associated with it + // which should be found + throw Kit.codeBug(); + } + --i; + Node n = (Node) loops.get(i); + if (n == jumpStatement) { + break; + } + + int elemtype = n.getType(); + if (elemtype == Token.WITH) { + Node leave = new Node(Token.LEAVEWITH); + previous = addBeforeCurrent(parent, previous, node, + leave); + } else if (elemtype == Token.TRY) { + Node.Jump tryNode = (Node.Jump)n; + Node.Jump jsrFinally = new Node.Jump(Token.JSR); + jsrFinally.target = tryNode.getFinally(); + previous = addBeforeCurrent(parent, previous, node, + jsrFinally); + } + } + + if (type == Token.BREAK) { + jump.target = jumpStatement.target; + } else { + jump.target = jumpStatement.getContinue(); + } + jump.setType(Token.GOTO); + + break; + } + + case Token.CALL: + visitCall(node, tree); + break; + + case Token.NEW: + visitNew(node, tree); + break; + + case Token.LETEXPR: + case Token.LET: { + Node child = node.getFirstChild(); + if (child.getType() == Token.LET) { + // We have a let statement or expression rather than a + // let declaration + boolean createWith = tree.getType() != Token.FUNCTION + || ((FunctionNode)tree).requiresActivation(); + node = visitLet(createWith, parent, previous, node); + break; + } else { + // fall through to process let declaration... + } + } + /* fall through */ + case Token.CONST: + case Token.VAR: + { + Node result = new Node(Token.BLOCK); + for (Node cursor = node.getFirstChild(); cursor != null;) { + // Move cursor to next before createAssignment gets chance + // to change n.next + Node n = cursor; + cursor = cursor.getNext(); + if (n.getType() == Token.NAME) { + if (!n.hasChildren()) + continue; + Node init = n.getFirstChild(); + n.removeChild(init); + n.setType(Token.BINDNAME); + n = new Node(type == Token.CONST ? + Token.SETCONST : + Token.SETNAME, + n, init); + } else { + // May be a destructuring assignment already transformed + // to a LETEXPR + if (n.getType() != Token.LETEXPR) + throw Kit.codeBug(); + } + Node pop = new Node(Token.EXPR_VOID, n, node.getLineno()); + result.addChildToBack(pop); + } + node = replaceCurrent(parent, previous, node, result); + break; + } + + case Token.TYPEOFNAME: { + Node.Scope defining = scope.getDefiningScope(node.getString()); + if (defining != null) { + node.setScope(defining); + } + } + break; + + case Token.TYPEOF: + case Token.IFNE: { + /* We want to suppress warnings for undefined property o.p + * for the following constructs: typeof o.p, if (o.p), + * if (!o.p), if (o.p == undefined), if (undefined == o.p) + */ + Node child = node.getFirstChild(); + if (type == Token.IFNE) { + while (child.getType() == Token.NOT) { + child = child.getFirstChild(); + } + if (child.getType() == Token.EQ || + child.getType() == Token.NE) + { + Node first = child.getFirstChild(); + Node last = child.getLastChild(); + if (first.getType() == Token.NAME && + first.getString().equals("undefined")) + child = last; + else if (last.getType() == Token.NAME && + last.getString().equals("undefined")) + child = first; + } + } + if (child.getType() == Token.GETPROP) + child.setType(Token.GETPROPNOWARN); + break; + } + + case Token.NAME: + case Token.SETNAME: + case Token.SETCONST: + case Token.DELPROP: + { + // Turn name to var for faster access if possible + if (createScopeObjects) { + break; + } + Node nameSource; + if (type == Token.NAME) { + nameSource = node; + } else { + nameSource = node.getFirstChild(); + if (nameSource.getType() != Token.BINDNAME) { + if (type == Token.DELPROP) { + break; + } + throw Kit.codeBug(); + } + } + if (nameSource.getScope() != null) { + break; // already have a scope set + } + String name = nameSource.getString(); + Node.Scope defining = scope.getDefiningScope(name); + if (defining != null) { + nameSource.setScope(defining); + if (type == Token.NAME) { + node.setType(Token.GETVAR); + } else if (type == Token.SETNAME) { + node.setType(Token.SETVAR); + nameSource.setType(Token.STRING); + } else if (type == Token.SETCONST) { + node.setType(Token.SETCONSTVAR); + nameSource.setType(Token.STRING); + } else if (type == Token.DELPROP) { + // Local variables are by definition permanent + Node n = new Node(Token.FALSE); + node = replaceCurrent(parent, previous, node, n); + } else { + throw Kit.codeBug(); + } + } + break; + } + } + + transformCompilationUnit_r(tree, node, + node instanceof Node.Scope ? (Node.Scope)node : scope, + createScopeObjects); + } + } + + protected void visitNew(Node node, ScriptOrFnNode tree) { + } + + protected void visitCall(Node node, ScriptOrFnNode tree) { + } + + protected Node visitLet(boolean createWith, Node parent, Node previous, + Node scopeNode) + { + Node vars = scopeNode.getFirstChild(); + Node body = vars.getNext(); + scopeNode.removeChild(vars); + scopeNode.removeChild(body); + boolean isExpression = scopeNode.getType() == Token.LETEXPR; + Node result; + Node newVars; + if (createWith) { + result = new Node(isExpression ? Token.WITHEXPR : Token.BLOCK); + result = replaceCurrent(parent, previous, scopeNode, result); + ArrayList<Object> list = new ArrayList<Object>(); + Node objectLiteral = new Node(Token.OBJECTLIT); + for (Node v=vars.getFirstChild(); v != null; v = v.getNext()) { + Node current = v; + if (current.getType() == Token.LETEXPR) { + // destructuring in let expr, e.g. let ([x, y] = [3, 4]) {} + List<?> destructuringNames = (List<?>) + current.getProp(Node.DESTRUCTURING_NAMES); + Node c = current.getFirstChild(); + if (c.getType() != Token.LET) throw Kit.codeBug(); + // Add initialization code to front of body + if (isExpression) { + body = new Node(Token.COMMA, c.getNext(), body); + } else { + body = new Node(Token.BLOCK, + new Node(Token.EXPR_VOID, c.getNext()), + body); + } + // Update "list" and "objectLiteral" for the variables + // defined in the destructuring assignment + if (destructuringNames != null) { + list.addAll(destructuringNames); + for (int i=0; i < destructuringNames.size(); i++) { + objectLiteral.addChildToBack( + new Node(Token.VOID, Node.newNumber(0.0))); + } + } + current = c.getFirstChild(); // should be a NAME, checked below + } + if (current.getType() != Token.NAME) throw Kit.codeBug(); + list.add(ScriptRuntime.getIndexObject(current.getString())); + Node init = current.getFirstChild(); + if (init == null) { + init = new Node(Token.VOID, Node.newNumber(0.0)); + } + objectLiteral.addChildToBack(init); + } + objectLiteral.putProp(Node.OBJECT_IDS_PROP, list.toArray()); + newVars = new Node(Token.ENTERWITH, objectLiteral); + result.addChildToBack(newVars); + result.addChildToBack(new Node(Token.WITH, body)); + result.addChildToBack(new Node(Token.LEAVEWITH)); + } else { + result = new Node(isExpression ? Token.COMMA : Token.BLOCK); + result = replaceCurrent(parent, previous, scopeNode, result); + newVars = new Node(Token.COMMA); + for (Node v=vars.getFirstChild(); v != null; v = v.getNext()) { + Node current = v; + if (current.getType() == Token.LETEXPR) { + // destructuring in let expr, e.g. let ([x, y] = [3, 4]) {} + Node c = current.getFirstChild(); + if (c.getType() != Token.LET) throw Kit.codeBug(); + // Add initialization code to front of body + if (isExpression) { + body = new Node(Token.COMMA, c.getNext(), body); + } else { + body = new Node(Token.BLOCK, + new Node(Token.EXPR_VOID, c.getNext()), + body); + } + // We're removing the LETEXPR, so move the symbols + Node.Scope.joinScopes((Node.Scope)current, + (Node.Scope)scopeNode); + current = c.getFirstChild(); // should be a NAME, checked below + } + if (current.getType() != Token.NAME) throw Kit.codeBug(); + Node stringNode = Node.newString(current.getString()); + stringNode.setScope((Node.Scope)scopeNode); + Node init = current.getFirstChild(); + if (init == null) { + init = new Node(Token.VOID, Node.newNumber(0.0)); + } + newVars.addChildToBack(new Node(Token.SETVAR, stringNode, init)); + } + if (isExpression) { + result.addChildToBack(newVars); + scopeNode.setType(Token.COMMA); + result.addChildToBack(scopeNode); + scopeNode.addChildToBack(body); + } else { + result.addChildToBack(new Node(Token.EXPR_VOID, newVars)); + scopeNode.setType(Token.BLOCK); + result.addChildToBack(scopeNode); + scopeNode.addChildrenToBack(body); + } + } + return result; + } + + private static Node addBeforeCurrent(Node parent, Node previous, + Node current, Node toAdd) + { + if (previous == null) { + if (!(current == parent.getFirstChild())) Kit.codeBug(); + parent.addChildToFront(toAdd); + } else { + if (!(current == previous.getNext())) Kit.codeBug(); + parent.addChildAfter(toAdd, previous); + } + return toAdd; + } + + private static Node replaceCurrent(Node parent, Node previous, + Node current, Node replacement) + { + if (previous == null) { + if (!(current == parent.getFirstChild())) Kit.codeBug(); + parent.replaceChild(current, replacement); + } else if (previous.next == current) { + // Check cachedPrev.next == current is necessary due to possible + // tree mutations + parent.replaceChildAfter(previous, replacement); + } else { + parent.replaceChild(current, replacement); + } + return replacement; + } + + private ObjArray loops; + private ObjArray loopEnds; + private boolean hasFinally; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ObjArray.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ObjArray.java new file mode 100644 index 0000000..a9636a3 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ObjArray.java @@ -0,0 +1,388 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +/** +Implementation of resizable array with focus on minimizing memory usage by storing few initial array elements in object fields. Can also be used as a stack. +*/ + +public class ObjArray implements Serializable +{ + static final long serialVersionUID = 4174889037736658296L; + + public ObjArray() { } + + public final boolean isSealed() + { + return sealed; + } + + public final void seal() + { + sealed = true; + } + + public final boolean isEmpty() + { + return size == 0; + } + + public final int size() + { + return size; + } + + public final void setSize(int newSize) + { + if (newSize < 0) throw new IllegalArgumentException(); + if (sealed) throw onSeledMutation(); + int N = size; + if (newSize < N) { + for (int i = newSize; i != N; ++i) { + setImpl(i, null); + } + } else if (newSize > N) { + if (newSize > FIELDS_STORE_SIZE) { + ensureCapacity(newSize); + } + } + size = newSize; + } + + public final Object get(int index) + { + if (!(0 <= index && index < size)) throw onInvalidIndex(index, size); + return getImpl(index); + } + + public final void set(int index, Object value) + { + if (!(0 <= index && index < size)) throw onInvalidIndex(index, size); + if (sealed) throw onSeledMutation(); + setImpl(index, value); + } + + private Object getImpl(int index) + { + switch (index) { + case 0: return f0; + case 1: return f1; + case 2: return f2; + case 3: return f3; + case 4: return f4; + } + return data[index - FIELDS_STORE_SIZE]; + } + + private void setImpl(int index, Object value) + { + switch (index) { + case 0: f0 = value; break; + case 1: f1 = value; break; + case 2: f2 = value; break; + case 3: f3 = value; break; + case 4: f4 = value; break; + default: data[index - FIELDS_STORE_SIZE] = value; + } + + } + + public int indexOf(Object obj) + { + int N = size; + for (int i = 0; i != N; ++i) { + Object current = getImpl(i); + if (current == obj || (current != null && current.equals(obj))) { + return i; + } + } + return -1; + } + + public int lastIndexOf(Object obj) + { + for (int i = size; i != 0;) { + --i; + Object current = getImpl(i); + if (current == obj || (current != null && current.equals(obj))) { + return i; + } + } + return -1; + } + + public final Object peek() + { + int N = size; + if (N == 0) throw onEmptyStackTopRead(); + return getImpl(N - 1); + } + + public final Object pop() + { + if (sealed) throw onSeledMutation(); + int N = size; + --N; + Object top; + switch (N) { + case -1: throw onEmptyStackTopRead(); + case 0: top = f0; f0 = null; break; + case 1: top = f1; f1 = null; break; + case 2: top = f2; f2 = null; break; + case 3: top = f3; f3 = null; break; + case 4: top = f4; f4 = null; break; + default: + top = data[N - FIELDS_STORE_SIZE]; + data[N - FIELDS_STORE_SIZE] = null; + } + size = N; + return top; + } + + public final void push(Object value) + { + add(value); + } + + public final void add(Object value) + { + if (sealed) throw onSeledMutation(); + int N = size; + if (N >= FIELDS_STORE_SIZE) { + ensureCapacity(N + 1); + } + size = N + 1; + setImpl(N, value); + } + + public final void add(int index, Object value) + { + int N = size; + if (!(0 <= index && index <= N)) throw onInvalidIndex(index, N + 1); + if (sealed) throw onSeledMutation(); + Object tmp; + switch (index) { + case 0: + if (N == 0) { f0 = value; break; } + tmp = f0; f0 = value; value = tmp; + case 1: + if (N == 1) { f1 = value; break; } + tmp = f1; f1 = value; value = tmp; + case 2: + if (N == 2) { f2 = value; break; } + tmp = f2; f2 = value; value = tmp; + case 3: + if (N == 3) { f3 = value; break; } + tmp = f3; f3 = value; value = tmp; + case 4: + if (N == 4) { f4 = value; break; } + tmp = f4; f4 = value; value = tmp; + + index = FIELDS_STORE_SIZE; + default: + ensureCapacity(N + 1); + if (index != N) { + System.arraycopy(data, index - FIELDS_STORE_SIZE, + data, index - FIELDS_STORE_SIZE + 1, + N - index); + } + data[index - FIELDS_STORE_SIZE] = value; + } + size = N + 1; + } + + public final void remove(int index) + { + int N = size; + if (!(0 <= index && index < N)) throw onInvalidIndex(index, N); + if (sealed) throw onSeledMutation(); + --N; + switch (index) { + case 0: + if (N == 0) { f0 = null; break; } + f0 = f1; + case 1: + if (N == 1) { f1 = null; break; } + f1 = f2; + case 2: + if (N == 2) { f2 = null; break; } + f2 = f3; + case 3: + if (N == 3) { f3 = null; break; } + f3 = f4; + case 4: + if (N == 4) { f4 = null; break; } + f4 = data[0]; + + index = FIELDS_STORE_SIZE; + default: + if (index != N) { + System.arraycopy(data, index - FIELDS_STORE_SIZE + 1, + data, index - FIELDS_STORE_SIZE, + N - index); + } + data[N - FIELDS_STORE_SIZE] = null; + } + size = N; + } + + public final void clear() + { + if (sealed) throw onSeledMutation(); + int N = size; + for (int i = 0; i != N; ++i) { + setImpl(i, null); + } + size = 0; + } + + public final Object[] toArray() + { + Object[] array = new Object[size]; + toArray(array, 0); + return array; + } + + public final void toArray(Object[] array) + { + toArray(array, 0); + } + + public final void toArray(Object[] array, int offset) + { + int N = size; + switch (N) { + default: + System.arraycopy(data, 0, array, offset + FIELDS_STORE_SIZE, + N - FIELDS_STORE_SIZE); + case 5: array[offset + 4] = f4; + case 4: array[offset + 3] = f3; + case 3: array[offset + 2] = f2; + case 2: array[offset + 1] = f1; + case 1: array[offset + 0] = f0; + case 0: break; + } + } + + private void ensureCapacity(int minimalCapacity) + { + int required = minimalCapacity - FIELDS_STORE_SIZE; + if (required <= 0) throw new IllegalArgumentException(); + if (data == null) { + int alloc = FIELDS_STORE_SIZE * 2; + if (alloc < required) { + alloc = required; + } + data = new Object[alloc]; + } else { + int alloc = data.length; + if (alloc < required) { + if (alloc <= FIELDS_STORE_SIZE) { + alloc = FIELDS_STORE_SIZE * 2; + } else { + alloc *= 2; + } + if (alloc < required) { + alloc = required; + } + Object[] tmp = new Object[alloc]; + if (size > FIELDS_STORE_SIZE) { + System.arraycopy(data, 0, tmp, 0, + size - FIELDS_STORE_SIZE); + } + data = tmp; + } + } + } + + private static RuntimeException onInvalidIndex(int index, int upperBound) + { + // \u2209 is "NOT ELEMENT OF" + String msg = index+" \u2209 [0, "+upperBound+')'; + throw new IndexOutOfBoundsException(msg); + } + + private static RuntimeException onEmptyStackTopRead() + { + throw new RuntimeException("Empty stack"); + } + + private static RuntimeException onSeledMutation() + { + throw new IllegalStateException("Attempt to modify sealed array"); + } + + private void writeObject(ObjectOutputStream os) throws IOException + { + os.defaultWriteObject(); + int N = size; + for (int i = 0; i != N; ++i) { + Object obj = getImpl(i); + os.writeObject(obj); + } + } + + private void readObject(ObjectInputStream is) + throws IOException, ClassNotFoundException + { + is.defaultReadObject(); // It reads size + int N = size; + if (N > FIELDS_STORE_SIZE) { + data = new Object[N - FIELDS_STORE_SIZE]; + } + for (int i = 0; i != N; ++i) { + Object obj = is.readObject(); + setImpl(i, obj); + } + } + +// Number of data elements + private int size; + + private boolean sealed; + + private static final int FIELDS_STORE_SIZE = 5; + private transient Object f0, f1, f2, f3, f4; + private transient Object[] data; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ObjToIntMap.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ObjToIntMap.java new file mode 100644 index 0000000..4aa7d23 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ObjToIntMap.java @@ -0,0 +1,697 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +/** + * Map to associate objects to integers. + * The map does not synchronize any of its operation, so either use + * it from a single thread or do own synchronization or perform all mutation + * operations on one thread before passing the map to others + * + * @author Igor Bukanov + * + */ + +public class ObjToIntMap implements Serializable +{ + static final long serialVersionUID = -1542220580748809402L; + +// Map implementation via hashtable, +// follows "The Art of Computer Programming" by Donald E. Knuth + +// ObjToIntMap is a copy cat of ObjToIntMap with API adjusted to object keys + + public static class Iterator { + + Iterator(ObjToIntMap master) { + this.master = master; + } + + final void init(Object[] keys, int[] values, int keyCount) { + this.keys = keys; + this.values = values; + this.cursor = -1; + this.remaining = keyCount; + } + + public void start() { + master.initIterator(this); + next(); + } + + public boolean done() { + return remaining < 0; + } + + public void next() { + if (remaining == -1) Kit.codeBug(); + if (remaining == 0) { + remaining = -1; + cursor = -1; + }else { + for (++cursor; ; ++cursor) { + Object key = keys[cursor]; + if (key != null && key != DELETED) { + --remaining; + break; + } + } + } + } + + public Object getKey() { + Object key = keys[cursor]; + if (key == UniqueTag.NULL_VALUE) { key = null; } + return key; + } + + public int getValue() { + return values[cursor]; + } + + public void setValue(int value) { + values[cursor] = value; + } + + ObjToIntMap master; + private int cursor; + private int remaining; + private Object[] keys; + private int[] values; + } + + public ObjToIntMap() { + this(4); + } + + public ObjToIntMap(int keyCountHint) { + if (keyCountHint < 0) Kit.codeBug(); + // Table grow when number of stored keys >= 3/4 of max capacity + int minimalCapacity = keyCountHint * 4 / 3; + int i; + for (i = 2; (1 << i) < minimalCapacity; ++i) { } + power = i; + if (check && power < 2) Kit.codeBug(); + } + + public boolean isEmpty() { + return keyCount == 0; + } + + public int size() { + return keyCount; + } + + public boolean has(Object key) { + if (key == null) { key = UniqueTag.NULL_VALUE; } + return 0 <= findIndex(key); + } + + /** + * Get integer value assigned with key. + * @return key integer value or defaultValue if key is absent + */ + public int get(Object key, int defaultValue) { + if (key == null) { key = UniqueTag.NULL_VALUE; } + int index = findIndex(key); + if (0 <= index) { + return values[index]; + } + return defaultValue; + } + + /** + * Get integer value assigned with key. + * @return key integer value + * @throws RuntimeException if key does not exist + */ + public int getExisting(Object key) { + if (key == null) { key = UniqueTag.NULL_VALUE; } + int index = findIndex(key); + if (0 <= index) { + return values[index]; + } + // Key must exist + Kit.codeBug(); + return 0; + } + + public void put(Object key, int value) { + if (key == null) { key = UniqueTag.NULL_VALUE; } + int index = ensureIndex(key); + values[index] = value; + } + + /** + * If table already contains a key that equals to keyArg, return that key + * while setting its value to zero, otherwise add keyArg with 0 value to + * the table and return it. + */ + public Object intern(Object keyArg) { + boolean nullKey = false; + if (keyArg == null) { + nullKey = true; + keyArg = UniqueTag.NULL_VALUE; + } + int index = ensureIndex(keyArg); + values[index] = 0; + return (nullKey) ? null : keys[index]; + } + + public void remove(Object key) { + if (key == null) { key = UniqueTag.NULL_VALUE; } + int index = findIndex(key); + if (0 <= index) { + keys[index] = DELETED; + --keyCount; + } + } + + public void clear() { + int i = keys.length; + while (i != 0) { + keys[--i] = null; + } + keyCount = 0; + occupiedCount = 0; + } + + public Iterator newIterator() { + return new Iterator(this); + } + + // The sole purpose of the method is to avoid accessing private fields + // from the Iterator inner class to workaround JDK 1.1 compiler bug which + // generates code triggering VerifierError on recent JVMs + final void initIterator(Iterator i) { + i.init(keys, values, keyCount); + } + + /** Return array of present keys */ + public Object[] getKeys() { + Object[] array = new Object[keyCount]; + getKeys(array, 0); + return array; + } + + public void getKeys(Object[] array, int offset) { + int count = keyCount; + for (int i = 0; count != 0; ++i) { + Object key = keys[i]; + if (key != null && key != DELETED) { + if (key == UniqueTag.NULL_VALUE) { key = null; } + array[offset] = key; + ++offset; + --count; + } + } + } + + private static int tableLookupStep(int fraction, int mask, int power) { + int shift = 32 - 2 * power; + if (shift >= 0) { + return ((fraction >>> shift) & mask) | 1; + } + else { + return (fraction & (mask >>> -shift)) | 1; + } + } + + private int findIndex(Object key) { + if (keys != null) { + int hash = key.hashCode(); + int fraction = hash * A; + int index = fraction >>> (32 - power); + Object test = keys[index]; + if (test != null) { + int N = 1 << power; + if (test == key + || (values[N + index] == hash && test.equals(key))) + { + return index; + } + // Search in table after first failed attempt + int mask = N - 1; + int step = tableLookupStep(fraction, mask, power); + int n = 0; + for (;;) { + if (check) { + if (n >= occupiedCount) Kit.codeBug(); + ++n; + } + index = (index + step) & mask; + test = keys[index]; + if (test == null) { + break; + } + if (test == key + || (values[N + index] == hash && test.equals(key))) + { + return index; + } + } + } + } + return -1; + } + +// Insert key that is not present to table without deleted entries +// and enough free space + private int insertNewKey(Object key, int hash) { + if (check && occupiedCount != keyCount) Kit.codeBug(); + if (check && keyCount == 1 << power) Kit.codeBug(); + int fraction = hash * A; + int index = fraction >>> (32 - power); + int N = 1 << power; + if (keys[index] != null) { + int mask = N - 1; + int step = tableLookupStep(fraction, mask, power); + int firstIndex = index; + do { + if (check && keys[index] == DELETED) Kit.codeBug(); + index = (index + step) & mask; + if (check && firstIndex == index) Kit.codeBug(); + } while (keys[index] != null); + } + keys[index] = key; + values[N + index] = hash; + ++occupiedCount; + ++keyCount; + + return index; + } + + private void rehashTable() { + if (keys == null) { + if (check && keyCount != 0) Kit.codeBug(); + if (check && occupiedCount != 0) Kit.codeBug(); + int N = 1 << power; + keys = new Object[N]; + values = new int[2 * N]; + } + else { + // Check if removing deleted entries would free enough space + if (keyCount * 2 >= occupiedCount) { + // Need to grow: less then half of deleted entries + ++power; + } + int N = 1 << power; + Object[] oldKeys = keys; + int[] oldValues = values; + int oldN = oldKeys.length; + keys = new Object[N]; + values = new int[2 * N]; + + int remaining = keyCount; + occupiedCount = keyCount = 0; + for (int i = 0; remaining != 0; ++i) { + Object key = oldKeys[i]; + if (key != null && key != DELETED) { + int keyHash = oldValues[oldN + i]; + int index = insertNewKey(key, keyHash); + values[index] = oldValues[i]; + --remaining; + } + } + } + } + +// Ensure key index creating one if necessary + private int ensureIndex(Object key) { + int hash = key.hashCode(); + int index = -1; + int firstDeleted = -1; + if (keys != null) { + int fraction = hash * A; + index = fraction >>> (32 - power); + Object test = keys[index]; + if (test != null) { + int N = 1 << power; + if (test == key + || (values[N + index] == hash && test.equals(key))) + { + return index; + } + if (test == DELETED) { + firstDeleted = index; + } + + // Search in table after first failed attempt + int mask = N - 1; + int step = tableLookupStep(fraction, mask, power); + int n = 0; + for (;;) { + if (check) { + if (n >= occupiedCount) Kit.codeBug(); + ++n; + } + index = (index + step) & mask; + test = keys[index]; + if (test == null) { + break; + } + if (test == key + || (values[N + index] == hash && test.equals(key))) + { + return index; + } + if (test == DELETED && firstDeleted < 0) { + firstDeleted = index; + } + } + } + } + // Inserting of new key + if (check && keys != null && keys[index] != null) + Kit.codeBug(); + if (firstDeleted >= 0) { + index = firstDeleted; + } + else { + // Need to consume empty entry: check occupation level + if (keys == null || occupiedCount * 4 >= (1 << power) * 3) { + // Too litle unused entries: rehash + rehashTable(); + return insertNewKey(key, hash); + } + ++occupiedCount; + } + keys[index] = key; + values[(1 << power) + index] = hash; + ++keyCount; + return index; + } + + private void writeObject(ObjectOutputStream out) + throws IOException + { + out.defaultWriteObject(); + + int count = keyCount; + for (int i = 0; count != 0; ++i) { + Object key = keys[i]; + if (key != null && key != DELETED) { + --count; + out.writeObject(key); + out.writeInt(values[i]); + } + } + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + + int writtenKeyCount = keyCount; + if (writtenKeyCount != 0) { + keyCount = 0; + int N = 1 << power; + keys = new Object[N]; + values = new int[2 * N]; + for (int i = 0; i != writtenKeyCount; ++i) { + Object key = in.readObject(); + int hash = key.hashCode(); + int index = insertNewKey(key, hash); + values[index] = in.readInt(); + } + } + } + +// A == golden_ratio * (1 << 32) = ((sqrt(5) - 1) / 2) * (1 << 32) +// See Knuth etc. + private static final int A = 0x9e3779b9; + + private static final Object DELETED = new Object(); + +// Structure of kyes and values arrays (N == 1 << power): +// keys[0 <= i < N]: key value or null or DELETED mark +// values[0 <= i < N]: value of key at keys[i] +// values[N <= i < 2*N]: hash code of key at keys[i-N] + + private transient Object[] keys; + private transient int[] values; + + private int power; + private int keyCount; + private transient int occupiedCount; // == keyCount + deleted_count + +// If true, enables consitency checks + private static final boolean check = false; + +/* TEST START + + public static void main(String[] args) { + if (!check) { + System.err.println("Set check to true and re-run"); + throw new RuntimeException("Set check to true and re-run"); + } + + ObjToIntMap map; + map = new ObjToIntMap(0); + testHash(map, 3); + map = new ObjToIntMap(0); + testHash(map, 10 * 1000); + map = new ObjToIntMap(); + testHash(map, 10 * 1000); + map = new ObjToIntMap(30 * 1000); + testHash(map, 10 * 100); + map.clear(); + testHash(map, 4); + map = new ObjToIntMap(0); + testHash(map, 10 * 100); + } + + private static void testHash(ObjToIntMap map, int N) { + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + check(-1 == map.get(key, -1)); + map.put(key, i); + check(i == map.get(key, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + map.put(key, i); + check(i == map.get(key, -1)); + } + + check(map.size() == N); + + System.out.print("."); System.out.flush(); + Object[] keys = map.getKeys(); + check(keys.length == N); + for (int i = 0; i != N; ++i) { + Object key = keys[i]; + check(map.has(key)); + } + + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + check(i == map.get(key, -1)); + } + + int Nsqrt = -1; + for (int i = 0; ; ++i) { + if (i * i >= N) { + Nsqrt = i; + break; + } + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i * i); + map.put(key, i); + check(i == map.get(key, -1)); + } + + check(map.size() == 2 * N - Nsqrt); + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i * i); + check(i == map.get(key, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(-1 - i * i); + map.put(key, i); + check(i == map.get(key, -1)); + } + + check(map.size() == 3 * N - Nsqrt); + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(-1 - i * i); + map.remove(key); + check(!map.has(key)); + } + + check(map.size() == 2 * N - Nsqrt); + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i * i); + check(i == map.get(key, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + int j = intSqrt(i); + if (j * j == i) { + check(j == map.get(key, -1)); + }else { + check(i == map.get(key, -1)); + } + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i * i); + map.remove(key); + check(-2 == map.get(key, -2)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + map.put(key, i); + check(i == map.get(key, -2)); + } + + check(map.size() == N); + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + check(i == map.get(key, -1)); + } + + System.out.print("."); System.out.flush(); + ObjToIntMap copy = (ObjToIntMap)writeAndRead(map); + check(copy.size() == N); + + for (int i = 0; i != N; ++i) { + Object key = testKey(i); + check(i == copy.get(key, -1)); + } + + System.out.print("."); System.out.flush(); + checkSameMaps(copy, map); + + System.out.println(); System.out.flush(); + } + + private static void checkSameMaps(ObjToIntMap map1, ObjToIntMap map2) { + check(map1.size() == map2.size()); + Object[] keys = map1.getKeys(); + check(keys.length == map1.size()); + for (int i = 0; i != keys.length; ++i) { + check(map1.get(keys[i], -1) == map2.get(keys[i], -1)); + } + } + + private static void check(boolean condition) { + if (!condition) Kit.codeBug(); + } + + private static Object[] testPool; + + private static Object testKey(int i) { + int MAX_POOL = 100; + if (0 <= i && i < MAX_POOL) { + if (testPool != null && testPool[i] != null) { + return testPool[i]; + } + } + Object x = new Double(i + 0.5); + if (0 <= i && i < MAX_POOL) { + if (testPool == null) { + testPool = new Object[MAX_POOL]; + } + testPool[i] = x; + } + return x; + } + + private static int intSqrt(int i) { + int approx = (int)Math.sqrt(i) + 1; + while (approx * approx > i) { + --approx; + } + return approx; + } + + private static Object writeAndRead(Object obj) { + try { + java.io.ByteArrayOutputStream + bos = new java.io.ByteArrayOutputStream(); + java.io.ObjectOutputStream + out = new java.io.ObjectOutputStream(bos); + out.writeObject(obj); + out.close(); + byte[] data = bos.toByteArray(); + java.io.ByteArrayInputStream + bis = new java.io.ByteArrayInputStream(data); + java.io.ObjectInputStream + in = new java.io.ObjectInputStream(bis); + Object result = in.readObject(); + in.close(); + return result; + }catch (Exception ex) { + throw new RuntimeException("Unexpected"); + } + } + +// TEST END */ + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Parser.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Parser.java new file mode 100644 index 0000000..80cb937 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Parser.java @@ -0,0 +1,2554 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Mike Ang + * Igor Bukanov + * Yuh-Ruey Chen + * Ethan Hugg + * Bob Jervis + * Terry Lucas + * Mike McCabe + * Milen Nankov + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Reader; +import java.io.IOException; +import java.util.Hashtable; + +/** + * This class implements the JavaScript parser. + * + * It is based on the C source files jsparse.c and jsparse.h + * in the jsref package. + * + * @see TokenStream + * + * @author Mike McCabe + * @author Brendan Eich + */ + +public class Parser +{ + // TokenInformation flags : currentFlaggedToken stores them together + // with token type + final static int + CLEAR_TI_MASK = 0xFFFF, // mask to clear token information bits + TI_AFTER_EOL = 1 << 16, // first token of the source line + TI_CHECK_LABEL = 1 << 17; // indicates to check for label + + CompilerEnvirons compilerEnv; + private ErrorReporter errorReporter; + /*APPJET*//*no longer:private*/ String sourceURI; + boolean calledByCompileFunction; + + /*APPJET*//*no longer:private*/ TokenStream ts; + private int currentFlaggedToken; + /*APPJET*//*no longer:private*/ int syntaxErrorCount; + + private IRFactory nf; + + private int nestingOfFunction; + + private Decompiler decompiler; + private String encodedSource; + +// The following are per function variables and should be saved/restored +// during function parsing. +// XXX Move to separated class? + ScriptOrFnNode currentScriptOrFn; + Node.Scope currentScope; + private int nestingOfWith; + private Hashtable labelSet; // map of label names into nodes + private ObjArray loopSet; + private ObjArray loopAndSwitchSet; + private boolean hasReturnValue; + private int endFlags; +// end of per function variables + + /*APPJET*/public int lastConsumedTokenLine = -1; + + public int getCurrentLineNumber() { + return ts.getLineno(); + } + + // Exception to unwind + private static class ParserException extends RuntimeException + { + static final long serialVersionUID = 5882582646773765630L; + } + + public Parser(CompilerEnvirons compilerEnv, ErrorReporter errorReporter) + { + this.compilerEnv = compilerEnv; + this.errorReporter = errorReporter; + } + + protected Decompiler createDecompiler(CompilerEnvirons compilerEnv) + { + return new Decompiler(); + } + + void addStrictWarning(String messageId, String messageArg) + { + if (compilerEnv.isStrictMode()) + addWarning(messageId, messageArg); + } + + void addWarning(String messageId, String messageArg) + { + String message = ScriptRuntime.getMessage1(messageId, messageArg); + if (compilerEnv.reportWarningAsError()) { + ++syntaxErrorCount; + errorReporter.error(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } else + errorReporter.warning(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } + + void addError(String messageId) + { + ++syntaxErrorCount; + String message = ScriptRuntime.getMessage0(messageId); + errorReporter.error(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } + + void addError(String messageId, String messageArg) + { + ++syntaxErrorCount; + String message = ScriptRuntime.getMessage1(messageId, messageArg); + errorReporter.error(message, sourceURI, ts.getLineno(), + ts.getLine(), ts.getOffset()); + } + + RuntimeException reportError(String messageId) + { + addError(messageId); + + // Throw a ParserException exception to unwind the recursive descent + // parse. + throw new ParserException(); + } + + /*APPJET*//*added method*/ + RuntimeException reportError(String messageId, String messageArg) + { + addError(messageId, messageArg); + + // Throw a ParserException exception to unwind the recursive descent + // parse. + throw new ParserException(); + } + + /*APPJET*//*no longer: private*/int peekToken() + throws IOException + { + int tt = currentFlaggedToken; + if (tt == Token.EOF) { + tt = ts.getToken(); + if (tt == Token.EOL) { + do { + tt = ts.getToken(); + } while (tt == Token.EOL); + tt |= TI_AFTER_EOL; + } + currentFlaggedToken = tt; + } + return tt & CLEAR_TI_MASK; + } + + private int peekFlaggedToken() + throws IOException + { + peekToken(); + return currentFlaggedToken; + } + + /*APPJET*//*no longer:private*/ void consumeToken() + { + currentFlaggedToken = Token.EOF; + /*APPJET*/lastConsumedTokenLine = ts.getLineno(); + } + + private int nextToken() + throws IOException + { + int tt = peekToken(); + consumeToken(); + return tt; + } + + private int nextFlaggedToken() + throws IOException + { + peekToken(); + int ttFlagged = currentFlaggedToken; + consumeToken(); + return ttFlagged; + } + + private boolean matchToken(int toMatch) + throws IOException + { + int tt = peekToken(); + if (tt != toMatch) { + return false; + } + consumeToken(); + return true; + } + + private int peekTokenOrEOL() + throws IOException + { + int tt = peekToken(); + // Check for last peeked token flags + if ((currentFlaggedToken & TI_AFTER_EOL) != 0) { + tt = Token.EOL; + } + return tt; + } + + private void setCheckForLabel() + { + if ((currentFlaggedToken & CLEAR_TI_MASK) != Token.NAME) + throw Kit.codeBug(); + currentFlaggedToken |= TI_CHECK_LABEL; + } + + private void mustMatchToken(int toMatch, String messageId) + throws IOException, ParserException + { + if (!matchToken(toMatch)) { + reportError(messageId); + } + } + + /*APPJET*//*added method*/ + private void mustMatchToken(int toMatch, String messageId, String messageArg) + throws IOException, ParserException + { + if (!matchToken(toMatch)) { + reportError(messageId, messageArg); + } + } + + private void mustHaveXML() + { + if (!compilerEnv.isXmlAvailable()) { + reportError("msg.XML.not.available"); + } + } + + public String getEncodedSource() + { + return encodedSource; + } + + public boolean eof() + { + return ts.eof(); + } + + boolean insideFunction() + { + return nestingOfFunction != 0; + } + + void pushScope(Node node) { + Node.Scope scopeNode = (Node.Scope) node; + if (scopeNode.getParentScope() != null) throw Kit.codeBug(); + scopeNode.setParent(currentScope); + currentScope = scopeNode; + } + + void popScope() { + currentScope = currentScope.getParentScope(); + } + + private Node enterLoop(Node loopLabel, boolean doPushScope) + { + Node loop = nf.createLoopNode(loopLabel, ts.getLineno()); + if (loopSet == null) { + loopSet = new ObjArray(); + if (loopAndSwitchSet == null) { + loopAndSwitchSet = new ObjArray(); + } + } + loopSet.push(loop); + loopAndSwitchSet.push(loop); + if (doPushScope) { + pushScope(loop); + } + return loop; + } + + private void exitLoop(boolean doPopScope) + { + loopSet.pop(); + loopAndSwitchSet.pop(); + if (doPopScope) { + popScope(); + } + } + + private Node enterSwitch(Node switchSelector, int lineno) + { + Node switchNode = nf.createSwitch(switchSelector, lineno); + if (loopAndSwitchSet == null) { + loopAndSwitchSet = new ObjArray(); + } + loopAndSwitchSet.push(switchNode); + return switchNode; + } + + private void exitSwitch() + { + loopAndSwitchSet.pop(); + } + + /* + * Build a parse tree from the given sourceString. + * + * @return an Object representing the parsed + * program. If the parse fails, null will be returned. (The + * parse failure will result in a call to the ErrorReporter from + * CompilerEnvirons.) + */ + public ScriptOrFnNode parse(String sourceString, + String sourceURI, int lineno) + { + this.sourceURI = sourceURI; + this.ts = new TokenStream(this, null, sourceString, lineno); + try { + return parse(); + } catch (IOException ex) { + // Should never happen + throw new IllegalStateException(); + } + } + + /* + * Build a parse tree from the given sourceString. + * + * @return an Object representing the parsed + * program. If the parse fails, null will be returned. (The + * parse failure will result in a call to the ErrorReporter from + * CompilerEnvirons.) + */ + public ScriptOrFnNode parse(Reader sourceReader, + String sourceURI, int lineno) + throws IOException + { + this.sourceURI = sourceURI; + this.ts = new TokenStream(this, sourceReader, null, lineno); + return parse(); + } + + private ScriptOrFnNode parse() + throws IOException + { + this.decompiler = createDecompiler(compilerEnv); + this.nf = new IRFactory(this); + currentScriptOrFn = nf.createScript(); + currentScope = currentScriptOrFn; + int sourceStartOffset = decompiler.getCurrentOffset(); + this.encodedSource = null; + decompiler.addToken(Token.SCRIPT); + + this.currentFlaggedToken = Token.EOF; + this.syntaxErrorCount = 0; + + int baseLineno = ts.getLineno(); // line number where source starts + + /*APPJET*/lastConsumedTokenLine = baseLineno; + + /* so we have something to add nodes to until + * we've collected all the source */ + Node pn = nf.createLeaf(Token.BLOCK); + + try { + for (;;) { + int tt = peekToken(); + + if (tt <= Token.EOF) { + break; + } + + Node n; + if (tt == Token.FUNCTION) { + consumeToken(); + try { + n = function(calledByCompileFunction + ? FunctionNode.FUNCTION_EXPRESSION + : FunctionNode.FUNCTION_STATEMENT); + } catch (ParserException e) { + break; + } + } else { + n = statement(); + } + nf.addChildToBack(pn, n); + } + } catch (StackOverflowError ex) { + String msg = ScriptRuntime.getMessage0( + "msg.too.deep.parser.recursion"); + throw Context.reportRuntimeError(msg, sourceURI, + ts.getLineno(), null, 0); + } + + if (this.syntaxErrorCount != 0) { + String msg = String.valueOf(this.syntaxErrorCount); + msg = ScriptRuntime.getMessage1("msg.got.syntax.errors", msg); + throw errorReporter.runtimeError(msg, sourceURI, baseLineno, + null, 0); + } + + currentScriptOrFn.setSourceName(sourceURI); + currentScriptOrFn.setBaseLineno(baseLineno); + currentScriptOrFn.setEndLineno(ts.getLineno()); + + int sourceEndOffset = decompiler.getCurrentOffset(); + currentScriptOrFn.setEncodedSourceBounds(sourceStartOffset, + sourceEndOffset); + + nf.initScript(currentScriptOrFn, pn); + + if (compilerEnv.isGeneratingSource()) { + encodedSource = decompiler.getEncodedSource(); + } + this.decompiler = null; // It helps GC + + return currentScriptOrFn; + } + + /* + * The C version of this function takes an argument list, + * which doesn't seem to be needed for tree generation... + * it'd only be useful for checking argument hiding, which + * I'm not doing anyway... + */ + private Node parseFunctionBody() + throws IOException + { + ++nestingOfFunction; + Node pn = nf.createBlock(ts.getLineno()); + try { + bodyLoop: for (;;) { + Node n; + int tt = peekToken(); + switch (tt) { + case Token.ERROR: + case Token.EOF: + case Token.RC: + break bodyLoop; + + case Token.FUNCTION: + consumeToken(); + n = function(FunctionNode.FUNCTION_STATEMENT); + break; + default: + n = statement(); + break; + } + nf.addChildToBack(pn, n); + } + } catch (ParserException e) { + // Ignore it + } finally { + --nestingOfFunction; + } + + return pn; + } + + private Node function(int functionType) + throws IOException, ParserException + { + int syntheticType = functionType; + int baseLineno = ts.getLineno(); // line number where source starts + + int functionSourceStart = decompiler.markFunctionStart(functionType); + String name; + Node memberExprNode = null; + if (matchToken(Token.NAME)) { + name = ts.getString(); + decompiler.addName(name); + if (!matchToken(Token.LP)) { + if (compilerEnv.isAllowMemberExprAsFunctionName()) { + // Extension to ECMA: if 'function <name>' does not follow + // by '(', assume <name> starts memberExpr + Node memberExprHead = nf.createName(name); + name = ""; + memberExprNode = memberExprTail(false, memberExprHead); + } + mustMatchToken(Token.LP, "msg.no.paren.parms"); + } + } else if (matchToken(Token.LP)) { + // Anonymous function + name = ""; + } else { + name = ""; + if (compilerEnv.isAllowMemberExprAsFunctionName()) { + // Note that memberExpr can not start with '(' like + // in function (1+2).toString(), because 'function (' already + // processed as anonymous function + memberExprNode = memberExpr(false); + } + mustMatchToken(Token.LP, "msg.no.paren.parms"); + } + + if (memberExprNode != null) { + syntheticType = FunctionNode.FUNCTION_EXPRESSION; + } + + if (syntheticType != FunctionNode.FUNCTION_EXPRESSION && + name.length() > 0) + { + // Function statements define a symbol in the enclosing scope + defineSymbol(Token.FUNCTION, name); + } + + boolean nested = insideFunction(); + + FunctionNode fnNode = nf.createFunction(name); + if (nested || nestingOfWith > 0) { + // 1. Nested functions are not affected by the dynamic scope flag + // as dynamic scope is already a parent of their scope. + // 2. Functions defined under the with statement also immune to + // this setup, in which case dynamic scope is ignored in favor + // of with object. + fnNode.itsIgnoreDynamicScope = true; + } + int functionIndex = currentScriptOrFn.addFunction(fnNode); + + int functionSourceEnd; + + ScriptOrFnNode savedScriptOrFn = currentScriptOrFn; + currentScriptOrFn = fnNode; + Node.Scope savedCurrentScope = currentScope; + currentScope = fnNode; + int savedNestingOfWith = nestingOfWith; + nestingOfWith = 0; + Hashtable savedLabelSet = labelSet; + labelSet = null; + ObjArray savedLoopSet = loopSet; + loopSet = null; + ObjArray savedLoopAndSwitchSet = loopAndSwitchSet; + loopAndSwitchSet = null; + boolean savedHasReturnValue = hasReturnValue; + int savedFunctionEndFlags = endFlags; + + Node destructuring = null; + Node body; + try { + decompiler.addToken(Token.LP); + if (!matchToken(Token.RP)) { + boolean first = true; + do { + if (!first) + decompiler.addToken(Token.COMMA); + first = false; + int tt = peekToken(); + if (tt == Token.LB || tt == Token.LC) { + // Destructuring assignment for parameters: add a + // dummy parameter name, and add a statement to the + // body to initialize variables from the destructuring + // assignment + if (destructuring == null) { + destructuring = new Node(Token.COMMA); + } + String parmName = currentScriptOrFn.getNextTempName(); + defineSymbol(Token.LP, parmName); + destructuring.addChildToBack( + nf.createDestructuringAssignment(Token.VAR, + primaryExpr(), nf.createName(parmName))); + } else { + mustMatchToken(Token.NAME, "msg.no.parm"); + String s = ts.getString(); + defineSymbol(Token.LP, s); + decompiler.addName(s); + } + } while (matchToken(Token.COMMA)); + + mustMatchToken(Token.RP, "msg.no.paren.after.parms"); + } + decompiler.addToken(Token.RP); + + mustMatchToken(Token.LC, "msg.no.brace.body"); + decompiler.addEOL(Token.LC); + body = parseFunctionBody(); + if (destructuring != null) { + body.addChildToFront( + new Node(Token.EXPR_VOID, destructuring, ts.getLineno())); + } + mustMatchToken(Token.RC, "msg.no.brace.after.body"); + + if (compilerEnv.isStrictMode() && !body.hasConsistentReturnUsage()) + { + String msg = name.length() > 0 ? "msg.no.return.value" + : "msg.anon.no.return.value"; + addStrictWarning(msg, name); + } + + if (syntheticType == FunctionNode.FUNCTION_EXPRESSION && + name.length() > 0 && currentScope.getSymbol(name) == null) + { + // Function expressions define a name only in the body of the + // function, and only if not hidden by a parameter name + defineSymbol(Token.FUNCTION, name); + } + + decompiler.addToken(Token.RC); + functionSourceEnd = decompiler.markFunctionEnd(functionSourceStart); + if (functionType != FunctionNode.FUNCTION_EXPRESSION) { + // Add EOL only if function is not part of expression + // since it gets SEMI + EOL from Statement in that case + decompiler.addToken(Token.EOL); + } + } + finally { + hasReturnValue = savedHasReturnValue; + endFlags = savedFunctionEndFlags; + loopAndSwitchSet = savedLoopAndSwitchSet; + loopSet = savedLoopSet; + labelSet = savedLabelSet; + nestingOfWith = savedNestingOfWith; + currentScriptOrFn = savedScriptOrFn; + currentScope = savedCurrentScope; + } + + fnNode.setEncodedSourceBounds(functionSourceStart, functionSourceEnd); + fnNode.setSourceName(sourceURI); + fnNode.setBaseLineno(baseLineno); + fnNode.setEndLineno(ts.getLineno()); + + Node pn = nf.initFunction(fnNode, functionIndex, body, syntheticType); + if (memberExprNode != null) { + pn = nf.createAssignment(Token.ASSIGN, memberExprNode, pn); + if (functionType != FunctionNode.FUNCTION_EXPRESSION) { + // XXX check JScript behavior: should it be createExprStatement? + pn = nf.createExprStatementNoReturn(pn, baseLineno); + } + } + return pn; + } + + private Node statements(Node scope) + throws IOException + { + Node pn = scope != null ? scope : nf.createBlock(ts.getLineno()); + + int tt; + while ((tt = peekToken()) > Token.EOF && tt != Token.RC) { + nf.addChildToBack(pn, statement()); + } + + return pn; + } + + private Node condition() + throws IOException, ParserException + { + mustMatchToken(Token.LP, "msg.no.paren.cond"); + decompiler.addToken(Token.LP); + Node pn = expr(false); + mustMatchToken(Token.RP, "msg.no.paren.after.cond"); + decompiler.addToken(Token.RP); + + // Report strict warning on code like "if (a = 7) ...". Suppress the + // warning if the condition is parenthesized, like "if ((a = 7)) ...". + if (pn.getProp(Node.PARENTHESIZED_PROP) == null && + (pn.getType() == Token.SETNAME || pn.getType() == Token.SETPROP || + pn.getType() == Token.SETELEM)) + { + addStrictWarning("msg.equal.as.assign", ""); + } + return pn; + } + + // match a NAME; return null if no match. + private Node matchJumpLabelName() + throws IOException, ParserException + { + Node label = null; + + int tt = peekTokenOrEOL(); + if (tt == Token.NAME) { + consumeToken(); + String name = ts.getString(); + decompiler.addName(name); + if (labelSet != null) { + label = (Node)labelSet.get(name); + } + if (label == null) { + reportError("msg.undef.label"); + } + } + + return label; + } + + private Node statement() + throws IOException + { + try { + Node pn = statementHelper(null); + if (pn != null) { + if (compilerEnv.isStrictMode() && !pn.hasSideEffects()) + addStrictWarning("msg.no.side.effects", ""); + return pn; + } + } catch (ParserException e) { } + + // skip to end of statement + int lineno = ts.getLineno(); + guessingStatementEnd: for (;;) { + int tt = peekTokenOrEOL(); + consumeToken(); + switch (tt) { + case Token.ERROR: + case Token.EOF: + case Token.EOL: + case Token.SEMI: + break guessingStatementEnd; + } + } + return nf.createExprStatement(nf.createName("error"), lineno); + } + + /*APPJET*/ /*begin*/ + private Node statementHelper(Node statementLabel) + throws IOException, ParserException { + + Node pn = statementHelper0(statementLabel); + if (pn != null && pn.getType() != Token.BLOCK && pn.getType() != Token.LOOP) { + pn.statementEndLineNum = lastConsumedTokenLine; + } + return pn; + } + /*end*/ + + private Node statementHelper0(Node statementLabel) /*APPJET*/ + throws IOException, ParserException + { + Node pn = null; + int tt = peekToken(); + + switch (tt) { + case Token.IF: { + consumeToken(); + + decompiler.addToken(Token.IF); + int lineno = ts.getLineno(); + Node cond = condition(); + /*APPJET*/cond.lineno = lineno; + /*APPJET*/cond.statementEndLineNum = lastConsumedTokenLine; + decompiler.addEOL(Token.LC); + Node ifTrue = statement(); + Node ifFalse = null; + if (matchToken(Token.ELSE)) { + decompiler.addToken(Token.RC); + decompiler.addToken(Token.ELSE); + decompiler.addEOL(Token.LC); + ifFalse = statement(); + } + decompiler.addEOL(Token.RC); + pn = nf.createIf(cond, ifTrue, ifFalse, lineno); + return pn; + } + + case Token.SWITCH: { + consumeToken(); + + decompiler.addToken(Token.SWITCH); + int lineno = ts.getLineno(); + mustMatchToken(Token.LP, "msg.no.paren.switch"); + decompiler.addToken(Token.LP); + /*APPJET*/Node toSwitchOn = expr(false); + /*APPJET*/toSwitchOn.lineno = lineno; + /*APPJET*/toSwitchOn.statementEndLineNum = lastConsumedTokenLine; + pn = enterSwitch(toSwitchOn, lineno); /*APPJET*/ + try { + mustMatchToken(Token.RP, "msg.no.paren.after.switch"); + decompiler.addToken(Token.RP); + mustMatchToken(Token.LC, "msg.no.brace.switch"); + decompiler.addEOL(Token.LC); + + boolean hasDefault = false; + switchLoop: for (;;) { + tt = nextToken(); + Node caseExpression; + switch (tt) { + case Token.RC: + break switchLoop; + + case Token.CASE: + decompiler.addToken(Token.CASE); + caseExpression = expr(false); + mustMatchToken(Token.COLON, "msg.no.colon.case"); + decompiler.addEOL(Token.COLON); + break; + + case Token.DEFAULT: + if (hasDefault) { + reportError("msg.double.switch.default"); + } + decompiler.addToken(Token.DEFAULT); + hasDefault = true; + caseExpression = null; + mustMatchToken(Token.COLON, "msg.no.colon.case"); + decompiler.addEOL(Token.COLON); + break; + + default: + reportError("msg.bad.switch"); + break switchLoop; + } + + Node block = nf.createLeaf(Token.BLOCK); + while ((tt = peekToken()) != Token.RC + && tt != Token.CASE + && tt != Token.DEFAULT + && tt != Token.EOF) + { + nf.addChildToBack(block, statement()); + } + + // caseExpression == null => add default label + nf.addSwitchCase(pn, caseExpression, block); + } + decompiler.addEOL(Token.RC); + nf.closeSwitch(pn); + } finally { + exitSwitch(); + } + return pn; + } + + case Token.WHILE: { + consumeToken(); + decompiler.addToken(Token.WHILE); + + Node loop = enterLoop(statementLabel, true); + try { + /*APPJET*/int lineno = ts.getLineno(); + Node cond = condition(); + /*APPJET*/cond.lineno = lineno; + /*APPJET*/cond.statementEndLineNum = lastConsumedTokenLine; + decompiler.addEOL(Token.LC); + Node body = statement(); + decompiler.addEOL(Token.RC); + pn = nf.createWhile(loop, cond, body); + } finally { + exitLoop(true); + } + return pn; + } + + case Token.DO: { + consumeToken(); + decompiler.addToken(Token.DO); + decompiler.addEOL(Token.LC); + + Node loop = enterLoop(statementLabel, true); + try { + Node body = statement(); + decompiler.addToken(Token.RC); + mustMatchToken(Token.WHILE, "msg.no.while.do"); + decompiler.addToken(Token.WHILE); + Node cond = condition(); + pn = nf.createDoWhile(loop, body, cond); + } finally { + exitLoop(true); + } + // Always auto-insert semicolon to follow SpiderMonkey: + // It is required by ECMAScript but is ignored by the rest of + // world, see bug 238945 + matchToken(Token.SEMI); + decompiler.addEOL(Token.SEMI); + return pn; + } + + case Token.FOR: { + consumeToken(); + boolean isForEach = false; + decompiler.addToken(Token.FOR); + + Node loop = enterLoop(statementLabel, true); + try { + Node init; // Node init is also foo in 'foo in object' + Node cond; // Node cond is also object in 'foo in object' + Node incr = null; + Node body; + int declType = -1; + + // See if this is a for each () instead of just a for () + if (matchToken(Token.NAME)) { + decompiler.addName(ts.getString()); + if (ts.getString().equals("each")) { + isForEach = true; + } else { + reportError("msg.no.paren.for"); + } + } + + mustMatchToken(Token.LP, "msg.no.paren.for"); + decompiler.addToken(Token.LP); + tt = peekToken(); + if (tt == Token.SEMI) { + init = nf.createLeaf(Token.EMPTY); + } else { + if (tt == Token.VAR || tt == Token.LET) { + // set init to a var list or initial + consumeToken(); // consume the token + decompiler.addToken(tt); + init = variables(true, tt); + declType = tt; + } + else { + init = expr(true); + } + } + + if (matchToken(Token.IN)) { + decompiler.addToken(Token.IN); + // 'cond' is the object over which we're iterating + cond = expr(false); + } else { // ordinary for loop + mustMatchToken(Token.SEMI, "msg.no.semi.for"); + decompiler.addToken(Token.SEMI); + if (peekToken() == Token.SEMI) { + // no loop condition + cond = nf.createLeaf(Token.EMPTY); + } else { + cond = expr(false); + } + + mustMatchToken(Token.SEMI, "msg.no.semi.for.cond"); + decompiler.addToken(Token.SEMI); + if (peekToken() == Token.RP) { + incr = nf.createLeaf(Token.EMPTY); + } else { + incr = expr(false); + } + } + + mustMatchToken(Token.RP, "msg.no.paren.for.ctrl"); + decompiler.addToken(Token.RP); + decompiler.addEOL(Token.LC); + /*APPJET*/int parenEndLine = lastConsumedTokenLine; + body = statement(); + decompiler.addEOL(Token.RC); + + if (incr == null) { + // cond could be null if 'in obj' got eaten + // by the init node. + pn = nf.createForIn(declType, loop, init, cond, body, + isForEach); + } else { + pn = nf.createFor(loop, init, cond, incr, body); + } + /*APPJET*/ // use the LOOP object to hold the range of the paren'd expr + /*APPJET*/pn.statementEndLineNum = parenEndLine; + } finally { + exitLoop(true); + } + return pn; + } + + case Token.TRY: { + consumeToken(); + int lineno = ts.getLineno(); + + Node tryblock; + Node catchblocks = null; + Node finallyblock = null; + + decompiler.addToken(Token.TRY); + if (peekToken() != Token.LC) { + reportError("msg.no.brace.try"); + } + decompiler.addEOL(Token.LC); + tryblock = statement(); + decompiler.addEOL(Token.RC); + + catchblocks = nf.createLeaf(Token.BLOCK); + + boolean sawDefaultCatch = false; + int peek = peekToken(); + if (peek == Token.CATCH) { + while (matchToken(Token.CATCH)) { + if (sawDefaultCatch) { + reportError("msg.catch.unreachable"); + } + decompiler.addToken(Token.CATCH); + mustMatchToken(Token.LP, "msg.no.paren.catch"); + decompiler.addToken(Token.LP); + + mustMatchToken(Token.NAME, "msg.bad.catchcond"); + String varName = ts.getString(); + decompiler.addName(varName); + + Node catchCond = null; + if (matchToken(Token.IF)) { + decompiler.addToken(Token.IF); + catchCond = expr(false); + } else { + sawDefaultCatch = true; + } + + mustMatchToken(Token.RP, "msg.bad.catchcond"); + decompiler.addToken(Token.RP); + mustMatchToken(Token.LC, "msg.no.brace.catchblock"); + decompiler.addEOL(Token.LC); + + nf.addChildToBack(catchblocks, + nf.createCatch(varName, catchCond, + statements(null), + ts.getLineno())); + + mustMatchToken(Token.RC, "msg.no.brace.after.body"); + decompiler.addEOL(Token.RC); + } + } else if (peek != Token.FINALLY) { + mustMatchToken(Token.FINALLY, "msg.try.no.catchfinally"); + } + + if (matchToken(Token.FINALLY)) { + decompiler.addToken(Token.FINALLY); + decompiler.addEOL(Token.LC); + finallyblock = statement(); + decompiler.addEOL(Token.RC); + } + + pn = nf.createTryCatchFinally(tryblock, catchblocks, + finallyblock, lineno); + + return pn; + } + + case Token.THROW: { + consumeToken(); + if (peekTokenOrEOL() == Token.EOL) { + // ECMAScript does not allow new lines before throw expression, + // see bug 256617 + reportError("msg.bad.throw.eol"); + } + + int lineno = ts.getLineno(); + decompiler.addToken(Token.THROW); + pn = nf.createThrow(expr(false), lineno); + break; + } + + case Token.BREAK: { + consumeToken(); + int lineno = ts.getLineno(); + + decompiler.addToken(Token.BREAK); + + // matchJumpLabelName only matches if there is one + Node breakStatement = matchJumpLabelName(); + if (breakStatement == null) { + if (loopAndSwitchSet == null || loopAndSwitchSet.size() == 0) { + reportError("msg.bad.break"); + return null; + } + breakStatement = (Node)loopAndSwitchSet.peek(); + } + pn = nf.createBreak(breakStatement, lineno); + break; + } + + case Token.CONTINUE: { + consumeToken(); + int lineno = ts.getLineno(); + + decompiler.addToken(Token.CONTINUE); + + Node loop; + // matchJumpLabelName only matches if there is one + Node label = matchJumpLabelName(); + if (label == null) { + if (loopSet == null || loopSet.size() == 0) { + reportError("msg.continue.outside"); + return null; + } + loop = (Node)loopSet.peek(); + } else { + loop = nf.getLabelLoop(label); + if (loop == null) { + reportError("msg.continue.nonloop"); + return null; + } + } + pn = nf.createContinue(loop, lineno); + break; + } + + case Token.WITH: { + consumeToken(); + + decompiler.addToken(Token.WITH); + int lineno = ts.getLineno(); + mustMatchToken(Token.LP, "msg.no.paren.with"); + decompiler.addToken(Token.LP); + Node obj = expr(false); + /*APPJET*/obj.lineno = lineno; + /*APPJET*/obj.statementEndLineNum = lastConsumedTokenLine; + mustMatchToken(Token.RP, "msg.no.paren.after.with"); + decompiler.addToken(Token.RP); + decompiler.addEOL(Token.LC); + + ++nestingOfWith; + Node body; + try { + body = statement(); + } finally { + --nestingOfWith; + } + + decompiler.addEOL(Token.RC); + + pn = nf.createWith(obj, body, lineno); + return pn; + } + + case Token.CONST: + case Token.VAR: { + consumeToken(); + decompiler.addToken(tt); + pn = variables(false, tt); + break; + } + + case Token.LET: { + consumeToken(); + decompiler.addToken(Token.LET); + if (peekToken() == Token.LP) { + pn = let(true); + } else { + pn = variables(false, tt); + } + return pn; + } + + case Token.RETURN: + case Token.YIELD: { + pn = returnOrYield(tt, false); + break; + } + + case Token.DEBUGGER: + consumeToken(); + decompiler.addToken(Token.DEBUGGER); + pn = nf.createDebugger(ts.getLineno()); + break; + + case Token.LC: + consumeToken(); + if (statementLabel != null) { + decompiler.addToken(Token.LC); + } + Node scope = nf.createScopeNode(Token.BLOCK, ts.getLineno()); + pushScope(scope); + try { + statements(scope); + mustMatchToken(Token.RC, "msg.no.brace.block"); + if (statementLabel != null) { + decompiler.addEOL(Token.RC); + } + return scope; + } finally { + popScope(); + } + + case Token.ERROR: + // Fall thru, to have a node for error recovery to work on + case Token.SEMI: + consumeToken(); + pn = nf.createLeaf(Token.EMPTY); + return pn; + + case Token.FUNCTION: { + consumeToken(); + pn = function(FunctionNode.FUNCTION_EXPRESSION_STATEMENT); + return pn; + } + + case Token.DEFAULT : + consumeToken(); + mustHaveXML(); + + decompiler.addToken(Token.DEFAULT); + int nsLine = ts.getLineno(); + + if (!(matchToken(Token.NAME) + && ts.getString().equals("xml"))) + { + reportError("msg.bad.namespace"); + } + decompiler.addName(" xml"); + + if (!(matchToken(Token.NAME) + && ts.getString().equals("namespace"))) + { + reportError("msg.bad.namespace"); + } + decompiler.addName(" namespace"); + + if (!matchToken(Token.ASSIGN)) { + reportError("msg.bad.namespace"); + } + decompiler.addToken(Token.ASSIGN); + + Node expr = expr(false); + pn = nf.createDefaultNamespace(expr, nsLine); + break; + + case Token.NAME: { + int lineno = ts.getLineno(); + String name = ts.getString(); + setCheckForLabel(); + pn = expr(false); + if (pn.getType() != Token.LABEL) { + pn = nf.createExprStatement(pn, lineno); + } else { + // Parsed the label: push back token should be + // colon that primaryExpr left untouched. + if (peekToken() != Token.COLON) Kit.codeBug(); + consumeToken(); + // depend on decompiling lookahead to guess that that + // last name was a label. + decompiler.addName(name); + decompiler.addEOL(Token.COLON); + + if (labelSet == null) { + labelSet = new Hashtable(); + } else if (labelSet.containsKey(name)) { + reportError("msg.dup.label"); + } + + boolean firstLabel; + if (statementLabel == null) { + firstLabel = true; + statementLabel = pn; + } else { + // Discard multiple label nodes and use only + // the first: it allows to simplify IRFactory + firstLabel = false; + } + labelSet.put(name, statementLabel); + try { + pn = statementHelper(statementLabel); + } finally { + labelSet.remove(name); + } + if (firstLabel) { + pn = nf.createLabeledStatement(statementLabel, pn); + } + return pn; + } + break; + } + + default: { + int lineno = ts.getLineno(); + pn = expr(false); + pn = nf.createExprStatement(pn, lineno); + break; + } + } + + int ttFlagged = peekFlaggedToken(); + switch (ttFlagged & CLEAR_TI_MASK) { + case Token.SEMI: + // Consume ';' as a part of expression + consumeToken(); + break; + case Token.ERROR: + case Token.EOF: + case Token.RC: + // Autoinsert ; + break; + default: + if ((ttFlagged & TI_AFTER_EOL) == 0) { + // Report error if no EOL or autoinsert ; otherwise + reportError("msg.no.semi.stmt"); + } + break; + } + decompiler.addEOL(Token.SEMI); + + return pn; + } + + /** + * Returns whether or not the bits in the mask have changed to all set. + * @param before bits before change + * @param after bits after change + * @param mask mask for bits + * @return true if all the bits in the mask are set in "after" but not + * "before" + */ + private static final boolean nowAllSet(int before, int after, int mask) + { + return ((before & mask) != mask) && ((after & mask) == mask); + } + + private Node returnOrYield(int tt, boolean exprContext) + throws IOException, ParserException + { + if (!insideFunction()) { + reportError(tt == Token.RETURN ? "msg.bad.return" + : "msg.bad.yield"); + } + consumeToken(); + decompiler.addToken(tt); + int lineno = ts.getLineno(); + + Node e; + /* This is ugly, but we don't want to require a semicolon. */ + switch (peekTokenOrEOL()) { + case Token.SEMI: + case Token.RC: + case Token.EOF: + case Token.EOL: + case Token.ERROR: + case Token.RB: + case Token.RP: + case Token.YIELD: + e = null; + break; + default: + e = expr(false); + break; + } + + int before = endFlags; + Node ret; + + if (tt == Token.RETURN) { + if (e == null ) { + endFlags |= Node.END_RETURNS; + } else { + endFlags |= Node.END_RETURNS_VALUE; + hasReturnValue = true; + } + ret = nf.createReturn(e, lineno); + + // see if we need a strict mode warning + if (nowAllSet(before, endFlags, + Node.END_RETURNS|Node.END_RETURNS_VALUE)) + { + addStrictWarning("msg.return.inconsistent", ""); + } + } else { + endFlags |= Node.END_YIELDS; + ret = nf.createYield(e, lineno); + if (!exprContext) + ret = new Node(Token.EXPR_VOID, ret, lineno); + } + + // see if we are mixing yields and value returns. + if (nowAllSet(before, endFlags, + Node.END_YIELDS|Node.END_RETURNS_VALUE)) + { + String name = ((FunctionNode)currentScriptOrFn).getFunctionName(); + if (name.length() == 0) + addError("msg.anon.generator.returns", ""); + else + addError("msg.generator.returns", name); + } + + return ret; + } + + /** + * Parse a 'var' or 'const' statement, or a 'var' init list in a for + * statement. + * @param inFor true if we are currently in the midst of the init + * clause of a for. + * @param inStatement true if called in a statement (as opposed to an + * expression) context + * @param declType A token value: either VAR, CONST, or LET depending on + * context. + * @return The parsed statement + * @throws IOException + * @throws ParserException + */ + private Node variables(boolean inFor, int declType) + throws IOException, ParserException + { + Node result = nf.createVariables(declType, ts.getLineno()); + boolean first = true; + for (;;) { + Node destructuring = null; + String s = null; + int tt = peekToken(); + if (tt == Token.LB || tt == Token.LC) { + // Destructuring assignment, e.g., var [a,b] = ... + destructuring = primaryExpr(); + } else { + // Simple variable name + mustMatchToken(Token.NAME, "msg.bad.var", + Token.name(declType).toLowerCase()); + s = ts.getString(); + + if (!first) + decompiler.addToken(Token.COMMA); + first = false; + + decompiler.addName(s); + defineSymbol(declType, s); + } + + Node init = null; + if (matchToken(Token.ASSIGN)) { + decompiler.addToken(Token.ASSIGN); + init = assignExpr(inFor); + } + + if (destructuring != null) { + if (init == null) { + if (!inFor) + reportError("msg.destruct.assign.no.init"); + nf.addChildToBack(result, destructuring); + } else { + nf.addChildToBack(result, + nf.createDestructuringAssignment(declType, + destructuring, init)); + } + } else { + Node name = nf.createName(s); + if (init != null) + nf.addChildToBack(name, init); + nf.addChildToBack(result, name); + } + + if (!matchToken(Token.COMMA)) + break; + } + return result; + } + + + private Node let(boolean isStatement) + throws IOException, ParserException + { + mustMatchToken(Token.LP, "msg.no.paren.after.let"); + decompiler.addToken(Token.LP); + Node result = nf.createScopeNode(Token.LET, ts.getLineno()); + pushScope(result); + try { + Node vars = variables(false, Token.LET); + nf.addChildToBack(result, vars); + mustMatchToken(Token.RP, "msg.no.paren.let"); + decompiler.addToken(Token.RP); + if (isStatement && peekToken() == Token.LC) { + // let statement + consumeToken(); + decompiler.addEOL(Token.LC); + nf.addChildToBack(result, statements(null)); + mustMatchToken(Token.RC, "msg.no.curly.let"); + decompiler.addToken(Token.RC); + } else { + // let expression + result.setType(Token.LETEXPR); + nf.addChildToBack(result, expr(false)); + if (isStatement) { + // let expression in statement context + result = nf.createExprStatement(result, ts.getLineno()); + } + } + } finally { + popScope(); + } + return result; + } + + void defineSymbol(int declType, String name) { + Node.Scope definingScope = currentScope.getDefiningScope(name); + Node.Scope.Symbol symbol = definingScope != null + ? definingScope.getSymbol(name) + : null; + boolean error = false; + if (symbol != null && (symbol.declType == Token.CONST || + declType == Token.CONST)) + { + error = true; + } else { + switch (declType) { + case Token.LET: + if (symbol != null && definingScope == currentScope) { + error = symbol.declType == Token.LET; + } + currentScope.putSymbol(name, + new Node.Scope.Symbol(declType, name)); + break; + + case Token.VAR: + case Token.CONST: + case Token.FUNCTION: + if (symbol != null) { + if (symbol.declType == Token.VAR) + addStrictWarning("msg.var.redecl", name); + else if (symbol.declType == Token.LP) { + addStrictWarning("msg.var.hides.arg", name); + } + } else { + currentScriptOrFn.putSymbol(name, + new Node.Scope.Symbol(declType, name)); + } + break; + + case Token.LP: + if (symbol != null) { + // must be duplicate parameter. Second parameter hides the + // first, so go ahead and add the second pararameter + addWarning("msg.dup.parms", name); + } + currentScriptOrFn.putSymbol(name, + new Node.Scope.Symbol(declType, name)); + break; + + default: + throw Kit.codeBug(); + } + } + if (error) { + addError(symbol.declType == Token.CONST ? "msg.const.redecl" : + symbol.declType == Token.LET ? "msg.let.redecl" : + symbol.declType == Token.VAR ? "msg.var.redecl" : + symbol.declType == Token.FUNCTION ? "msg.fn.redecl" : + "msg.parm.redecl", name); + } + } + + private Node expr(boolean inForInit) + throws IOException, ParserException + { + Node pn = assignExpr(inForInit); + while (matchToken(Token.COMMA)) { + decompiler.addToken(Token.COMMA); + if (compilerEnv.isStrictMode() && !pn.hasSideEffects()) + addStrictWarning("msg.no.side.effects", ""); + if (peekToken() == Token.YIELD) { + reportError("msg.yield.parenthesized"); + } + pn = nf.createBinary(Token.COMMA, pn, assignExpr(inForInit)); + } + return pn; + } + + private Node assignExpr(boolean inForInit) + throws IOException, ParserException + { + int tt = peekToken(); + if (tt == Token.YIELD) { + consumeToken(); + return returnOrYield(tt, true); + } + Node pn = condExpr(inForInit); + + tt = peekToken(); + if (Token.FIRST_ASSIGN <= tt && tt <= Token.LAST_ASSIGN) { + consumeToken(); + decompiler.addToken(tt); + pn = nf.createAssignment(tt, pn, assignExpr(inForInit)); + } + + return pn; + } + + private Node condExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = orExpr(inForInit); + + if (matchToken(Token.HOOK)) { + decompiler.addToken(Token.HOOK); + Node ifTrue = assignExpr(false); + mustMatchToken(Token.COLON, "msg.no.colon.cond"); + decompiler.addToken(Token.COLON); + Node ifFalse = assignExpr(inForInit); + return nf.createCondExpr(pn, ifTrue, ifFalse); + } + + return pn; + } + + private Node orExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = andExpr(inForInit); + if (matchToken(Token.OR)) { + decompiler.addToken(Token.OR); + pn = nf.createBinary(Token.OR, pn, orExpr(inForInit)); + } + + return pn; + } + + private Node andExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = bitOrExpr(inForInit); + if (matchToken(Token.AND)) { + decompiler.addToken(Token.AND); + pn = nf.createBinary(Token.AND, pn, andExpr(inForInit)); + } + + return pn; + } + + private Node bitOrExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = bitXorExpr(inForInit); + while (matchToken(Token.BITOR)) { + decompiler.addToken(Token.BITOR); + pn = nf.createBinary(Token.BITOR, pn, bitXorExpr(inForInit)); + } + return pn; + } + + private Node bitXorExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = bitAndExpr(inForInit); + while (matchToken(Token.BITXOR)) { + decompiler.addToken(Token.BITXOR); + pn = nf.createBinary(Token.BITXOR, pn, bitAndExpr(inForInit)); + } + return pn; + } + + private Node bitAndExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = eqExpr(inForInit); + while (matchToken(Token.BITAND)) { + decompiler.addToken(Token.BITAND); + pn = nf.createBinary(Token.BITAND, pn, eqExpr(inForInit)); + } + return pn; + } + + private Node eqExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = relExpr(inForInit); + for (;;) { + int tt = peekToken(); + switch (tt) { + case Token.EQ: + case Token.NE: + case Token.SHEQ: + case Token.SHNE: + consumeToken(); + int decompilerToken = tt; + int parseToken = tt; + if (compilerEnv.getLanguageVersion() == Context.VERSION_1_2) { + // JavaScript 1.2 uses shallow equality for == and != . + // In addition, convert === and !== for decompiler into + // == and != since the decompiler is supposed to show + // canonical source and in 1.2 ===, !== are allowed + // only as an alias to ==, !=. + switch (tt) { + case Token.EQ: + parseToken = Token.SHEQ; + break; + case Token.NE: + parseToken = Token.SHNE; + break; + case Token.SHEQ: + decompilerToken = Token.EQ; + break; + case Token.SHNE: + decompilerToken = Token.NE; + break; + } + } + decompiler.addToken(decompilerToken); + pn = nf.createBinary(parseToken, pn, relExpr(inForInit)); + continue; + } + break; + } + return pn; + } + + private Node relExpr(boolean inForInit) + throws IOException, ParserException + { + Node pn = shiftExpr(); + for (;;) { + int tt = peekToken(); + switch (tt) { + case Token.IN: + if (inForInit) + break; + // fall through + case Token.INSTANCEOF: + case Token.LE: + case Token.LT: + case Token.GE: + case Token.GT: + consumeToken(); + decompiler.addToken(tt); + pn = nf.createBinary(tt, pn, shiftExpr()); + continue; + } + break; + } + return pn; + } + + private Node shiftExpr() + throws IOException, ParserException + { + Node pn = addExpr(); + for (;;) { + int tt = peekToken(); + switch (tt) { + case Token.LSH: + case Token.URSH: + case Token.RSH: + consumeToken(); + decompiler.addToken(tt); + pn = nf.createBinary(tt, pn, addExpr()); + continue; + } + break; + } + return pn; + } + + private Node addExpr() + throws IOException, ParserException + { + Node pn = mulExpr(); + for (;;) { + int tt = peekToken(); + if (tt == Token.ADD || tt == Token.SUB) { + consumeToken(); + decompiler.addToken(tt); + // flushNewLines + pn = nf.createBinary(tt, pn, mulExpr()); + continue; + } + break; + } + + return pn; + } + + private Node mulExpr() + throws IOException, ParserException + { + Node pn = unaryExpr(); + for (;;) { + int tt = peekToken(); + switch (tt) { + case Token.MUL: + case Token.DIV: + case Token.MOD: + consumeToken(); + decompiler.addToken(tt); + pn = nf.createBinary(tt, pn, unaryExpr()); + continue; + } + break; + } + + return pn; + } + + private Node unaryExpr() + throws IOException, ParserException + { + int tt; + + tt = peekToken(); + + switch(tt) { + case Token.VOID: + case Token.NOT: + case Token.BITNOT: + case Token.TYPEOF: + consumeToken(); + decompiler.addToken(tt); + return nf.createUnary(tt, unaryExpr()); + + case Token.ADD: + consumeToken(); + // Convert to special POS token in decompiler and parse tree + decompiler.addToken(Token.POS); + return nf.createUnary(Token.POS, unaryExpr()); + + case Token.SUB: + consumeToken(); + // Convert to special NEG token in decompiler and parse tree + decompiler.addToken(Token.NEG); + return nf.createUnary(Token.NEG, unaryExpr()); + + case Token.INC: + case Token.DEC: + consumeToken(); + decompiler.addToken(tt); + return nf.createIncDec(tt, false, memberExpr(true)); + + case Token.DELPROP: + consumeToken(); + decompiler.addToken(Token.DELPROP); + return nf.createUnary(Token.DELPROP, unaryExpr()); + + case Token.ERROR: + consumeToken(); + break; + + // XML stream encountered in expression. + case Token.LT: + if (compilerEnv.isXmlAvailable()) { + consumeToken(); + Node pn = xmlInitializer(); + return memberExprTail(true, pn); + } + // Fall thru to the default handling of RELOP + + default: + Node pn = memberExpr(true); + + // Don't look across a newline boundary for a postfix incop. + tt = peekTokenOrEOL(); + if (tt == Token.INC || tt == Token.DEC) { + consumeToken(); + decompiler.addToken(tt); + return nf.createIncDec(tt, true, pn); + } + return pn; + } + return nf.createName("error"); // Only reached on error.Try to continue. + + } + + private Node xmlInitializer() throws IOException + { + int tt = ts.getFirstXMLToken(); + if (tt != Token.XML && tt != Token.XMLEND) { + reportError("msg.syntax"); + return null; + } + + /* Make a NEW node to append to. */ + Node pnXML = nf.createLeaf(Token.NEW); + + String xml = ts.getString(); + boolean fAnonymous = xml.trim().startsWith("<>"); + + Node pn = nf.createName(fAnonymous ? "XMLList" : "XML"); + nf.addChildToBack(pnXML, pn); + + pn = null; + Node expr; + for (;;tt = ts.getNextXMLToken()) { + switch (tt) { + case Token.XML: + xml = ts.getString(); + decompiler.addName(xml); + mustMatchToken(Token.LC, "msg.syntax"); + decompiler.addToken(Token.LC); + expr = (peekToken() == Token.RC) + ? nf.createString("") + : expr(false); + mustMatchToken(Token.RC, "msg.syntax"); + decompiler.addToken(Token.RC); + if (pn == null) { + pn = nf.createString(xml); + } else { + pn = nf.createBinary(Token.ADD, pn, nf.createString(xml)); + } + if (ts.isXMLAttribute()) { + /* Need to put the result in double quotes */ + expr = nf.createUnary(Token.ESCXMLATTR, expr); + Node prepend = nf.createBinary(Token.ADD, + nf.createString("\""), + expr); + expr = nf.createBinary(Token.ADD, + prepend, + nf.createString("\"")); + } else { + expr = nf.createUnary(Token.ESCXMLTEXT, expr); + } + pn = nf.createBinary(Token.ADD, pn, expr); + break; + case Token.XMLEND: + xml = ts.getString(); + decompiler.addName(xml); + if (pn == null) { + pn = nf.createString(xml); + } else { + pn = nf.createBinary(Token.ADD, pn, nf.createString(xml)); + } + + nf.addChildToBack(pnXML, pn); + return pnXML; + default: + reportError("msg.syntax"); + return null; + } + } + } + + private void argumentList(Node listNode) + throws IOException, ParserException + { + boolean matched; + matched = matchToken(Token.RP); + if (!matched) { + boolean first = true; + do { + if (!first) + decompiler.addToken(Token.COMMA); + first = false; + if (peekToken() == Token.YIELD) { + reportError("msg.yield.parenthesized"); + } + nf.addChildToBack(listNode, assignExpr(false)); + } while (matchToken(Token.COMMA)); + + mustMatchToken(Token.RP, "msg.no.paren.arg"); + } + decompiler.addToken(Token.RP); + } + + private Node memberExpr(boolean allowCallSyntax) + throws IOException, ParserException + { + int tt; + + Node pn; + + /* Check for new expressions. */ + tt = peekToken(); + if (tt == Token.NEW) { + /* Eat the NEW token. */ + consumeToken(); + decompiler.addToken(Token.NEW); + + /* Make a NEW node to append to. */ + pn = nf.createCallOrNew(Token.NEW, memberExpr(false)); + + if (matchToken(Token.LP)) { + decompiler.addToken(Token.LP); + /* Add the arguments to pn, if any are supplied. */ + argumentList(pn); + } + + /* XXX there's a check in the C source against + * "too many constructor arguments" - how many + * do we claim to support? + */ + + /* Experimental syntax: allow an object literal to follow a new expression, + * which will mean a kind of anonymous class built with the JavaAdapter. + * the object literal will be passed as an additional argument to the constructor. + */ + tt = peekToken(); + if (tt == Token.LC) { + nf.addChildToBack(pn, primaryExpr()); + } + } else { + pn = primaryExpr(); + } + + return memberExprTail(allowCallSyntax, pn); + } + + private Node memberExprTail(boolean allowCallSyntax, Node pn) + throws IOException, ParserException + { + tailLoop: + for (;;) { + int tt = peekToken(); + switch (tt) { + + case Token.DOT: + case Token.DOTDOT: + { + int memberTypeFlags; + String s; + + consumeToken(); + decompiler.addToken(tt); + memberTypeFlags = 0; + if (tt == Token.DOTDOT) { + mustHaveXML(); + memberTypeFlags = Node.DESCENDANTS_FLAG; + } + if (!compilerEnv.isXmlAvailable()) { + mustMatchToken(Token.NAME, "msg.no.name.after.dot"); + s = ts.getString(); + decompiler.addName(s); + pn = nf.createPropertyGet(pn, null, s, memberTypeFlags); + break; + } + + tt = nextToken(); + switch (tt) { + + // needed for generator.throw(); + case Token.THROW: + decompiler.addName("throw"); + pn = propertyName(pn, "throw", memberTypeFlags); + break; + + // handles: name, ns::name, ns::*, ns::[expr] + case Token.NAME: + s = ts.getString(); + decompiler.addName(s); + pn = propertyName(pn, s, memberTypeFlags); + break; + + // handles: *, *::name, *::*, *::[expr] + case Token.MUL: + decompiler.addName("*"); + pn = propertyName(pn, "*", memberTypeFlags); + break; + + // handles: '@attr', '@ns::attr', '@ns::*', '@ns::*', + // '@::attr', '@::*', '@*', '@*::attr', '@*::*' + case Token.XMLATTR: + decompiler.addToken(Token.XMLATTR); + pn = attributeAccess(pn, memberTypeFlags); + break; + + default: + reportError("msg.no.name.after.dot"); + } + } + break; + + case Token.DOTQUERY: + consumeToken(); + mustHaveXML(); + decompiler.addToken(Token.DOTQUERY); + pn = nf.createDotQuery(pn, expr(false), ts.getLineno()); + mustMatchToken(Token.RP, "msg.no.paren"); + decompiler.addToken(Token.RP); + break; + + case Token.LB: + consumeToken(); + decompiler.addToken(Token.LB); + pn = nf.createElementGet(pn, null, expr(false), 0); + mustMatchToken(Token.RB, "msg.no.bracket.index"); + decompiler.addToken(Token.RB); + break; + + case Token.LP: + if (!allowCallSyntax) { + break tailLoop; + } + consumeToken(); + decompiler.addToken(Token.LP); + pn = nf.createCallOrNew(Token.CALL, pn); + /* Add the arguments to pn, if any are supplied. */ + argumentList(pn); + break; + + default: + break tailLoop; + } + } + return pn; + } + + /* + * Xml attribute expression: + * '@attr', '@ns::attr', '@ns::*', '@ns::*', '@*', '@*::attr', '@*::*' + */ + private Node attributeAccess(Node pn, int memberTypeFlags) + throws IOException + { + memberTypeFlags |= Node.ATTRIBUTE_FLAG; + int tt = nextToken(); + + switch (tt) { + // handles: @name, @ns::name, @ns::*, @ns::[expr] + case Token.NAME: + { + String s = ts.getString(); + decompiler.addName(s); + pn = propertyName(pn, s, memberTypeFlags); + } + break; + + // handles: @*, @*::name, @*::*, @*::[expr] + case Token.MUL: + decompiler.addName("*"); + pn = propertyName(pn, "*", memberTypeFlags); + break; + + // handles @[expr] + case Token.LB: + decompiler.addToken(Token.LB); + pn = nf.createElementGet(pn, null, expr(false), memberTypeFlags); + mustMatchToken(Token.RB, "msg.no.bracket.index"); + decompiler.addToken(Token.RB); + break; + + default: + reportError("msg.no.name.after.xmlAttr"); + pn = nf.createPropertyGet(pn, null, "?", memberTypeFlags); + break; + } + + return pn; + } + + /** + * Check if :: follows name in which case it becomes qualified name + */ + private Node propertyName(Node pn, String name, int memberTypeFlags) + throws IOException, ParserException + { + String namespace = null; + if (matchToken(Token.COLONCOLON)) { + decompiler.addToken(Token.COLONCOLON); + namespace = name; + + int tt = nextToken(); + switch (tt) { + // handles name::name + case Token.NAME: + name = ts.getString(); + decompiler.addName(name); + break; + + // handles name::* + case Token.MUL: + decompiler.addName("*"); + name = "*"; + break; + + // handles name::[expr] + case Token.LB: + decompiler.addToken(Token.LB); + pn = nf.createElementGet(pn, namespace, expr(false), + memberTypeFlags); + mustMatchToken(Token.RB, "msg.no.bracket.index"); + decompiler.addToken(Token.RB); + return pn; + + default: + reportError("msg.no.name.after.coloncolon"); + name = "?"; + } + } + + pn = nf.createPropertyGet(pn, namespace, name, memberTypeFlags); + return pn; + } + + private Node arrayComprehension(String arrayName, Node expr) + throws IOException, ParserException + { + if (nextToken() != Token.FOR) + throw Kit.codeBug(); // shouldn't be here if next token isn't 'for' + decompiler.addName(" "); // space after array literal expr + decompiler.addToken(Token.FOR); + boolean isForEach = false; + if (matchToken(Token.NAME)) { + decompiler.addName(ts.getString()); + if (ts.getString().equals("each")) { + isForEach = true; + } else { + reportError("msg.no.paren.for"); + } + } + mustMatchToken(Token.LP, "msg.no.paren.for"); + decompiler.addToken(Token.LP); + String name; + int tt = peekToken(); + if (tt == Token.LB || tt == Token.LC) { + // handle destructuring assignment + name = currentScriptOrFn.getNextTempName(); + defineSymbol(Token.LP, name); + expr = nf.createBinary(Token.COMMA, + nf.createAssignment(Token.ASSIGN, primaryExpr(), + nf.createName(name)), + expr); + } else if (tt == Token.NAME) { + consumeToken(); + name = ts.getString(); + decompiler.addName(name); + } else { + reportError("msg.bad.var"); + return nf.createNumber(0); + } + + Node init = nf.createName(name); + // Define as a let since we want the scope of the variable to + // be restricted to the array comprehension + defineSymbol(Token.LET, name); + + mustMatchToken(Token.IN, "msg.in.after.for.name"); + decompiler.addToken(Token.IN); + Node iterator = expr(false); + mustMatchToken(Token.RP, "msg.no.paren.for.ctrl"); + decompiler.addToken(Token.RP); + + Node body; + tt = peekToken(); + if (tt == Token.FOR) { + body = arrayComprehension(arrayName, expr); + } else { + Node call = nf.createCallOrNew(Token.CALL, + nf.createPropertyGet(nf.createName(arrayName), null, + "push", 0)); + call.addChildToBack(expr); + body = new Node(Token.EXPR_VOID, call, ts.getLineno()); + if (tt == Token.IF) { + consumeToken(); + decompiler.addToken(Token.IF); + int lineno = ts.getLineno(); + Node cond = condition(); + body = nf.createIf(cond, body, null, lineno); + } + mustMatchToken(Token.RB, "msg.no.bracket.arg"); + decompiler.addToken(Token.RB); + } + + Node loop = enterLoop(null, true); + try { + return nf.createForIn(Token.LET, loop, init, iterator, body, + isForEach); + } finally { + exitLoop(false); + } + } + + private Node primaryExpr() + throws IOException, ParserException + { + Node pn; + + int ttFlagged = nextFlaggedToken(); + int tt = ttFlagged & CLEAR_TI_MASK; + + switch(tt) { + + case Token.FUNCTION: + return function(FunctionNode.FUNCTION_EXPRESSION); + + case Token.LB: { + ObjArray elems = new ObjArray(); + int skipCount = 0; + int destructuringLen = 0; + decompiler.addToken(Token.LB); + boolean after_lb_or_comma = true; + for (;;) { + tt = peekToken(); + + if (tt == Token.COMMA) { + consumeToken(); + decompiler.addToken(Token.COMMA); + if (!after_lb_or_comma) { + after_lb_or_comma = true; + } else { + elems.add(null); + ++skipCount; + } + } else if (tt == Token.RB) { + consumeToken(); + decompiler.addToken(Token.RB); + // for ([a,] in obj) is legal, but for ([a] in obj) is + // not since we have both key and value supplied. The + // trick is that [a,] and [a] are equivalent in other + // array literal contexts. So we calculate a special + // length value just for destructuring assignment. + destructuringLen = elems.size() + + (after_lb_or_comma ? 1 : 0); + break; + } else if (skipCount == 0 && elems.size() == 1 && + tt == Token.FOR) + { + Node scopeNode = nf.createScopeNode(Token.ARRAYCOMP, + ts.getLineno()); + String tempName = currentScriptOrFn.getNextTempName(); + pushScope(scopeNode); + try { + defineSymbol(Token.LET, tempName); + Node expr = (Node) elems.get(0); + Node block = nf.createBlock(ts.getLineno()); + Node init = new Node(Token.EXPR_VOID, + nf.createAssignment(Token.ASSIGN, + nf.createName(tempName), + nf.createCallOrNew(Token.NEW, + nf.createName("Array"))), ts.getLineno()); + block.addChildToBack(init); + block.addChildToBack(arrayComprehension(tempName, + expr)); + scopeNode.addChildToBack(block); + scopeNode.addChildToBack(nf.createName(tempName)); + return scopeNode; + } finally { + popScope(); + } + } else { + if (!after_lb_or_comma) { + reportError("msg.no.bracket.arg"); + } + elems.add(assignExpr(false)); + after_lb_or_comma = false; + } + } + return nf.createArrayLiteral(elems, skipCount, destructuringLen); + } + + case Token.LC: { + ObjArray elems = new ObjArray(); + decompiler.addToken(Token.LC); + if (!matchToken(Token.RC)) { + + boolean first = true; + commaloop: + do { + Object property; + + if (!first) + decompiler.addToken(Token.COMMA); + else + first = false; + + tt = peekToken(); + switch(tt) { + case Token.NAME: + case Token.STRING: + consumeToken(); + // map NAMEs to STRINGs in object literal context + // but tell the decompiler the proper type + String s = ts.getString(); + if (tt == Token.NAME) { + if (s.equals("get") && + peekToken() == Token.NAME) { + decompiler.addToken(Token.GET); + consumeToken(); + s = ts.getString(); + decompiler.addName(s); + property = ScriptRuntime.getIndexObject(s); + if (!getterSetterProperty(elems, property, + true)) + break commaloop; + break; + } else if (s.equals("set") && + peekToken() == Token.NAME) { + decompiler.addToken(Token.SET); + consumeToken(); + s = ts.getString(); + decompiler.addName(s); + property = ScriptRuntime.getIndexObject(s); + if (!getterSetterProperty(elems, property, + false)) + break commaloop; + break; + } + decompiler.addName(s); + } else { + decompiler.addString(s); + } + property = ScriptRuntime.getIndexObject(s); + plainProperty(elems, property); + break; + + case Token.NUMBER: + consumeToken(); + double n = ts.getNumber(); + decompiler.addNumber(n); + property = ScriptRuntime.getIndexObject(n); + plainProperty(elems, property); + break; + + case Token.RC: + // trailing comma is OK. + break commaloop; + default: + reportError("msg.bad.prop"); + break commaloop; + } + } while (matchToken(Token.COMMA)); + + mustMatchToken(Token.RC, "msg.no.brace.prop"); + } + decompiler.addToken(Token.RC); + return nf.createObjectLiteral(elems); + } + + case Token.LET: + decompiler.addToken(Token.LET); + return let(false); + + case Token.LP: + + /* Brendan's IR-jsparse.c makes a new node tagged with + * TOK_LP here... I'm not sure I understand why. Isn't + * the grouping already implicit in the structure of the + * parse tree? also TOK_LP is already overloaded (I + * think) in the C IR as 'function call.' */ + decompiler.addToken(Token.LP); + pn = expr(false); + pn.putProp(Node.PARENTHESIZED_PROP, Boolean.TRUE); + decompiler.addToken(Token.RP); + mustMatchToken(Token.RP, "msg.no.paren"); + return pn; + + case Token.XMLATTR: + mustHaveXML(); + decompiler.addToken(Token.XMLATTR); + pn = attributeAccess(null, 0); + return pn; + + case Token.NAME: { + String name = ts.getString(); + if ((ttFlagged & TI_CHECK_LABEL) != 0) { + if (peekToken() == Token.COLON) { + // Do not consume colon, it is used as unwind indicator + // to return to statementHelper. + // XXX Better way? + return nf.createLabel(ts.getLineno()); + } + } + + decompiler.addName(name); + if (compilerEnv.isXmlAvailable()) { + pn = propertyName(null, name, 0); + } else { + pn = nf.createName(name); + } + return pn; + } + + case Token.NUMBER: { + double n = ts.getNumber(); + decompiler.addNumber(n); + return nf.createNumber(n); + } + + case Token.STRING: { + String s = ts.getString(); + decompiler.addString(s); + return nf.createString(s); + } + + case Token.DIV: + case Token.ASSIGN_DIV: { + // Got / or /= which should be treated as regexp in fact + ts.readRegExp(tt); + String flags = ts.regExpFlags; + ts.regExpFlags = null; + String re = ts.getString(); + decompiler.addRegexp(re, flags); + /*APPJET*/ + int index = currentScriptOrFn.addRegexp + (re, flags, getCurrentLineNumber()); + return nf.createRegExp(index); + } + + case Token.NULL: + case Token.THIS: + case Token.FALSE: + case Token.TRUE: + decompiler.addToken(tt); + return nf.createLeaf(tt); + + case Token.RESERVED: + reportError("msg.reserved.id"); + break; + + case Token.ERROR: + /* the scanner or one of its subroutines reported the error. */ + break; + + case Token.EOF: + reportError("msg.unexpected.eof"); + break; + + default: + reportError("msg.syntax"); + break; + } + return null; // should never reach here + } + + private void plainProperty(ObjArray elems, Object property) + throws IOException { + mustMatchToken(Token.COLON, "msg.no.colon.prop"); + + // OBJLIT is used as ':' in object literal for + // decompilation to solve spacing ambiguity. + decompiler.addToken(Token.OBJECTLIT); + elems.add(property); + elems.add(assignExpr(false)); + } + + private boolean getterSetterProperty(ObjArray elems, Object property, + boolean isGetter) throws IOException { + Node f = function(FunctionNode.FUNCTION_EXPRESSION); + if (f.getType() != Token.FUNCTION) { + reportError("msg.bad.prop"); + return false; + } + int fnIndex = f.getExistingIntProp(Node.FUNCTION_PROP); + FunctionNode fn = currentScriptOrFn.getFunctionNode(fnIndex); + if (fn.getFunctionName().length() != 0) { + reportError("msg.bad.prop"); + return false; + } + elems.add(property); + if (isGetter) { + elems.add(nf.createUnary(Token.GET, f)); + } else { + elems.add(nf.createUnary(Token.SET, f)); + } + return true; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/PolicySecurityController.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/PolicySecurityController.java new file mode 100644 index 0000000..c4d3d7e --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/PolicySecurityController.java @@ -0,0 +1,223 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.lang.ref.SoftReference; +import java.lang.reflect.UndeclaredThrowableException; +import java.security.AccessController; +import java.security.CodeSource; +import java.security.Policy; +import java.security.PrivilegedAction; +import java.security.PrivilegedActionException; +import java.security.PrivilegedExceptionAction; +import java.security.SecureClassLoader; +import java.util.Map; +import java.util.WeakHashMap; + +import org.mozilla.classfile.ByteCode; +import org.mozilla.classfile.ClassFileWriter; + +/** + * A security controller relying on Java {@link Policy} in effect. When you use + * this security controller, your securityDomain objects must be instances of + * {@link CodeSource} representing the location from where you load your + * scripts. Any Java policy "grant" statements matching the URL and certificate + * in code sources will apply to the scripts. If you specify any certificates + * within your {@link CodeSource} objects, it is your responsibility to verify + * (or not) that the script source files are signed in whatever + * implementation-specific way you're using. + * @author Attila Szegedi + */ +public class PolicySecurityController extends SecurityController +{ + private static final byte[] secureCallerImplBytecode = loadBytecode(); + + // We're storing a CodeSource -> (ClassLoader -> SecureRenderer), since we + // need to have one renderer per class loader. We're using weak hash maps + // and soft references all the way, since we don't want to interfere with + // cleanup of either CodeSource or ClassLoader objects. + private static final Map callers = new WeakHashMap(); + + public Class getStaticSecurityDomainClassInternal() { + return CodeSource.class; + } + + private static class Loader extends SecureClassLoader + implements GeneratedClassLoader + { + private final CodeSource codeSource; + + Loader(ClassLoader parent, CodeSource codeSource) + { + super(parent); + this.codeSource = codeSource; + } + + public Class defineClass(String name, byte[] data) + { + return defineClass(name, data, 0, data.length, codeSource); + } + + public void linkClass(Class cl) + { + resolveClass(cl); + } + } + + public GeneratedClassLoader createClassLoader(final ClassLoader parent, + final Object securityDomain) + { + return (Loader)AccessController.doPrivileged( + new PrivilegedAction() + { + public Object run() + { + return new Loader(parent, (CodeSource)securityDomain); + } + }); + } + + public Object getDynamicSecurityDomain(Object securityDomain) + { + // No separate notion of dynamic security domain - just return what was + // passed in. + return securityDomain; + } + + public Object callWithDomain(final Object securityDomain, final Context cx, + Callable callable, Scriptable scope, Scriptable thisObj, + Object[] args) + { + // Run in doPrivileged as we might be checked for "getClassLoader" + // runtime permission + final ClassLoader classLoader = (ClassLoader)AccessController.doPrivileged( + new PrivilegedAction() { + public Object run() { + return cx.getApplicationClassLoader(); + } + }); + final CodeSource codeSource = (CodeSource)securityDomain; + Map classLoaderMap; + synchronized(callers) + { + classLoaderMap = (Map)callers.get(codeSource); + if(classLoaderMap == null) + { + classLoaderMap = new WeakHashMap(); + callers.put(codeSource, classLoaderMap); + } + } + SecureCaller caller; + synchronized(classLoaderMap) + { + SoftReference ref = (SoftReference)classLoaderMap.get(classLoader); + if(ref != null) + { + caller = (SecureCaller)ref.get(); + } + else + { + caller = null; + } + if(caller == null) + { + try + { + // Run in doPrivileged as we'll be checked for + // "createClassLoader" runtime permission + caller = (SecureCaller)AccessController.doPrivileged( + new PrivilegedExceptionAction() + { + public Object run() throws Exception + { + Loader loader = new Loader(classLoader, + codeSource); + Class c = loader.defineClass( + SecureCaller.class.getName() + "Impl", + secureCallerImplBytecode); + return c.newInstance(); + } + }); + classLoaderMap.put(classLoader, new SoftReference(caller)); + } + catch(PrivilegedActionException ex) + { + throw new UndeclaredThrowableException(ex.getCause()); + } + } + } + return caller.call(callable, cx, scope, thisObj, args); + } + + public abstract static class SecureCaller + { + public abstract Object call(Callable callable, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args); + } + + + private static byte[] loadBytecode() + { + String secureCallerClassName = SecureCaller.class.getName(); + ClassFileWriter cfw = new ClassFileWriter( + secureCallerClassName + "Impl", secureCallerClassName, + "<generated>"); + cfw.startMethod("<init>", "()V", ClassFileWriter.ACC_PUBLIC); + cfw.addALoad(0); + cfw.addInvoke(ByteCode.INVOKESPECIAL, secureCallerClassName, + "<init>", "()V"); + cfw.add(ByteCode.RETURN); + cfw.stopMethod((short)1); + String callableCallSig = + "Lorg/mozilla/javascript/Context;" + + "Lorg/mozilla/javascript/Scriptable;" + + "Lorg/mozilla/javascript/Scriptable;" + + "[Ljava/lang/Object;)Ljava/lang/Object;"; + + cfw.startMethod("call", + "(Lorg/mozilla/javascript/Callable;" + callableCallSig, + (short)(ClassFileWriter.ACC_PUBLIC + | ClassFileWriter.ACC_FINAL)); + for(int i = 1; i < 6; ++i) { + cfw.addALoad(i); + } + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/Callable", "call", + "(" + callableCallSig); + cfw.add(ByteCode.ARETURN); + cfw.stopMethod((short)6); + return cfw.toByteArray(); + } +}
\ No newline at end of file diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Ref.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Ref.java new file mode 100644 index 0000000..1e237bc --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Ref.java @@ -0,0 +1,64 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; + +/** + * Generic notion of reference object that know how to query/modify the + * target objects based on some property/index. + */ +public abstract class Ref implements Serializable +{ + public boolean has(Context cx) + { + return true; + } + + public abstract Object get(Context cx); + + public abstract Object set(Context cx, Object value); + + public boolean delete(Context cx) + { + return false; + } + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RefCallable.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RefCallable.java new file mode 100644 index 0000000..6d4b61c --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RefCallable.java @@ -0,0 +1,59 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@mir2.org + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * Object that can allows assignments to the result of function calls. + */ +public interface RefCallable extends Callable +{ + /** + * Perform function call in reference context. + * The args array reference should not be stored in any object that is + * can be GC-reachable after this method returns. If this is necessary, + * for example, to implement {@link Ref} methods, then store args.clone(), + * not args array itself. + * + * @param cx the current Context for this thread + * @param thisObj the JavaScript <code>this</code> object + * @param args the array of arguments + */ + public Ref refCall(Context cx, Scriptable thisObj, Object[] args); +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RegExpProxy.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RegExpProxy.java new file mode 100644 index 0000000..ac29c6e --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RegExpProxy.java @@ -0,0 +1,71 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * A proxy for the regexp package, so that the regexp package can be + * loaded optionally. + * + * @author Norris Boyd + */ +public interface RegExpProxy +{ + // Types of regexp actions + + public static final int RA_MATCH = 1; + public static final int RA_REPLACE = 2; + public static final int RA_SEARCH = 3; + + public boolean isRegExp(Scriptable obj); + + public Object compileRegExp(Context cx, String source, String flags); + + public Scriptable wrapRegExp(Context cx, Scriptable scope, + Object compiled); + + public Object action(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args, + int actionType); + + public int find_split(Context cx, Scriptable scope, String target, + String separator, Scriptable re, + int[] ip, int[] matchlen, + boolean[] matched, String[][] parensp); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RhinoException.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RhinoException.java new file mode 100644 index 0000000..b7f4a4d --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/RhinoException.java @@ -0,0 +1,306 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript; + +import java.io.CharArrayWriter; +import java.io.File; +import java.io.FilenameFilter; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.util.List; +import java.util.ArrayList; + +/** + * The class of exceptions thrown by the JavaScript engine. + */ +public abstract class RhinoException extends RuntimeException +{ + RhinoException() + { + Evaluator e = Context.createInterpreter(); + if (e != null) + e.captureStackInfo(this); + } + + RhinoException(String details) + { + super(details); + Evaluator e = Context.createInterpreter(); + if (e != null) + e.captureStackInfo(this); + } + + public final String getMessage() + { + String details = details(); + if (sourceName == null || lineNumber <= 0) { + return details; + } + StringBuffer buf = new StringBuffer(details); + buf.append(" ("); + if (sourceName != null) { + buf.append(sourceName); + } + if (lineNumber > 0) { + buf.append('#'); + buf.append(lineNumber); + } + buf.append(')'); + return buf.toString(); + } + + public String details() + { + return super.getMessage(); + } + + /** + * Get the uri of the script source containing the error, or null + * if that information is not available. + */ + public final String sourceName() + { + return sourceName; + } + + /** + * Initialize the uri of the script source containing the error. + * + * @param sourceName the uri of the script source responsible for the error. + * It should not be <tt>null</tt>. + * + * @throws IllegalStateException if the method is called more then once. + */ + public final void initSourceName(String sourceName) + { + if (sourceName == null) throw new IllegalArgumentException(); + if (this.sourceName != null) throw new IllegalStateException(); + this.sourceName = sourceName; + } + + /** + * Returns the line number of the statement causing the error, + * or zero if not available. + */ + public final int lineNumber() + { + return lineNumber; + } + + /** + * Initialize the line number of the script statement causing the error. + * + * @param lineNumber the line number in the script source. + * It should be positive number. + * + * @throws IllegalStateException if the method is called more then once. + */ + public final void initLineNumber(int lineNumber) + { + if (lineNumber <= 0) throw new IllegalArgumentException(String.valueOf(lineNumber)); + if (this.lineNumber > 0) throw new IllegalStateException(); + this.lineNumber = lineNumber; + } + + /** + * The column number of the location of the error, or zero if unknown. + */ + public final int columnNumber() + { + return columnNumber; + } + + /** + * Initialize the column number of the script statement causing the error. + * + * @param columnNumber the column number in the script source. + * It should be positive number. + * + * @throws IllegalStateException if the method is called more then once. + */ + public final void initColumnNumber(int columnNumber) + { + if (columnNumber <= 0) throw new IllegalArgumentException(String.valueOf(columnNumber)); + if (this.columnNumber > 0) throw new IllegalStateException(); + this.columnNumber = columnNumber; + } + + /** + * The source text of the line causing the error, or null if unknown. + */ + public final String lineSource() + { + return lineSource; + } + + /** + * Initialize the text of the source line containing the error. + * + * @param lineSource the text of the source line responsible for the error. + * It should not be <tt>null</tt>. + * + * @throws IllegalStateException if the method is called more then once. + */ + public final void initLineSource(String lineSource) + { + if (lineSource == null) throw new IllegalArgumentException(); + if (this.lineSource != null) throw new IllegalStateException(); + this.lineSource = lineSource; + } + + final void recordErrorOrigin(String sourceName, int lineNumber, + String lineSource, int columnNumber) + { + // XXX: for compatibility allow for now -1 to mean 0 + if (lineNumber == -1) { + lineNumber = 0; + } + + if (sourceName != null) { + initSourceName(sourceName); + } + if (lineNumber != 0) { + initLineNumber(lineNumber); + } + if (lineSource != null) { + initLineSource(lineSource); + } + if (columnNumber != 0) { + initColumnNumber(columnNumber); + } + } + + private String generateStackTrace() + { + // Get stable reference to work properly with concurrent access + CharArrayWriter writer = new CharArrayWriter(); + super.printStackTrace(new PrintWriter(writer)); + String origStackTrace = writer.toString(); + Evaluator e = Context.createInterpreter(); + if (e != null) + return e.getPatchedStack(this, origStackTrace); + return null; + } + + /** + * Get a string representing the script stack of this exception. + * If optimization is enabled, this corresponds to all java stack elements + * with a source name ending with ".js". + * @return a script stack dump + * @since 1.6R6 + */ + public String getScriptStackTrace() + { + return getScriptStackTrace(new FilenameFilter() { + public boolean accept(File dir, String name) { + return name.endsWith(".js"); + } + }); + } + + /** + * Get a string representing the script stack of this exception. + * If optimization is enabled, this corresponds to all java stack elements + * with a source name matching the <code>filter</code>. + * @param filter the file name filter to determine whether a file is a + * script file + * @return a script stack dump + * @since 1.6R6 + */ + public String getScriptStackTrace(FilenameFilter filter) + { + List interpreterStack; + Evaluator interpreter = Context.createInterpreter(); + if (interpreter != null) + interpreterStack = interpreter.getScriptStack(this); + else + interpreterStack = new ArrayList(); + int interpreterStackIndex = 0; + StringBuffer buffer = new StringBuffer(); + String lineSeparator = SecurityUtilities.getSystemProperty("line.separator"); + StackTraceElement[] stack = getStackTrace(); + for (int i = 0; i < stack.length; i++) { + StackTraceElement e = stack[i]; + String name = e.getFileName(); + if (e.getLineNumber() > -1 && name != null && + filter.accept(null, name)) + { + buffer.append("\tat "); + buffer.append(e.getFileName()); + buffer.append(':'); + buffer.append(e.getLineNumber()); + buffer.append(lineSeparator); + } else if (interpreterStack != null && + "org.mozilla.javascript.Interpreter".equals(e.getClassName()) && + "interpretLoop".equals(e.getMethodName())) + { + buffer.append(interpreterStack.get(interpreterStackIndex++)); + } + } + return buffer.toString(); + } + + public void printStackTrace(PrintWriter s) + { + if (interpreterStackInfo == null) { + super.printStackTrace(s); + } else { + s.print(generateStackTrace()); + } + } + + public void printStackTrace(PrintStream s) + { + if (interpreterStackInfo == null) { + super.printStackTrace(s); + } else { + s.print(generateStackTrace()); + } + } + + private String sourceName; + private int lineNumber; + private String lineSource; + private int columnNumber; + + Object interpreterStackInfo; + int[] interpreterLineData; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Script.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Script.java new file mode 100644 index 0000000..4721ead --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Script.java @@ -0,0 +1,73 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * All compiled scripts implement this interface. + * <p> + * This class encapsulates script execution relative to an + * object scope. + * @since 1.3 + * @author Norris Boyd + */ + +public interface Script { + + /** + * Execute the script. + * <p> + * The script is executed in a particular runtime Context, which + * must be associated with the current thread. + * The script is executed relative to a scope--definitions and + * uses of global top-level variables and functions will access + * properties of the scope object. For compliant ECMA + * programs, the scope must be an object that has been initialized + * as a global object using <code>Context.initStandardObjects</code>. + * <p> + * + * @param cx the Context associated with the current thread + * @param scope the scope to execute relative to + * @return the result of executing the script + * @see org.mozilla.javascript.Context#initStandardObjects() + */ + public Object exec(Context cx, Scriptable scope); + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptOrFnNode.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptOrFnNode.java new file mode 100644 index 0000000..9ea6d1f --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptOrFnNode.java @@ -0,0 +1,241 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * Bob Jervis + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.util.ArrayList; + +public class ScriptOrFnNode extends Node.Scope { + + public ScriptOrFnNode(int nodeType) { + super(nodeType); + symbols = new ArrayList(4); + setParent(null); + } + + public final String getSourceName() { return sourceName; } + + public final void setSourceName(String sourceName) { + this.sourceName = sourceName; + } + + public final int getEncodedSourceStart() { return encodedSourceStart; } + + public final int getEncodedSourceEnd() { return encodedSourceEnd; } + + public final void setEncodedSourceBounds(int start, int end) { + this.encodedSourceStart = start; + this.encodedSourceEnd = end; + } + + public final int getBaseLineno() { return this.lineno; } + + public final void setBaseLineno(int lineno) { + // One time action + if (lineno < 0 || this.lineno >= 0) Kit.codeBug(); + this.lineno = lineno; + } + + public final int getEndLineno() { return endLineno; } + + public final void setEndLineno(int lineno) { + // One time action + if (lineno < 0 || endLineno >= 0) Kit.codeBug(); + endLineno = lineno; + } + + public final int getFunctionCount() { + if (functions == null) { return 0; } + return functions.size(); + } + + public final FunctionNode getFunctionNode(int i) { + return (FunctionNode)functions.get(i); + } + + public final int addFunction(FunctionNode fnNode) { + if (fnNode == null) Kit.codeBug(); + if (functions == null) { functions = new ObjArray(); } + functions.add(fnNode); + return functions.size() - 1; + } + + public final int getRegexpCount() { + if (regexps == null) { return 0; } + return regexps.size() / 2; + } + + public final String getRegexpString(int index) { + return (String)regexps.get(index * 2); + } + + public final String getRegexpFlags(int index) { + return (String)regexps.get(index * 2 + 1); + } + + /*APPJET*/public final int getRegexpLineno(int index) { + return (Integer)regexpLinenos.get(index); + } + + public final int addRegexp(String string, String flags, /*APPJET*/ + int lineno) { + if (string == null) Kit.codeBug(); + if (regexps == null) { + /*APPJET*/ + regexps = new ObjArray(); + regexpLinenos = new ObjArray(); + } + regexps.add(string); + regexps.add(flags); + /*APPJET*/regexpLinenos.add(lineno); + return regexps.size() / 2 - 1; + } + + public int getIndexForNameNode(Node nameNode) { + if (variableNames == null) throw Kit.codeBug(); + Node.Scope node = nameNode.getScope(); + Symbol symbol = node == null ? null + : node.getSymbol(nameNode.getString()); + if (symbol == null) + return -1; + return symbol.index; + } + + public final String getParamOrVarName(int index) { + if (variableNames == null) throw Kit.codeBug(); + return variableNames[index]; + } + + public final int getParamCount() { + return paramCount; + } + + public final int getParamAndVarCount() { + if (variableNames == null) throw Kit.codeBug(); + return symbols.size(); + } + + public final String[] getParamAndVarNames() { + if (variableNames == null) throw Kit.codeBug(); + return variableNames; + } + + public final boolean[] getParamAndVarConst() { + if (variableNames == null) throw Kit.codeBug(); + return isConsts; + } + + void addSymbol(Symbol symbol) { + if (variableNames != null) throw Kit.codeBug(); + if (symbol.declType == Token.LP) { + paramCount++; + } + symbols.add(symbol); + } + + /** + * Assign every symbol a unique integer index. Generate arrays of variable + * names and constness that can be indexed by those indices. + * + * @param flattenAllTables if true, flatten all symbol tables, included + * nested block scope symbol tables. If false, just flatten the script's + * or function's symbol table. + */ + void flattenSymbolTable(boolean flattenAllTables) { + if (!flattenAllTables) { + ArrayList newSymbols = new ArrayList(); + if (this.symbolTable != null) { + // Just replace "symbols" with the symbols in this object's + // symbol table. Can't just work from symbolTable map since + // we need to retain duplicate parameters. + for (int i=0; i < symbols.size(); i++) { + Symbol symbol = (Symbol) symbols.get(i); + if (symbol.containingTable == this) { + newSymbols.add(symbol); + } + } + } + symbols = newSymbols; + } + variableNames = new String[symbols.size()]; + isConsts = new boolean[symbols.size()]; + for (int i=0; i < symbols.size(); i++) { + Symbol symbol = (Symbol) symbols.get(i); + variableNames[i] = symbol.name; + isConsts[i] = symbol.declType == Token.CONST; + symbol.index = i; + } + } + + public final Object getCompilerData() + { + return compilerData; + } + + public final void setCompilerData(Object data) + { + if (data == null) throw new IllegalArgumentException(); + // Can only call once + if (compilerData != null) throw new IllegalStateException(); + compilerData = data; + } + + public String getNextTempName() + { + return "$" + tempNumber++; + } + + private int encodedSourceStart; + private int encodedSourceEnd; + private String sourceName; + private int endLineno = -1; + + private ObjArray functions; + private ObjArray regexps; + /*APPJET*/ private ObjArray regexpLinenos; + + private ArrayList symbols; + private int paramCount = 0; + private String[] variableNames; + private boolean[] isConsts; + + private Object compilerData; + private int tempNumber = 0; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptRuntime.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptRuntime.java new file mode 100644 index 0000000..f879581 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptRuntime.java @@ -0,0 +1,3830 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Patrick Beard + * Norris Boyd + * Igor Bukanov + * Ethan Hugg + * Bob Jervis + * Roger Lawrence + * Terry Lucas + * Frank Mitchell + * Milen Nankov + * Hannes Wallnoefer + * Andrew Wason + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; +import java.lang.reflect.*; +import java.text.MessageFormat; +import java.util.Locale; +import java.util.ResourceBundle; + +import org.mozilla.javascript.xml.XMLObject; +import org.mozilla.javascript.xml.XMLLib; + +/** + * This is the class that implements the runtime. + * + * @author Norris Boyd + */ + +public class ScriptRuntime { + + /** + * No instances should be created. + */ + protected ScriptRuntime() { + } + + private static class NoSuchMethodShim implements Callable { + String methodName; + Callable noSuchMethodMethod; + + NoSuchMethodShim(Callable noSuchMethodMethod, String methodName) + { + this.noSuchMethodMethod = noSuchMethodMethod; + this.methodName = methodName; + } + /** + * Perform the call. + * + * @param cx the current Context for this thread + * @param scope the scope to use to resolve properties. + * @param thisObj the JavaScript <code>this</code> object + * @param args the array of arguments + * @return the result of the call + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + Object[] nestedArgs = new Object[2]; + + nestedArgs[0] = methodName; + nestedArgs[1] = newArrayLiteral(args, null, cx, scope); + return noSuchMethodMethod.call(cx, scope, thisObj, nestedArgs); + } + + } + /* + * There's such a huge space (and some time) waste for the Foo.class + * syntax: the compiler sticks in a test of a static field in the + * enclosing class for null and the code for creating the class value. + * It has to do this since the reference has to get pushed off until + * execution time (i.e. can't force an early load), but for the + * 'standard' classes - especially those in java.lang, we can trust + * that they won't cause problems by being loaded early. + */ + + public final static Class + BooleanClass = Kit.classOrNull("java.lang.Boolean"), + ByteClass = Kit.classOrNull("java.lang.Byte"), + CharacterClass = Kit.classOrNull("java.lang.Character"), + ClassClass = Kit.classOrNull("java.lang.Class"), + DoubleClass = Kit.classOrNull("java.lang.Double"), + FloatClass = Kit.classOrNull("java.lang.Float"), + IntegerClass = Kit.classOrNull("java.lang.Integer"), + LongClass = Kit.classOrNull("java.lang.Long"), + NumberClass = Kit.classOrNull("java.lang.Number"), + ObjectClass = Kit.classOrNull("java.lang.Object"), + ShortClass = Kit.classOrNull("java.lang.Short"), + StringClass = Kit.classOrNull("java.lang.String"), + DateClass = Kit.classOrNull("java.util.Date"); + + public final static Class + ContextClass + = Kit.classOrNull("org.mozilla.javascript.Context"), + ContextFactoryClass + = Kit.classOrNull("org.mozilla.javascript.ContextFactory"), + FunctionClass + = Kit.classOrNull("org.mozilla.javascript.Function"), + ScriptableClass + = Kit.classOrNull("org.mozilla.javascript.Scriptable"), + ScriptableObjectClass + = Kit.classOrNull("org.mozilla.javascript.ScriptableObject"); + + private static final String[] lazilyNames = { + "RegExp", "org.mozilla.javascript.regexp.NativeRegExp", + "Packages", "org.mozilla.javascript.NativeJavaTopPackage", + "java", "org.mozilla.javascript.NativeJavaTopPackage", + "javax", "org.mozilla.javascript.NativeJavaTopPackage", + "org", "org.mozilla.javascript.NativeJavaTopPackage", + "com", "org.mozilla.javascript.NativeJavaTopPackage", + "edu", "org.mozilla.javascript.NativeJavaTopPackage", + "net", "org.mozilla.javascript.NativeJavaTopPackage", + "getClass", "org.mozilla.javascript.NativeJavaTopPackage", + "JavaAdapter", "org.mozilla.javascript.JavaAdapter", + "JavaImporter", "org.mozilla.javascript.ImporterTopLevel", + "Continuation", "org.mozilla.javascript.continuations.Continuation", + // TODO Grotesque hack using literal string (xml) just to minimize + // changes for now + "XML", "(xml)", + "XMLList", "(xml)", + "Namespace", "(xml)", + "QName", "(xml)", + }; + + private static final Object LIBRARY_SCOPE_KEY = new Object(); + + public static boolean isRhinoRuntimeType(Class cl) + { + if (cl.isPrimitive()) { + return (cl != Character.TYPE); + } else { + return (cl == StringClass || cl == BooleanClass + || NumberClass.isAssignableFrom(cl) + || ScriptableClass.isAssignableFrom(cl)); + } + } + + public static ScriptableObject initStandardObjects(Context cx, + ScriptableObject scope, + boolean sealed) + { + if (scope == null) { + scope = new NativeObject(); + } + scope.associateValue(LIBRARY_SCOPE_KEY, scope); + (new ClassCache()).associate(scope); + + BaseFunction.init(scope, sealed); + NativeObject.init(scope, sealed); + + Scriptable objectProto = ScriptableObject.getObjectPrototype(scope); + + // Function.prototype.__proto__ should be Object.prototype + Scriptable functionProto = ScriptableObject.getFunctionPrototype(scope); + functionProto.setPrototype(objectProto); + + // Set the prototype of the object passed in if need be + if (scope.getPrototype() == null) + scope.setPrototype(objectProto); + + // must precede NativeGlobal since it's needed therein + NativeError.init(scope, sealed); + NativeGlobal.init(cx, scope, sealed); + + NativeArray.init(scope, sealed); + if (cx.getOptimizationLevel() > 0) { + // When optimizing, attempt to fulfill all requests for new Array(N) + // with a higher threshold before switching to a sparse + // representation + NativeArray.setMaximumInitialCapacity(200000); + } + NativeString.init(scope, sealed); + NativeBoolean.init(scope, sealed); + NativeNumber.init(scope, sealed); + NativeDate.init(scope, sealed); + NativeMath.init(scope, sealed); + + NativeWith.init(scope, sealed); + NativeCall.init(scope, sealed); + NativeScript.init(scope, sealed); + + NativeIterator.init(scope, sealed); // Also initializes NativeGenerator + + boolean withXml = cx.hasFeature(Context.FEATURE_E4X) && + cx.getE4xImplementationFactory() != null; + + for (int i = 0; i != lazilyNames.length; i += 2) { + String topProperty = lazilyNames[i]; + String className = lazilyNames[i + 1]; + if (!withXml && className.equals("(xml)")) { + continue; + } else if (withXml && className.equals("(xml)")) { + className = cx.getE4xImplementationFactory(). + getImplementationClassName(); + } + new LazilyLoadedCtor(scope, topProperty, className, sealed); + } + + return scope; + } + + public static ScriptableObject getLibraryScopeOrNull(Scriptable scope) + { + ScriptableObject libScope; + libScope = (ScriptableObject)ScriptableObject. + getTopScopeValue(scope, LIBRARY_SCOPE_KEY); + return libScope; + } + + // It is public so NativeRegExp can access it. + public static boolean isJSLineTerminator(int c) + { + // Optimization for faster check for eol character: + // they do not have 0xDFD0 bits set + if ((c & 0xDFD0) != 0) { + return false; + } + return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029; + } + + public static Boolean wrapBoolean(boolean b) + { + return b ? Boolean.TRUE : Boolean.FALSE; + } + + public static Integer wrapInt(int i) + { + return new Integer(i); + } + + public static Number wrapNumber(double x) + { + if (x != x) { + return ScriptRuntime.NaNobj; + } + return new Double(x); + } + + /** + * Convert the value to a boolean. + * + * See ECMA 9.2. + */ + public static boolean toBoolean(Object val) + { + for (;;) { + if (val instanceof Boolean) + return ((Boolean) val).booleanValue(); + if (val == null || val == Undefined.instance) + return false; + if (val instanceof String) + return ((String) val).length() != 0; + if (val instanceof Number) { + double d = ((Number) val).doubleValue(); + return (d == d && d != 0.0); + } + if (val instanceof Scriptable) { + if (val instanceof ScriptableObject && + ((ScriptableObject) val).avoidObjectDetection()) + { + return false; + } + if (Context.getContext().isVersionECMA1()) { + // pure ECMA + return true; + } + // ECMA extension + val = ((Scriptable) val).getDefaultValue(BooleanClass); + if (val instanceof Scriptable) + throw errorWithClassName("msg.primitive.expected", val); + continue; + } + warnAboutNonJSObject(val); + return true; + } + } + + /** + * Convert the value to a number. + * + * See ECMA 9.3. + */ + public static double toNumber(Object val) + { + for (;;) { + if (val instanceof Number) + return ((Number) val).doubleValue(); + if (val == null) + return +0.0; + if (val == Undefined.instance) + return NaN; + if (val instanceof String) + return toNumber((String) val); + if (val instanceof Boolean) + return ((Boolean) val).booleanValue() ? 1 : +0.0; + if (val instanceof Scriptable) { + val = ((Scriptable) val).getDefaultValue(NumberClass); + if (val instanceof Scriptable) + throw errorWithClassName("msg.primitive.expected", val); + continue; + } + warnAboutNonJSObject(val); + return NaN; + } + } + + public static double toNumber(Object[] args, int index) { + return (index < args.length) ? toNumber(args[index]) : NaN; + } + + // Can not use Double.NaN defined as 0.0d / 0.0 as under the Microsoft VM, + // versions 2.01 and 3.0P1, that causes some uses (returns at least) of + // Double.NaN to be converted to 1.0. + // So we use ScriptRuntime.NaN instead of Double.NaN. + public static final double + NaN = Double.longBitsToDouble(0x7ff8000000000000L); + + // A similar problem exists for negative zero. + public static final double + negativeZero = Double.longBitsToDouble(0x8000000000000000L); + + public static final Double NaNobj = new Double(NaN); + + /* + * Helper function for toNumber, parseInt, and TokenStream.getToken. + */ + static double stringToNumber(String s, int start, int radix) { + char digitMax = '9'; + char lowerCaseBound = 'a'; + char upperCaseBound = 'A'; + int len = s.length(); + if (radix < 10) { + digitMax = (char) ('0' + radix - 1); + } + if (radix > 10) { + lowerCaseBound = (char) ('a' + radix - 10); + upperCaseBound = (char) ('A' + radix - 10); + } + int end; + double sum = 0.0; + for (end=start; end < len; end++) { + char c = s.charAt(end); + int newDigit; + if ('0' <= c && c <= digitMax) + newDigit = c - '0'; + else if ('a' <= c && c < lowerCaseBound) + newDigit = c - 'a' + 10; + else if ('A' <= c && c < upperCaseBound) + newDigit = c - 'A' + 10; + else + break; + sum = sum*radix + newDigit; + } + if (start == end) { + return NaN; + } + if (sum >= 9007199254740992.0) { + if (radix == 10) { + /* If we're accumulating a decimal number and the number + * is >= 2^53, then the result from the repeated multiply-add + * above may be inaccurate. Call Java to get the correct + * answer. + */ + try { + return Double.valueOf(s.substring(start, end)).doubleValue(); + } catch (NumberFormatException nfe) { + return NaN; + } + } else if (radix == 2 || radix == 4 || radix == 8 || + radix == 16 || radix == 32) + { + /* The number may also be inaccurate for one of these bases. + * This happens if the addition in value*radix + digit causes + * a round-down to an even least significant mantissa bit + * when the first dropped bit is a one. If any of the + * following digits in the number (which haven't been added + * in yet) are nonzero then the correct action would have + * been to round up instead of down. An example of this + * occurs when reading the number 0x1000000000000081, which + * rounds to 0x1000000000000000 instead of 0x1000000000000100. + */ + int bitShiftInChar = 1; + int digit = 0; + + final int SKIP_LEADING_ZEROS = 0; + final int FIRST_EXACT_53_BITS = 1; + final int AFTER_BIT_53 = 2; + final int ZEROS_AFTER_54 = 3; + final int MIXED_AFTER_54 = 4; + + int state = SKIP_LEADING_ZEROS; + int exactBitsLimit = 53; + double factor = 0.0; + boolean bit53 = false; + // bit54 is the 54th bit (the first dropped from the mantissa) + boolean bit54 = false; + + for (;;) { + if (bitShiftInChar == 1) { + if (start == end) + break; + digit = s.charAt(start++); + if ('0' <= digit && digit <= '9') + digit -= '0'; + else if ('a' <= digit && digit <= 'z') + digit -= 'a' - 10; + else + digit -= 'A' - 10; + bitShiftInChar = radix; + } + bitShiftInChar >>= 1; + boolean bit = (digit & bitShiftInChar) != 0; + + switch (state) { + case SKIP_LEADING_ZEROS: + if (bit) { + --exactBitsLimit; + sum = 1.0; + state = FIRST_EXACT_53_BITS; + } + break; + case FIRST_EXACT_53_BITS: + sum *= 2.0; + if (bit) + sum += 1.0; + --exactBitsLimit; + if (exactBitsLimit == 0) { + bit53 = bit; + state = AFTER_BIT_53; + } + break; + case AFTER_BIT_53: + bit54 = bit; + factor = 2.0; + state = ZEROS_AFTER_54; + break; + case ZEROS_AFTER_54: + if (bit) { + state = MIXED_AFTER_54; + } + // fallthrough + case MIXED_AFTER_54: + factor *= 2; + break; + } + } + switch (state) { + case SKIP_LEADING_ZEROS: + sum = 0.0; + break; + case FIRST_EXACT_53_BITS: + case AFTER_BIT_53: + // do nothing + break; + case ZEROS_AFTER_54: + // x1.1 -> x1 + 1 (round up) + // x0.1 -> x0 (round down) + if (bit54 & bit53) + sum += 1.0; + sum *= factor; + break; + case MIXED_AFTER_54: + // x.100...1.. -> x + 1 (round up) + // x.0anything -> x (round down) + if (bit54) + sum += 1.0; + sum *= factor; + break; + } + } + /* We don't worry about inaccurate numbers for any other base. */ + } + return sum; + } + + + /** + * ToNumber applied to the String type + * + * See ECMA 9.3.1 + */ + public static double toNumber(String s) { + int len = s.length(); + int start = 0; + char startChar; + for (;;) { + if (start == len) { + // Empty or contains only whitespace + return +0.0; + } + startChar = s.charAt(start); + if (!Character.isWhitespace(startChar)) + break; + start++; + } + + if (startChar == '0') { + if (start + 2 < len) { + int c1 = s.charAt(start + 1); + if (c1 == 'x' || c1 == 'X') { + // A hexadecimal number + return stringToNumber(s, start + 2, 16); + } + } + } else if (startChar == '+' || startChar == '-') { + if (start + 3 < len && s.charAt(start + 1) == '0') { + int c2 = s.charAt(start + 2); + if (c2 == 'x' || c2 == 'X') { + // A hexadecimal number with sign + double val = stringToNumber(s, start + 3, 16); + return startChar == '-' ? -val : val; + } + } + } + + int end = len - 1; + char endChar; + while (Character.isWhitespace(endChar = s.charAt(end))) + end--; + if (endChar == 'y') { + // check for "Infinity" + if (startChar == '+' || startChar == '-') + start++; + if (start + 7 == end && s.regionMatches(start, "Infinity", 0, 8)) + return startChar == '-' + ? Double.NEGATIVE_INFINITY + : Double.POSITIVE_INFINITY; + return NaN; + } + // A non-hexadecimal, non-infinity number: + // just try a normal floating point conversion + String sub = s.substring(start, end+1); + if (MSJVM_BUG_WORKAROUNDS) { + // The MS JVM will accept non-conformant strings + // rather than throwing a NumberFormatException + // as it should. + for (int i=sub.length()-1; i >= 0; i--) { + char c = sub.charAt(i); + if (('0' <= c && c <= '9') || c == '.' || + c == 'e' || c == 'E' || + c == '+' || c == '-') + continue; + return NaN; + } + } + try { + return Double.valueOf(sub).doubleValue(); + } catch (NumberFormatException ex) { + return NaN; + } + } + + /** + * Helper function for builtin objects that use the varargs form. + * ECMA function formal arguments are undefined if not supplied; + * this function pads the argument array out to the expected + * length, if necessary. + */ + public static Object[] padArguments(Object[] args, int count) { + if (count < args.length) + return args; + + int i; + Object[] result = new Object[count]; + for (i = 0; i < args.length; i++) { + result[i] = args[i]; + } + + for (; i < count; i++) { + result[i] = Undefined.instance; + } + + return result; + } + + /* Work around Microsoft Java VM bugs. */ + private final static boolean MSJVM_BUG_WORKAROUNDS = true; + + public static String escapeString(String s) + { + return escapeString(s, '"'); + } + + /** + * For escaping strings printed by object and array literals; not quite + * the same as 'escape.' + */ + public static String escapeString(String s, char escapeQuote) + { + if (!(escapeQuote == '"' || escapeQuote == '\'')) Kit.codeBug(); + StringBuffer sb = null; + + for(int i = 0, L = s.length(); i != L; ++i) { + int c = s.charAt(i); + + if (' ' <= c && c <= '~' && c != escapeQuote && c != '\\') { + // an ordinary print character (like C isprint()) and not " + // or \ . + if (sb != null) { + sb.append((char)c); + } + continue; + } + if (sb == null) { + sb = new StringBuffer(L + 3); + sb.append(s); + sb.setLength(i); + } + + int escape = -1; + switch (c) { + case '\b': escape = 'b'; break; + case '\f': escape = 'f'; break; + case '\n': escape = 'n'; break; + case '\r': escape = 'r'; break; + case '\t': escape = 't'; break; + case 0xb: escape = 'v'; break; // Java lacks \v. + case ' ': escape = ' '; break; + case '\\': escape = '\\'; break; + } + if (escape >= 0) { + // an \escaped sort of character + sb.append('\\'); + sb.append((char)escape); + } else if (c == escapeQuote) { + sb.append('\\'); + sb.append(escapeQuote); + } else { + int hexSize; + if (c < 256) { + // 2-digit hex + sb.append("\\x"); + hexSize = 2; + } else { + // Unicode. + sb.append("\\u"); + hexSize = 4; + } + // append hexadecimal form of c left-padded with 0 + for (int shift = (hexSize - 1) * 4; shift >= 0; shift -= 4) { + int digit = 0xf & (c >> shift); + int hc = (digit < 10) ? '0' + digit : 'a' - 10 + digit; + sb.append((char)hc); + } + } + } + return (sb == null) ? s : sb.toString(); + } + + static boolean isValidIdentifierName(String s) + { + int L = s.length(); + if (L == 0) + return false; + if (!Character.isJavaIdentifierStart(s.charAt(0))) + return false; + for (int i = 1; i != L; ++i) { + if (!Character.isJavaIdentifierPart(s.charAt(i))) + return false; + } + return !TokenStream.isKeyword(s); + } + + /** + * Convert the value to a string. + * + * See ECMA 9.8. + */ + public static String toString(Object val) { + for (;;) { + if (val == null) { + return "null"; + } + if (val == Undefined.instance) { + return "undefined"; + } + if (val instanceof String) { + return (String)val; + } + if (val instanceof Number) { + // XXX should we just teach NativeNumber.stringValue() + // about Numbers? + return numberToString(((Number)val).doubleValue(), 10); + } + if (val instanceof Scriptable) { + val = ((Scriptable) val).getDefaultValue(StringClass); + if (val instanceof Scriptable) { + throw errorWithClassName("msg.primitive.expected", val); + } + continue; + } + return val.toString(); + } + } + + static String defaultObjectToString(Scriptable obj) + { + return "[object " + obj.getClassName() + ']'; + } + + public static String toString(Object[] args, int index) + { + return (index < args.length) ? toString(args[index]) : "undefined"; + } + + /** + * Optimized version of toString(Object) for numbers. + */ + public static String toString(double val) { + return numberToString(val, 10); + } + + public static String numberToString(double d, int base) { + if (d != d) + return "NaN"; + if (d == Double.POSITIVE_INFINITY) + return "Infinity"; + if (d == Double.NEGATIVE_INFINITY) + return "-Infinity"; + if (d == 0.0) + return "0"; + + if ((base < 2) || (base > 36)) { + throw Context.reportRuntimeError1( + "msg.bad.radix", Integer.toString(base)); + } + + if (base != 10) { + return DToA.JS_dtobasestr(base, d); + } else { + StringBuffer result = new StringBuffer(); + DToA.JS_dtostr(result, DToA.DTOSTR_STANDARD, 0, d); + return result.toString(); + } + + } + + static String uneval(Context cx, Scriptable scope, Object value) + { + if (value == null) { + return "null"; + } + if (value == Undefined.instance) { + return "undefined"; + } + if (value instanceof String) { + String escaped = escapeString((String)value); + StringBuffer sb = new StringBuffer(escaped.length() + 2); + sb.append('\"'); + sb.append(escaped); + sb.append('\"'); + return sb.toString(); + } + if (value instanceof Number) { + double d = ((Number)value).doubleValue(); + if (d == 0 && 1 / d < 0) { + return "-0"; + } + return toString(d); + } + if (value instanceof Boolean) { + return toString(value); + } + if (value instanceof Scriptable) { + Scriptable obj = (Scriptable)value; + // Wrapped Java objects won't have "toSource" and will report + // errors for get()s of nonexistent name, so use has() first + if (ScriptableObject.hasProperty(obj, "toSource")) { + Object v = ScriptableObject.getProperty(obj, "toSource"); + if (v instanceof Function) { + Function f = (Function)v; + return toString(f.call(cx, scope, obj, emptyArgs)); + } + } + return toString(value); + } + warnAboutNonJSObject(value); + return value.toString(); + } + + static String defaultObjectToSource(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + boolean toplevel, iterating; + if (cx.iterating == null) { + toplevel = true; + iterating = false; + cx.iterating = new ObjToIntMap(31); + } else { + toplevel = false; + iterating = cx.iterating.has(thisObj); + } + + StringBuffer result = new StringBuffer(128); + if (toplevel) { + result.append("("); + } + result.append('{'); + + // Make sure cx.iterating is set to null when done + // so we don't leak memory + try { + if (!iterating) { + cx.iterating.intern(thisObj); // stop recursion. + Object[] ids = thisObj.getIds(); + for (int i=0; i < ids.length; i++) { + Object id = ids[i]; + Object value; + if (id instanceof Integer) { + int intId = ((Integer)id).intValue(); + value = thisObj.get(intId, thisObj); + if (value == Scriptable.NOT_FOUND) + continue; // a property has been removed + if (i > 0) + result.append(", "); + result.append(intId); + } else { + String strId = (String)id; + value = thisObj.get(strId, thisObj); + if (value == Scriptable.NOT_FOUND) + continue; // a property has been removed + if (i > 0) + result.append(", "); + if (ScriptRuntime.isValidIdentifierName(strId)) { + result.append(strId); + } else { + result.append('\''); + result.append( + ScriptRuntime.escapeString(strId, '\'')); + result.append('\''); + } + } + result.append(':'); + result.append(ScriptRuntime.uneval(cx, scope, value)); + } + } + } finally { + if (toplevel) { + cx.iterating = null; + } + } + + result.append('}'); + if (toplevel) { + result.append(')'); + } + return result.toString(); + } + + public static Scriptable toObject(Scriptable scope, Object val) + { + if (val instanceof Scriptable) { + return (Scriptable)val; + } + return toObject(Context.getContext(), scope, val); + } + + public static Scriptable toObjectOrNull(Context cx, Object obj) + { + if (obj instanceof Scriptable) { + return (Scriptable)obj; + } else if (obj != null && obj != Undefined.instance) { + return toObject(cx, getTopCallScope(cx), obj); + } + return null; + } + + /** + * @deprecated Use {@link #toObject(Scriptable, Object)} instead. + */ + public static Scriptable toObject(Scriptable scope, Object val, + Class staticClass) + { + if (val instanceof Scriptable) { + return (Scriptable)val; + } + return toObject(Context.getContext(), scope, val); + } + + /** + * Convert the value to an object. + * + * See ECMA 9.9. + */ + public static Scriptable toObject(Context cx, Scriptable scope, Object val) + { + if (val instanceof Scriptable) { + return (Scriptable) val; + } + if (val == null) { + throw typeError0("msg.null.to.object"); + } + if (val == Undefined.instance) { + throw typeError0("msg.undef.to.object"); + } + String className = val instanceof String ? "String" : + val instanceof Number ? "Number" : + val instanceof Boolean ? "Boolean" : + null; + if (className != null) { + Object[] args = { val }; + scope = ScriptableObject.getTopLevelScope(scope); + return newObject(cx, scope, className, args); + } + + // Extension: Wrap as a LiveConnect object. + Object wrapped = cx.getWrapFactory().wrap(cx, scope, val, null); + if (wrapped instanceof Scriptable) + return (Scriptable) wrapped; + throw errorWithClassName("msg.invalid.type", val); + } + + /** + * @deprecated Use {@link #toObject(Context, Scriptable, Object)} instead. + */ + public static Scriptable toObject(Context cx, Scriptable scope, Object val, + Class staticClass) + { + return toObject(cx, scope, val); + } + + /** + * @deprecated The method is only present for compatibility. + */ + public static Object call(Context cx, Object fun, Object thisArg, + Object[] args, Scriptable scope) + { + if (!(fun instanceof Function)) { + throw notFunctionError(toString(fun)); + } + Function function = (Function)fun; + Scriptable thisObj = toObjectOrNull(cx, thisArg); + if (thisObj == null) { + throw undefCallError(thisObj, "function"); + } + return function.call(cx, scope, thisObj, args); + } + + public static Scriptable newObject(Context cx, Scriptable scope, + String constructorName, Object[] args) + { + scope = ScriptableObject.getVeryTopLevelScope(scope); // APPJET + Function ctor = getExistingCtor(cx, scope, constructorName); + if (args == null) { args = ScriptRuntime.emptyArgs; } + return ctor.construct(cx, scope, args); + } + + /** + * + * See ECMA 9.4. + */ + public static double toInteger(Object val) { + return toInteger(toNumber(val)); + } + + // convenience method + public static double toInteger(double d) { + // if it's NaN + if (d != d) + return +0.0; + + if (d == 0.0 || + d == Double.POSITIVE_INFINITY || + d == Double.NEGATIVE_INFINITY) + return d; + + if (d > 0.0) + return Math.floor(d); + else + return Math.ceil(d); + } + + public static double toInteger(Object[] args, int index) { + return (index < args.length) ? toInteger(args[index]) : +0.0; + } + + /** + * + * See ECMA 9.5. + */ + public static int toInt32(Object val) + { + // short circuit for common integer values + if (val instanceof Integer) + return ((Integer)val).intValue(); + + return toInt32(toNumber(val)); + } + + public static int toInt32(Object[] args, int index) { + return (index < args.length) ? toInt32(args[index]) : 0; + } + + public static int toInt32(double d) { + int id = (int)d; + if (id == d) { + // This covers -0.0 as well + return id; + } + + if (d != d + || d == Double.POSITIVE_INFINITY + || d == Double.NEGATIVE_INFINITY) + { + return 0; + } + + d = (d >= 0) ? Math.floor(d) : Math.ceil(d); + + double two32 = 4294967296.0; + d = Math.IEEEremainder(d, two32); + // (double)(long)d == d should hold here + + long l = (long)d; + // returning (int)d does not work as d can be outside int range + // but the result must always be 32 lower bits of l + return (int)l; + } + + /** + * See ECMA 9.6. + * @return long value representing 32 bits unsigned integer + */ + public static long toUint32(double d) { + long l = (long)d; + if (l == d) { + // This covers -0.0 as well + return l & 0xffffffffL; + } + + if (d != d + || d == Double.POSITIVE_INFINITY + || d == Double.NEGATIVE_INFINITY) + { + return 0; + } + + d = (d >= 0) ? Math.floor(d) : Math.ceil(d); + + // 0x100000000 gives me a numeric overflow... + double two32 = 4294967296.0; + l = (long)Math.IEEEremainder(d, two32); + + return l & 0xffffffffL; + } + + public static long toUint32(Object val) { + return toUint32(toNumber(val)); + } + + /** + * + * See ECMA 9.7. + */ + public static char toUint16(Object val) { + double d = toNumber(val); + + int i = (int)d; + if (i == d) { + return (char)i; + } + + if (d != d + || d == Double.POSITIVE_INFINITY + || d == Double.NEGATIVE_INFINITY) + { + return 0; + } + + d = (d >= 0) ? Math.floor(d) : Math.ceil(d); + + int int16 = 0x10000; + i = (int)Math.IEEEremainder(d, int16); + + return (char)i; + } + + // XXX: this is until setDefaultNamespace will learn how to store NS + // properly and separates namespace form Scriptable.get etc. + private static final String DEFAULT_NS_TAG = "__default_namespace__"; + + public static Object setDefaultNamespace(Object namespace, Context cx) + { + Scriptable scope = cx.currentActivationCall; + if (scope == null) { + scope = getTopCallScope(cx); + } + + XMLLib xmlLib = currentXMLLib(cx); + Object ns = xmlLib.toDefaultXmlNamespace(cx, namespace); + + // XXX : this should be in separated namesapce from Scriptable.get/put + if (!scope.has(DEFAULT_NS_TAG, scope)) { + // XXX: this is racy of cause + ScriptableObject.defineProperty(scope, DEFAULT_NS_TAG, ns, + ScriptableObject.PERMANENT + | ScriptableObject.DONTENUM); + } else { + scope.put(DEFAULT_NS_TAG, scope, ns); + } + + return Undefined.instance; + } + + public static Object searchDefaultNamespace(Context cx) + { + Scriptable scope = cx.currentActivationCall; + if (scope == null) { + scope = getTopCallScope(cx); + } + Object nsObject; + for (;;) { + Scriptable parent = scope.getParentScope(); + if (parent == null) { + nsObject = ScriptableObject.getProperty(scope, DEFAULT_NS_TAG); + if (nsObject == Scriptable.NOT_FOUND) { + return null; + } + break; + } + nsObject = scope.get(DEFAULT_NS_TAG, scope); + if (nsObject != Scriptable.NOT_FOUND) { + break; + } + scope = parent; + } + return nsObject; + } + + public static Object getTopLevelProp(Scriptable scope, String id) { + scope = ScriptableObject.getTopLevelScope(scope); + return ScriptableObject.getProperty(scope, id); + } + + static Function getExistingCtor(Context cx, Scriptable scope, + String constructorName) + { + Object ctorVal = ScriptableObject.getProperty(scope, constructorName); + if (ctorVal instanceof Function) { + return (Function)ctorVal; + } + if (ctorVal == Scriptable.NOT_FOUND) { + throw Context.reportRuntimeError1( + "msg.ctor.not.found", constructorName); + } else { + throw Context.reportRuntimeError1( + "msg.not.ctor", constructorName); + } + } + + /** + * Return -1L if str is not an index or the index value as lower 32 + * bits of the result. + */ + private static long indexFromString(String str) + { + // The length of the decimal string representation of + // Integer.MAX_VALUE, 2147483647 + final int MAX_VALUE_LENGTH = 10; + + int len = str.length(); + if (len > 0) { + int i = 0; + boolean negate = false; + int c = str.charAt(0); + if (c == '-') { + if (len > 1) { + c = str.charAt(1); + i = 1; + negate = true; + } + } + c -= '0'; + if (0 <= c && c <= 9 + && len <= (negate ? MAX_VALUE_LENGTH + 1 : MAX_VALUE_LENGTH)) + { + // Use negative numbers to accumulate index to handle + // Integer.MIN_VALUE that is greater by 1 in absolute value + // then Integer.MAX_VALUE + int index = -c; + int oldIndex = 0; + i++; + if (index != 0) { + // Note that 00, 01, 000 etc. are not indexes + while (i != len && 0 <= (c = str.charAt(i) - '0') && c <= 9) + { + oldIndex = index; + index = 10 * index - c; + i++; + } + } + // Make sure all characters were consumed and that it couldn't + // have overflowed. + if (i == len && + (oldIndex > (Integer.MIN_VALUE / 10) || + (oldIndex == (Integer.MIN_VALUE / 10) && + c <= (negate ? -(Integer.MIN_VALUE % 10) + : (Integer.MAX_VALUE % 10))))) + { + return 0xFFFFFFFFL & (negate ? index : -index); + } + } + } + return -1L; + } + + /** + * If str is a decimal presentation of Uint32 value, return it as long. + * Othewise return -1L; + */ + public static long testUint32String(String str) + { + // The length of the decimal string representation of + // UINT32_MAX_VALUE, 4294967296 + final int MAX_VALUE_LENGTH = 10; + + int len = str.length(); + if (1 <= len && len <= MAX_VALUE_LENGTH) { + int c = str.charAt(0); + c -= '0'; + if (c == 0) { + // Note that 00,01 etc. are not valid Uint32 presentations + return (len == 1) ? 0L : -1L; + } + if (1 <= c && c <= 9) { + long v = c; + for (int i = 1; i != len; ++i) { + c = str.charAt(i) - '0'; + if (!(0 <= c && c <= 9)) { + return -1; + } + v = 10 * v + c; + } + // Check for overflow + if ((v >>> 32) == 0) { + return v; + } + } + } + return -1; + } + + /** + * If s represents index, then return index value wrapped as Integer + * and othewise return s. + */ + static Object getIndexObject(String s) + { + long indexTest = indexFromString(s); + if (indexTest >= 0) { + return new Integer((int)indexTest); + } + return s; + } + + /** + * If d is exact int value, return its value wrapped as Integer + * and othewise return d converted to String. + */ + static Object getIndexObject(double d) + { + int i = (int)d; + if (i == d) { + return new Integer(i); + } + return toString(d); + } + + /** + * If toString(id) is a decimal presentation of int32 value, then id + * is index. In this case return null and make the index available + * as ScriptRuntime.lastIndexResult(cx). Otherwise return toString(id). + */ + static String toStringIdOrIndex(Context cx, Object id) + { + if (id instanceof Number) { + double d = ((Number)id).doubleValue(); + int index = (int)d; + if (index == d) { + storeIndexResult(cx, index); + return null; + } + return toString(id); + } else { + String s; + if (id instanceof String) { + s = (String)id; + } else { + s = toString(id); + } + long indexTest = indexFromString(s); + if (indexTest >= 0) { + storeIndexResult(cx, (int)indexTest); + return null; + } + return s; + } + } + + /** + * Call obj.[[Get]](id) + */ + public static Object getObjectElem(Object obj, Object elem, Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefReadError(obj, elem); + } + return getObjectElem(sobj, elem, cx); + } + + public static Object getObjectElem(Scriptable obj, Object elem, + Context cx) + { + if (obj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)obj; + return xmlObject.ecmaGet(cx, elem); + } + + Object result; + + String s = toStringIdOrIndex(cx, elem); + if (s == null) { + int index = lastIndexResult(cx); + result = ScriptableObject.getProperty(obj, index); + } else { + result = ScriptableObject.getProperty(obj, s); + } + + if (result == Scriptable.NOT_FOUND) { + result = Undefined.instance; + } + + return result; + } + + /** + * Version of getObjectElem when elem is a valid JS identifier name. + */ + public static Object getObjectProp(Object obj, String property, + Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefReadError(obj, property); + } + return getObjectProp(sobj, property, cx); + } + + public static Object getObjectProp(Scriptable obj, String property, + Context cx) + { + if (obj instanceof XMLObject) { + // TODO: Change XMLObject to just use Scriptable interface + // to avoid paying cost of instanceof check on *every property + // lookup* ! + XMLObject xmlObject = (XMLObject)obj; + return xmlObject.ecmaGet(cx, property); + } + + Object result = ScriptableObject.getProperty(obj, property); + if (result == Scriptable.NOT_FOUND) { + if (cx.hasFeature(Context.FEATURE_STRICT_MODE)) { + Context.reportWarning(ScriptRuntime.getMessage1( + "msg.ref.undefined.prop", property)); + } + result = Undefined.instance; + } + + return result; + } + + public static Object getObjectPropNoWarn(Object obj, String property, + Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefReadError(obj, property); + } + if (obj instanceof XMLObject) { + // TODO: fix as mentioned in note in method above + getObjectProp(sobj, property, cx); + } + Object result = ScriptableObject.getProperty(sobj, property); + if (result == Scriptable.NOT_FOUND) { + return Undefined.instance; + } + return result; + } + + /* + * A cheaper and less general version of the above for well-known argument + * types. + */ + public static Object getObjectIndex(Object obj, double dblIndex, + Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefReadError(obj, toString(dblIndex)); + } + + int index = (int)dblIndex; + if (index == dblIndex) { + return getObjectIndex(sobj, index, cx); + } else { + String s = toString(dblIndex); + return getObjectProp(sobj, s, cx); + } + } + + public static Object getObjectIndex(Scriptable obj, int index, + Context cx) + { + if (obj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)obj; + return xmlObject.ecmaGet(cx, new Integer(index)); + } + + Object result = ScriptableObject.getProperty(obj, index); + if (result == Scriptable.NOT_FOUND) { + result = Undefined.instance; + } + + return result; + } + + /* + * Call obj.[[Put]](id, value) + */ + public static Object setObjectElem(Object obj, Object elem, Object value, + Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefWriteError(obj, elem, value); + } + return setObjectElem(sobj, elem, value, cx); + } + + public static Object setObjectElem(Scriptable obj, Object elem, + Object value, Context cx) + { + if (obj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)obj; + xmlObject.ecmaPut(cx, elem, value); + return value; + } + + String s = toStringIdOrIndex(cx, elem); + if (s == null) { + int index = lastIndexResult(cx); + ScriptableObject.putProperty(obj, index, value); + } else { + ScriptableObject.putProperty(obj, s, value); + } + + return value; + } + + /** + * Version of setObjectElem when elem is a valid JS identifier name. + */ + public static Object setObjectProp(Object obj, String property, + Object value, Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefWriteError(obj, property, value); + } + return setObjectProp(sobj, property, value, cx); + } + + public static Object setObjectProp(Scriptable obj, String property, + Object value, Context cx) + { + if (obj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)obj; + xmlObject.ecmaPut(cx, property, value); + } else { + ScriptableObject.putProperty(obj, property, value); + } + return value; + } + + /* + * A cheaper and less general version of the above for well-known argument + * types. + */ + public static Object setObjectIndex(Object obj, double dblIndex, + Object value, Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw undefWriteError(obj, String.valueOf(dblIndex), value); + } + + int index = (int)dblIndex; + if (index == dblIndex) { + return setObjectIndex(sobj, index, value, cx); + } else { + String s = toString(dblIndex); + return setObjectProp(sobj, s, value, cx); + } + } + + public static Object setObjectIndex(Scriptable obj, int index, Object value, + Context cx) + { + if (obj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)obj; + xmlObject.ecmaPut(cx, new Integer(index), value); + } else { + ScriptableObject.putProperty(obj, index, value); + } + return value; + } + + public static boolean deleteObjectElem(Scriptable target, Object elem, + Context cx) + { + boolean result; + if (target instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)target; + result = xmlObject.ecmaDelete(cx, elem); + } else { + String s = toStringIdOrIndex(cx, elem); + if (s == null) { + int index = lastIndexResult(cx); + result = ScriptableObject.deleteProperty(target, index); + } else { + result = ScriptableObject.deleteProperty(target, s); + } + } + return result; + } + + public static boolean hasObjectElem(Scriptable target, Object elem, + Context cx) + { + boolean result; + + if (target instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)target; + result = xmlObject.ecmaHas(cx, elem); + } else { + String s = toStringIdOrIndex(cx, elem); + if (s == null) { + int index = lastIndexResult(cx); + result = ScriptableObject.hasProperty(target, index); + } else { + result = ScriptableObject.hasProperty(target, s); + } + } + + return result; + } + + public static Object refGet(Ref ref, Context cx) + { + return ref.get(cx); + } + + public static Object refSet(Ref ref, Object value, Context cx) + { + return ref.set(cx, value); + } + + public static Object refDel(Ref ref, Context cx) + { + return wrapBoolean(ref.delete(cx)); + } + + static boolean isSpecialProperty(String s) + { + return s.equals("__proto__") || s.equals("__parent__"); + } + + public static Ref specialRef(Object obj, String specialProperty, + Context cx) + { + return SpecialRef.createSpecial(cx, obj, specialProperty); + } + + /** + * The delete operator + * + * See ECMA 11.4.1 + * + * In ECMA 0.19, the description of the delete operator (11.4.1) + * assumes that the [[Delete]] method returns a value. However, + * the definition of the [[Delete]] operator (8.6.2.5) does not + * define a return value. Here we assume that the [[Delete]] + * method doesn't return a value. + */ + public static Object delete(Object obj, Object id, Context cx) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + String idStr = (id == null) ? "null" : id.toString(); + throw typeError2("msg.undef.prop.delete", toString(obj), idStr); + } + boolean result = deleteObjectElem(sobj, id, cx); + return wrapBoolean(result); + } + + /** + * Looks up a name in the scope chain and returns its value. + */ + public static Object name(Context cx, Scriptable scope, String name) + { + Scriptable parent = scope.getParentScope(); + if (parent == null) { + Object result = topScopeName(cx, scope, name); + if (result == Scriptable.NOT_FOUND) { + throw notFoundError(scope, name); + } + return result; + } + + return nameOrFunction(cx, scope, parent, name, false); + } + + private static Object nameOrFunction(Context cx, Scriptable scope, + Scriptable parentScope, String name, + boolean asFunctionCall) + { + Object result; + Scriptable thisObj = scope; // It is used only if asFunctionCall==true. + + XMLObject firstXMLObject = null; + for (;;) { + if (scope instanceof NativeWith) { + Scriptable withObj = scope.getPrototype(); + if (withObj instanceof XMLObject) { + XMLObject xmlObj = (XMLObject)withObj; + if (xmlObj.ecmaHas(cx, name)) { + // function this should be the target object of with + thisObj = xmlObj; + result = xmlObj.ecmaGet(cx, name); + break; + } + if (firstXMLObject == null) { + firstXMLObject = xmlObj; + } + } else { + result = ScriptableObject.getProperty(withObj, name); + if (result != Scriptable.NOT_FOUND) { + // function this should be the target object of with + thisObj = withObj; + break; + } + } + } else if (scope instanceof NativeCall) { + // NativeCall does not prototype chain and Scriptable.get + // can be called directly. + result = scope.get(name, scope); + if (result != Scriptable.NOT_FOUND) { + if (asFunctionCall) { + // ECMA 262 requires that this for nested funtions + // should be top scope + thisObj = ScriptableObject. + getTopLevelScope(parentScope); + } + break; + } + } else { + // Can happen if Rhino embedding decided that nested + // scopes are useful for what ever reasons. + result = ScriptableObject.getProperty(scope, name); + if (result != Scriptable.NOT_FOUND) { + thisObj = scope; + break; + } + } + scope = parentScope; + parentScope = parentScope.getParentScope(); + if (parentScope == null) { + result = topScopeName(cx, scope, name); + if (result == Scriptable.NOT_FOUND) { + if (firstXMLObject == null || asFunctionCall) { + throw notFoundError(scope, name); + } + // The name was not found, but we did find an XML + // object in the scope chain and we are looking for name, + // not function. The result should be an empty XMLList + // in name context. + result = firstXMLObject.ecmaGet(cx, name); + } + // For top scope thisObj for functions is always scope itself. + thisObj = scope; + break; + } + } + + if (asFunctionCall) { + if (!(result instanceof Callable)) { + throw notFunctionError(result, name); + } + storeScriptable(cx, thisObj); + } + + return result; + } + + private static Object topScopeName(Context cx, Scriptable scope, + String name) + { + if (cx.useDynamicScope) { + scope = checkDynamicScope(cx.topCallScope, scope); + } + return ScriptableObject.getProperty(scope, name); + } + + + /** + * Returns the object in the scope chain that has a given property. + * + * The order of evaluation of an assignment expression involves + * evaluating the lhs to a reference, evaluating the rhs, and then + * modifying the reference with the rhs value. This method is used + * to 'bind' the given name to an object containing that property + * so that the side effects of evaluating the rhs do not affect + * which property is modified. + * Typically used in conjunction with setName. + * + * See ECMA 10.1.4 + */ + public static Scriptable bind(Context cx, Scriptable scope, String id) + { + Scriptable firstXMLObject = null; + Scriptable parent = scope.getParentScope(); + childScopesChecks: if (parent != null) { + // Check for possibly nested "with" scopes first + while (scope instanceof NativeWith) { + Scriptable withObj = scope.getPrototype(); + if (withObj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)withObj; + if (xmlObject.ecmaHas(cx, id)) { + return xmlObject; + } + if (firstXMLObject == null) { + firstXMLObject = xmlObject; + } + } else { + if (ScriptableObject.hasProperty(withObj, id)) { + return withObj; + } + } + scope = parent; + parent = parent.getParentScope(); + if (parent == null) { + break childScopesChecks; + } + } + for (;;) { + if (ScriptableObject.hasProperty(scope, id)) { + return scope; + } + scope = parent; + parent = parent.getParentScope(); + if (parent == null) { + break childScopesChecks; + } + } + } + // scope here is top scope + if (cx.useDynamicScope) { + scope = checkDynamicScope(cx.topCallScope, scope); + } + if (ScriptableObject.hasProperty(scope, id)) { + return scope; + } + // Nothing was found, but since XML objects always bind + // return one if found + return firstXMLObject; + } + + public static Object setName(Scriptable bound, Object value, + Context cx, Scriptable scope, String id) + { + if (bound != null) { + if (bound instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)bound; + xmlObject.ecmaPut(cx, id, value); + } else { + ScriptableObject.putProperty(bound, id, value); + } + } else { + // "newname = 7;", where 'newname' has not yet + // been defined, creates a new property in the + // top scope unless strict mode is specified. + if (cx.hasFeature(Context.FEATURE_STRICT_MODE) || + cx.hasFeature(Context.FEATURE_STRICT_VARS)) + { + Context.reportWarning( + ScriptRuntime.getMessage1("msg.assn.create.strict", id)); + } + // Find the top scope by walking up the scope chain. + bound = ScriptableObject.getTopLevelScope(scope); + if (cx.useDynamicScope) { + bound = checkDynamicScope(cx.topCallScope, bound); + } + bound.put(id, bound, value); + } + return value; + } + + public static Object setConst(Scriptable bound, Object value, + Context cx, String id) + { + if (bound instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)bound; + xmlObject.ecmaPut(cx, id, value); + } else { + ScriptableObject.putConstProperty(bound, id, value); + } + return value; + } + + /** + * This is the enumeration needed by the for..in statement. + * + * See ECMA 12.6.3. + * + * IdEnumeration maintains a ObjToIntMap to make sure a given + * id is enumerated only once across multiple objects in a + * prototype chain. + * + * XXX - ECMA delete doesn't hide properties in the prototype, + * but js/ref does. This means that the js/ref for..in can + * avoid maintaining a hash table and instead perform lookups + * to see if a given property has already been enumerated. + * + */ + private static class IdEnumeration implements Serializable + { + private static final long serialVersionUID = 1L; + Scriptable obj; + Object[] ids; + int index; + ObjToIntMap used; + Object currentId; + int enumType; /* one of ENUM_INIT_KEYS, ENUM_INIT_VALUES, + ENUM_INIT_ARRAY */ + + // if true, integer ids will be returned as numbers rather than strings + boolean enumNumbers; + + Scriptable iterator; + } + + public static Scriptable toIterator(Context cx, Scriptable scope, + Scriptable obj, boolean keyOnly) + { + /*APPJET 1.6*//* + if (ScriptableObject.hasProperty(obj, + NativeIterator.ITERATOR_PROPERTY_NAME)) + { + Object v = ScriptableObject.getProperty(obj, + NativeIterator.ITERATOR_PROPERTY_NAME); + if (!(v instanceof Callable)) { + throw typeError0("msg.invalid.iterator"); + } + Callable f = (Callable) v; + Object[] args = new Object[] { keyOnly ? Boolean.TRUE + : Boolean.FALSE }; + v = f.call(cx, scope, obj, args); + if (!(v instanceof Scriptable)) { + throw typeError0("msg.iterator.primitive"); + } + return (Scriptable) v; + }*/ + return null; + } + + // for backwards compatibility with generated class files + public static Object enumInit(Object value, Context cx, boolean enumValues) + { + return enumInit(value, cx, enumValues ? ENUMERATE_VALUES + : ENUMERATE_KEYS); + } + + public static final int ENUMERATE_KEYS = 0; + public static final int ENUMERATE_VALUES = 1; + public static final int ENUMERATE_ARRAY = 2; + public static final int ENUMERATE_KEYS_NO_ITERATOR = 3; + public static final int ENUMERATE_VALUES_NO_ITERATOR = 4; + public static final int ENUMERATE_ARRAY_NO_ITERATOR = 5; + + public static Object enumInit(Object value, Context cx, int enumType) + { + IdEnumeration x = new IdEnumeration(); + x.obj = toObjectOrNull(cx, value); + if (x.obj == null) { + // null or undefined do not cause errors but rather lead to empty + // "for in" loop + return x; + } + x.enumType = enumType; + x.iterator = null; + if (enumType != ENUMERATE_KEYS_NO_ITERATOR && + enumType != ENUMERATE_VALUES_NO_ITERATOR && + enumType != ENUMERATE_ARRAY_NO_ITERATOR) + { + x.iterator = toIterator(cx, x.obj.getParentScope(), x.obj, true); + } + if (x.iterator == null) { + // enumInit should read all initial ids before returning + // or "for (a.i in a)" would wrongly enumerate i in a as well + enumChangeObject(x); + } + + return x; + } + + public static void setEnumNumbers(Object enumObj, boolean enumNumbers) { + ((IdEnumeration)enumObj).enumNumbers = enumNumbers; + } + + public static Boolean enumNext(Object enumObj) + { + IdEnumeration x = (IdEnumeration)enumObj; + if (x.iterator != null) { + Object v = ScriptableObject.getProperty(x.iterator, "next"); + if (!(v instanceof Callable)) + return Boolean.FALSE; + Callable f = (Callable) v; + Context cx = Context.enter(); + try { + x.currentId = f.call(cx, x.iterator.getParentScope(), + x.iterator, emptyArgs); + return Boolean.TRUE; + } catch (JavaScriptException e) { + if (e.getValue() instanceof NativeIterator.StopIteration) { + return Boolean.FALSE; + } + throw e; + } finally { + Context.exit(); + } + } + for (;;) { + if (x.obj == null) { + return Boolean.FALSE; + } + if (x.index == x.ids.length) { + x.obj = x.obj.getPrototype(); + enumChangeObject(x); + continue; + } + Object id = x.ids[x.index++]; + if (x.used != null && x.used.has(id)) { + continue; + } + if (id instanceof String) { + String strId = (String)id; + if (!x.obj.has(strId, x.obj)) + continue; // must have been deleted + x.currentId = strId; + } else { + int intId = ((Number)id).intValue(); + if (!x.obj.has(intId, x.obj)) + continue; // must have been deleted + x.currentId = x.enumNumbers ? (Object) (new Integer(intId)) + : String.valueOf(intId); + } + return Boolean.TRUE; + } + } + + public static Object enumId(Object enumObj, Context cx) + { + IdEnumeration x = (IdEnumeration)enumObj; + if (x.iterator != null) { + return x.currentId; + } + switch (x.enumType) { + case ENUMERATE_KEYS: + case ENUMERATE_KEYS_NO_ITERATOR: + return x.currentId; + case ENUMERATE_VALUES: + case ENUMERATE_VALUES_NO_ITERATOR: + return enumValue(enumObj, cx); + case ENUMERATE_ARRAY: + case ENUMERATE_ARRAY_NO_ITERATOR: + Object[] elements = { x.currentId, enumValue(enumObj, cx) }; + return cx.newArray(x.obj.getParentScope(), elements); + default: + throw Kit.codeBug(); + } + } + + public static Object enumValue(Object enumObj, Context cx) { + IdEnumeration x = (IdEnumeration)enumObj; + + Object result; + + String s = toStringIdOrIndex(cx, x.currentId); + if (s == null) { + int index = lastIndexResult(cx); + result = x.obj.get(index, x.obj); + } else { + result = x.obj.get(s, x.obj); + } + + return result; + } + + private static void enumChangeObject(IdEnumeration x) + { + Object[] ids = null; + while (x.obj != null) { + ids = x.obj.getIds(); + if (ids.length != 0) { + break; + } + x.obj = x.obj.getPrototype(); + } + if (x.obj != null && x.ids != null) { + Object[] previous = x.ids; + int L = previous.length; + if (x.used == null) { + x.used = new ObjToIntMap(L); + } + for (int i = 0; i != L; ++i) { + x.used.intern(previous[i]); + } + } + x.ids = ids; + x.index = 0; + } + + /** + * Prepare for calling name(...): return function corresponding to + * name and make current top scope available + * as ScriptRuntime.lastStoredScriptable() for consumption as thisObj. + * The caller must call ScriptRuntime.lastStoredScriptable() immediately + * after calling this method. + */ + public static Callable getNameFunctionAndThis(String name, + Context cx, + Scriptable scope) + { + Scriptable parent = scope.getParentScope(); + if (parent == null) { + Object result = topScopeName(cx, scope, name); + if (!(result instanceof Callable)) { + if (result == Scriptable.NOT_FOUND) { + throw notFoundError(scope, name); + } else { + throw notFunctionError(result, name); + } + } + // Top scope is not NativeWith or NativeCall => thisObj == scope + Scriptable thisObj = scope; + storeScriptable(cx, thisObj); + return (Callable)result; + } + + // name will call storeScriptable(cx, thisObj); + return (Callable)nameOrFunction(cx, scope, parent, name, true); + } + + /** + * Prepare for calling obj[id](...): return function corresponding to + * obj[id] and make obj properly converted to Scriptable available + * as ScriptRuntime.lastStoredScriptable() for consumption as thisObj. + * The caller must call ScriptRuntime.lastStoredScriptable() immediately + * after calling this method. + */ + public static Callable getElemFunctionAndThis(Object obj, + Object elem, + Context cx) + { + String s = toStringIdOrIndex(cx, elem); + if (s != null) { + return getPropFunctionAndThis(obj, s, cx); + } + int index = lastIndexResult(cx); + + Scriptable thisObj = toObjectOrNull(cx, obj); + if (thisObj == null) { + throw undefCallError(obj, String.valueOf(index)); + } + + Object value; + for (;;) { + // Ignore XML lookup as requred by ECMA 357, 11.2.2.1 + value = ScriptableObject.getProperty(thisObj, index); + if (value != Scriptable.NOT_FOUND) { + break; + } + if (!(thisObj instanceof XMLObject)) { + break; + } + XMLObject xmlObject = (XMLObject)thisObj; + Scriptable extra = xmlObject.getExtraMethodSource(cx); + if (extra == null) { + break; + } + thisObj = extra; + } + if (!(value instanceof Callable)) { + throw notFunctionError(value, elem); + } + + storeScriptable(cx, thisObj); + return (Callable)value; + } + + /** + * Prepare for calling obj.property(...): return function corresponding to + * obj.property and make obj properly converted to Scriptable available + * as ScriptRuntime.lastStoredScriptable() for consumption as thisObj. + * The caller must call ScriptRuntime.lastStoredScriptable() immediately + * after calling this method. + */ + public static Callable getPropFunctionAndThis(Object obj, + String property, + Context cx) + { + Scriptable thisObj = toObjectOrNull(cx, obj); + if (thisObj == null) { + throw undefCallError(obj, property); + } + + Object value; + for (;;) { + // Ignore XML lookup as required by ECMA 357, 11.2.2.1 + value = ScriptableObject.getProperty(thisObj, property); + if (value != Scriptable.NOT_FOUND) { + break; + } + if (!(thisObj instanceof XMLObject)) { + break; + } + XMLObject xmlObject = (XMLObject)thisObj; + Scriptable extra = xmlObject.getExtraMethodSource(cx); + if (extra == null) { + break; + } + thisObj = extra; + } + + if (!(value instanceof Callable)) { + Object noSuchMethod = ScriptableObject.getProperty(thisObj, "__noSuchMethod__"); + if (noSuchMethod instanceof Callable) + value = new NoSuchMethodShim((Callable)noSuchMethod, property); + else + throw notFunctionError(thisObj, value, property); + } + + storeScriptable(cx, thisObj); + return (Callable)value; + } + + /** + * Prepare for calling <expression>(...): return function corresponding to + * <expression> and make parent scope of the function available + * as ScriptRuntime.lastStoredScriptable() for consumption as thisObj. + * The caller must call ScriptRuntime.lastStoredScriptable() immediately + * after calling this method. + */ + public static Callable getValueFunctionAndThis(Object value, Context cx) + { + if (!(value instanceof Callable)) { + throw notFunctionError(value); + } + + Callable f = (Callable)value; + Scriptable thisObj = null; + if (f instanceof Scriptable) { + thisObj = ((Scriptable)f).getParentScope(); + } + if (thisObj == null) { + if (cx.topCallScope == null) throw new IllegalStateException(); + thisObj = cx.topCallScope; + } + if (thisObj.getParentScope() != null) { + if (thisObj instanceof NativeWith) { + // functions defined inside with should have with target + // as their thisObj + } else if (thisObj instanceof NativeCall) { + // nested functions should have top scope as their thisObj + thisObj = ScriptableObject.getTopLevelScope(thisObj); + } + } + storeScriptable(cx, thisObj); + return f; + } + + /** + * Perform function call in reference context. Should always + * return value that can be passed to + * {@link #refGet(Ref, Context)} or {@link #refSet(Ref, Object, Context)} + * arbitrary number of times. + * The args array reference should not be stored in any object that is + * can be GC-reachable after this method returns. If this is necessary, + * store args.clone(), not args array itself. + */ + public static Ref callRef(Callable function, Scriptable thisObj, + Object[] args, Context cx) + { + if (function instanceof RefCallable) { + RefCallable rfunction = (RefCallable)function; + Ref ref = rfunction.refCall(cx, thisObj, args); + if (ref == null) { + throw new IllegalStateException(rfunction.getClass().getName()+".refCall() returned null"); + } + return ref; + } + // No runtime support for now + String msg = getMessage1("msg.no.ref.from.function", + toString(function)); + throw constructError("ReferenceError", msg); + } + + /** + * Operator new. + * + * See ECMA 11.2.2 + */ + public static Scriptable newObject(Object fun, Context cx, + Scriptable scope, Object[] args) + { + if (!(fun instanceof Function)) { + throw notFunctionError(fun); + } + Function function = (Function)fun; + return function.construct(cx, scope, args); + } + + public static Object callSpecial(Context cx, Callable fun, + Scriptable thisObj, + Object[] args, Scriptable scope, + Scriptable callerThis, int callType, + String filename, int lineNumber) + { + if (callType == Node.SPECIALCALL_EVAL) { + if (NativeGlobal.isEvalFunction(fun)) { + return evalSpecial(cx, scope, callerThis, args, + filename, lineNumber); + } + } else if (callType == Node.SPECIALCALL_WITH) { + if (NativeWith.isWithFunction(fun)) { + throw Context.reportRuntimeError1("msg.only.from.new", + "With"); + } + } else { + throw Kit.codeBug(); + } + + return fun.call(cx, scope, thisObj, args); + } + + public static Object newSpecial(Context cx, Object fun, + Object[] args, Scriptable scope, + int callType) + { + if (callType == Node.SPECIALCALL_EVAL) { + if (NativeGlobal.isEvalFunction(fun)) { + throw typeError1("msg.not.ctor", "eval"); + } + } else if (callType == Node.SPECIALCALL_WITH) { + if (NativeWith.isWithFunction(fun)) { + return NativeWith.newWithSpecial(cx, scope, args); + } + } else { + throw Kit.codeBug(); + } + + return newObject(fun, cx, scope, args); + } + + /** + * Function.prototype.apply and Function.prototype.call + * + * See Ecma 15.3.4.[34] + */ + public static Object applyOrCall(boolean isApply, + Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + int L = args.length; + Callable function = getCallable(thisObj); + + Scriptable callThis = null; + if (L != 0) { + callThis = toObjectOrNull(cx, args[0]); + } + if (callThis == null) { + // This covers the case of args[0] == (null|undefined) as well. + callThis = getTopCallScope(cx); + } + + Object[] callArgs; + if (isApply) { + // Follow Ecma 15.3.4.3 + callArgs = L <= 1 ? ScriptRuntime.emptyArgs : + getApplyArguments(cx, args[1]); + } else { + // Follow Ecma 15.3.4.4 + if (L <= 1) { + callArgs = ScriptRuntime.emptyArgs; + } else { + callArgs = new Object[L - 1]; + System.arraycopy(args, 1, callArgs, 0, L - 1); + } + } + + return function.call(cx, scope, callThis, callArgs); + } + + static Object[] getApplyArguments(Context cx, Object arg1) + { + if (arg1 == null || arg1 == Undefined.instance) { + return ScriptRuntime.emptyArgs; + } else if (arg1 instanceof NativeArray || arg1 instanceof Arguments) { + return cx.getElements((Scriptable) arg1); + } else { + throw ScriptRuntime.typeError0("msg.arg.isnt.array"); + } + } + + static Callable getCallable(Scriptable thisObj) + { + Callable function; + if (thisObj instanceof Callable) { + function = (Callable)thisObj; + } else { + Object value = thisObj.getDefaultValue(ScriptRuntime.FunctionClass); + if (!(value instanceof Callable)) { + throw ScriptRuntime.notFunctionError(value, thisObj); + } + function = (Callable)value; + } + return function; + } + + /** + * The eval function property of the global object. + * + * See ECMA 15.1.2.1 + */ + public static Object evalSpecial(Context cx, Scriptable scope, + Object thisArg, Object[] args, + String filename, int lineNumber) + { + if (args.length < 1) + return Undefined.instance; + Object x = args[0]; + if (!(x instanceof String)) { + if (cx.hasFeature(Context.FEATURE_STRICT_MODE) || + cx.hasFeature(Context.FEATURE_STRICT_EVAL)) + { + throw Context.reportRuntimeError0("msg.eval.nonstring.strict"); + } + String message = ScriptRuntime.getMessage0("msg.eval.nonstring"); + Context.reportWarning(message); + return x; + } + if (filename == null) { + int[] linep = new int[1]; + filename = Context.getSourcePositionFromStack(linep); + if (filename != null) { + lineNumber = linep[0]; + } else { + filename = ""; + } + } + String sourceName = ScriptRuntime. + makeUrlForGeneratedScript(true, filename, lineNumber); + + ErrorReporter reporter; + reporter = DefaultErrorReporter.forEval(cx.getErrorReporter()); + + Evaluator evaluator = Context.createInterpreter(); + if (evaluator == null) { + throw new JavaScriptException("Interpreter not present", + filename, lineNumber); + } + + // Compile with explicit interpreter instance to force interpreter + // mode. + Script script = cx.compileString((String)x, evaluator, + reporter, sourceName, 1, null); + evaluator.setEvalScriptFlag(script); + Callable c = (Callable)script; + return c.call(cx, scope, (Scriptable)thisArg, ScriptRuntime.emptyArgs); + } + + /** + * The typeof operator + */ + public static String typeof(Object value) + { + if (value == null) + return "object"; + if (value == Undefined.instance) + return "undefined"; + if (value instanceof Scriptable) + { + if (value instanceof ScriptableObject && + ((ScriptableObject)value).avoidObjectDetection()) + { + return "undefined"; + } + if (value instanceof XMLObject) + return "xml"; + return (value instanceof Callable) ? "function" : "object"; + } + if (value instanceof String) + return "string"; + if (value instanceof Number) + return "number"; + if (value instanceof Boolean) + return "boolean"; + throw errorWithClassName("msg.invalid.type", value); + } + + /** + * The typeof operator that correctly handles the undefined case + */ + public static String typeofName(Scriptable scope, String id) + { + Context cx = Context.getContext(); + Scriptable val = bind(cx, scope, id); + if (val == null) + return "undefined"; + return typeof(getObjectProp(val, id, cx)); + } + + // neg: + // implement the '-' operator inline in the caller + // as "-toNumber(val)" + + // not: + // implement the '!' operator inline in the caller + // as "!toBoolean(val)" + + // bitnot: + // implement the '~' operator inline in the caller + // as "~toInt32(val)" + + public static Object add(Object val1, Object val2, Context cx) + { + if(val1 instanceof Number && val2 instanceof Number) { + return wrapNumber(((Number)val1).doubleValue() + + ((Number)val2).doubleValue()); + } + if (val1 instanceof XMLObject) { + Object test = ((XMLObject)val1).addValues(cx, true, val2); + if (test != Scriptable.NOT_FOUND) { + return test; + } + } + if (val2 instanceof XMLObject) { + Object test = ((XMLObject)val2).addValues(cx, false, val1); + if (test != Scriptable.NOT_FOUND) { + return test; + } + } + if (val1 instanceof Scriptable) + val1 = ((Scriptable) val1).getDefaultValue(null); + if (val2 instanceof Scriptable) + val2 = ((Scriptable) val2).getDefaultValue(null); + if (!(val1 instanceof String) && !(val2 instanceof String)) + if ((val1 instanceof Number) && (val2 instanceof Number)) + return wrapNumber(((Number)val1).doubleValue() + + ((Number)val2).doubleValue()); + else + return wrapNumber(toNumber(val1) + toNumber(val2)); + return toString(val1).concat(toString(val2)); + } + + public static String add(String val1, Object val2) { + return val1.concat(toString(val2)); + } + + public static String add(Object val1, String val2) { + return toString(val1).concat(val2); + } + + /** + * @deprecated The method is only present for compatibility. + */ + public static Object nameIncrDecr(Scriptable scopeChain, String id, + int incrDecrMask) + { + return nameIncrDecr(scopeChain, id, Context.getContext(), incrDecrMask); + } + + public static Object nameIncrDecr(Scriptable scopeChain, String id, + Context cx, int incrDecrMask) + { + Scriptable target; + Object value; + search: { + do { + if (cx.useDynamicScope && scopeChain.getParentScope() == null) { + scopeChain = checkDynamicScope(cx.topCallScope, scopeChain); + } + target = scopeChain; + do { + value = target.get(id, scopeChain); + if (value != Scriptable.NOT_FOUND) { + break search; + } + target = target.getPrototype(); + } while (target != null); + scopeChain = scopeChain.getParentScope(); + } while (scopeChain != null); + throw notFoundError(scopeChain, id); + } + return doScriptableIncrDecr(target, id, scopeChain, value, + incrDecrMask); + } + + public static Object propIncrDecr(Object obj, String id, + Context cx, int incrDecrMask) + { + Scriptable start = toObjectOrNull(cx, obj); + if (start == null) { + throw undefReadError(obj, id); + } + + Scriptable target = start; + Object value; + search: { + do { + value = target.get(id, start); + if (value != Scriptable.NOT_FOUND) { + break search; + } + target = target.getPrototype(); + } while (target != null); + start.put(id, start, NaNobj); + return NaNobj; + } + return doScriptableIncrDecr(target, id, start, value, + incrDecrMask); + } + + private static Object doScriptableIncrDecr(Scriptable target, + String id, + Scriptable protoChainStart, + Object value, + int incrDecrMask) + { + boolean post = ((incrDecrMask & Node.POST_FLAG) != 0); + double number; + if (value instanceof Number) { + number = ((Number)value).doubleValue(); + } else { + number = toNumber(value); + if (post) { + // convert result to number + value = wrapNumber(number); + } + } + if ((incrDecrMask & Node.DECR_FLAG) == 0) { + ++number; + } else { + --number; + } + Number result = wrapNumber(number); + target.put(id, protoChainStart, result); + if (post) { + return value; + } else { + return result; + } + } + + public static Object elemIncrDecr(Object obj, Object index, + Context cx, int incrDecrMask) + { + Object value = getObjectElem(obj, index, cx); + boolean post = ((incrDecrMask & Node.POST_FLAG) != 0); + double number; + if (value instanceof Number) { + number = ((Number)value).doubleValue(); + } else { + number = toNumber(value); + if (post) { + // convert result to number + value = wrapNumber(number); + } + } + if ((incrDecrMask & Node.DECR_FLAG) == 0) { + ++number; + } else { + --number; + } + Number result = wrapNumber(number); + setObjectElem(obj, index, result, cx); + if (post) { + return value; + } else { + return result; + } + } + + public static Object refIncrDecr(Ref ref, Context cx, int incrDecrMask) + { + Object value = ref.get(cx); + boolean post = ((incrDecrMask & Node.POST_FLAG) != 0); + double number; + if (value instanceof Number) { + number = ((Number)value).doubleValue(); + } else { + number = toNumber(value); + if (post) { + // convert result to number + value = wrapNumber(number); + } + } + if ((incrDecrMask & Node.DECR_FLAG) == 0) { + ++number; + } else { + --number; + } + Number result = wrapNumber(number); + ref.set(cx, result); + if (post) { + return value; + } else { + return result; + } + } + + private static Object toPrimitive(Object val) + { + if (!(val instanceof Scriptable)) { + return val; + } + Scriptable s = (Scriptable)val; + Object result = s.getDefaultValue(null); + if (result instanceof Scriptable) + throw typeError0("msg.bad.default.value"); + return result; + } + + /** + * Equality + * + * See ECMA 11.9 + */ + public static boolean eq(Object x, Object y) + { + if (x == null || x == Undefined.instance) { + if (y == null || y == Undefined.instance) { + return true; + } + if (y instanceof ScriptableObject) { + Object test = ((ScriptableObject)y).equivalentValues(x); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + return false; + } else if (x instanceof Number) { + return eqNumber(((Number)x).doubleValue(), y); + } else if (x instanceof String) { + return eqString((String)x, y); + } else if (x instanceof Boolean) { + boolean b = ((Boolean)x).booleanValue(); + if (y instanceof Boolean) { + return b == ((Boolean)y).booleanValue(); + } + if (y instanceof ScriptableObject) { + Object test = ((ScriptableObject)y).equivalentValues(x); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + return eqNumber(b ? 1.0 : 0.0, y); + } else if (x instanceof Scriptable) { + if (y instanceof Scriptable) { + if (x == y) { + return true; + } + if (x instanceof ScriptableObject) { + Object test = ((ScriptableObject)x).equivalentValues(y); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + if (y instanceof ScriptableObject) { + Object test = ((ScriptableObject)y).equivalentValues(x); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + if (x instanceof Wrapper && y instanceof Wrapper) { + // See bug 413838. Effectively an extension to ECMA for + // the LiveConnect case. + Object unwrappedX = ((Wrapper)x).unwrap(); + Object unwrappedY = ((Wrapper)y).unwrap(); + return unwrappedX == unwrappedY || + (isPrimitive(unwrappedX) && + isPrimitive(unwrappedY) && + eq(unwrappedX, unwrappedY)); + } + return false; + } else if (y instanceof Boolean) { + if (x instanceof ScriptableObject) { + Object test = ((ScriptableObject)x).equivalentValues(y); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + double d = ((Boolean)y).booleanValue() ? 1.0 : 0.0; + return eqNumber(d, x); + } else if (y instanceof Number) { + return eqNumber(((Number)y).doubleValue(), x); + } else if (y instanceof String) { + return eqString((String)y, x); + } + // covers the case when y == Undefined.instance as well + return false; + } else { + warnAboutNonJSObject(x); + return x == y; + } + } + + private static boolean isPrimitive(Object obj) { + return (obj instanceof Number) || (obj instanceof String) || + (obj instanceof Boolean); + } + + static boolean eqNumber(double x, Object y) + { + for (;;) { + if (y == null || y == Undefined.instance) { + return false; + } else if (y instanceof Number) { + return x == ((Number)y).doubleValue(); + } else if (y instanceof String) { + return x == toNumber(y); + } else if (y instanceof Boolean) { + return x == (((Boolean)y).booleanValue() ? 1.0 : +0.0); + } else if (y instanceof Scriptable) { + if (y instanceof ScriptableObject) { + Object xval = wrapNumber(x); + Object test = ((ScriptableObject)y).equivalentValues(xval); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + y = toPrimitive(y); + } else { + warnAboutNonJSObject(y); + return false; + } + } + } + + private static boolean eqString(String x, Object y) + { + for (;;) { + if (y == null || y == Undefined.instance) { + return false; + } else if (y instanceof String) { + return x.equals(y); + } else if (y instanceof Number) { + return toNumber(x) == ((Number)y).doubleValue(); + } else if (y instanceof Boolean) { + return toNumber(x) == (((Boolean)y).booleanValue() ? 1.0 : 0.0); + } else if (y instanceof Scriptable) { + if (y instanceof ScriptableObject) { + Object test = ((ScriptableObject)y).equivalentValues(x); + if (test != Scriptable.NOT_FOUND) { + return ((Boolean)test).booleanValue(); + } + } + y = toPrimitive(y); + continue; + } else { + warnAboutNonJSObject(y); + return false; + } + } + } + public static boolean shallowEq(Object x, Object y) + { + if (x == y) { + if (!(x instanceof Number)) { + return true; + } + // NaN check + double d = ((Number)x).doubleValue(); + return d == d; + } + if (x == null || x == Undefined.instance) { + return false; + } else if (x instanceof Number) { + if (y instanceof Number) { + return ((Number)x).doubleValue() == ((Number)y).doubleValue(); + } + } else if (x instanceof String) { + if (y instanceof String) { + return x.equals(y); + } + } else if (x instanceof Boolean) { + if (y instanceof Boolean) { + return x.equals(y); + } + } else if (x instanceof Scriptable) { + if (x instanceof Wrapper && y instanceof Wrapper) { + return ((Wrapper)x).unwrap() == ((Wrapper)y).unwrap(); + } + } else { + warnAboutNonJSObject(x); + return x == y; + } + return false; + } + + /** + * The instanceof operator. + * + * @return a instanceof b + */ + public static boolean instanceOf(Object a, Object b, Context cx) + { + // Check RHS is an object + if (! (b instanceof Scriptable)) { + throw typeError0("msg.instanceof.not.object"); + } + + // for primitive values on LHS, return false + // XXX we may want to change this so that + // 5 instanceof Number == true + if (! (a instanceof Scriptable)) + return false; + + return ((Scriptable)b).hasInstance((Scriptable)a); + } + + /** + * Delegates to + * + * @return true iff rhs appears in lhs' proto chain + */ + public static boolean jsDelegatesTo(Scriptable lhs, Scriptable rhs) { + Scriptable proto = lhs.getPrototype(); + + while (proto != null) { + if (proto.equals(rhs)) return true; + proto = proto.getPrototype(); + } + + return false; + } + + /** + * The in operator. + * + * This is a new JS 1.3 language feature. The in operator mirrors + * the operation of the for .. in construct, and tests whether the + * rhs has the property given by the lhs. It is different from the + * for .. in construct in that: + * <BR> - it doesn't perform ToObject on the right hand side + * <BR> - it returns true for DontEnum properties. + * @param a the left hand operand + * @param b the right hand operand + * + * @return true if property name or element number a is a property of b + */ + public static boolean in(Object a, Object b, Context cx) + { + if (!(b instanceof Scriptable)) { + throw typeError0("msg.instanceof.not.object"); + } + + return hasObjectElem((Scriptable)b, a, cx); + } + + public static boolean cmp_LT(Object val1, Object val2) + { + double d1, d2; + if (val1 instanceof Number && val2 instanceof Number) { + d1 = ((Number)val1).doubleValue(); + d2 = ((Number)val2).doubleValue(); + } else { + if (val1 instanceof Scriptable) + val1 = ((Scriptable) val1).getDefaultValue(NumberClass); + if (val2 instanceof Scriptable) + val2 = ((Scriptable) val2).getDefaultValue(NumberClass); + if (val1 instanceof String && val2 instanceof String) { + return ((String)val1).compareTo((String)val2) < 0; + } + d1 = toNumber(val1); + d2 = toNumber(val2); + } + return d1 < d2; + } + + public static boolean cmp_LE(Object val1, Object val2) + { + double d1, d2; + if (val1 instanceof Number && val2 instanceof Number) { + d1 = ((Number)val1).doubleValue(); + d2 = ((Number)val2).doubleValue(); + } else { + if (val1 instanceof Scriptable) + val1 = ((Scriptable) val1).getDefaultValue(NumberClass); + if (val2 instanceof Scriptable) + val2 = ((Scriptable) val2).getDefaultValue(NumberClass); + if (val1 instanceof String && val2 instanceof String) { + return ((String)val1).compareTo((String)val2) <= 0; + } + d1 = toNumber(val1); + d2 = toNumber(val2); + } + return d1 <= d2; + } + + // ------------------ + // Statements + // ------------------ + + public static ScriptableObject getGlobal(Context cx) { + final String GLOBAL_CLASS = "org.mozilla.javascript.tools.shell.Global"; + Class globalClass = Kit.classOrNull(GLOBAL_CLASS); + if (globalClass != null) { + try { + Class[] parm = { ScriptRuntime.ContextClass }; + Constructor globalClassCtor = globalClass.getConstructor(parm); + Object[] arg = { cx }; + return (ScriptableObject) globalClassCtor.newInstance(arg); + } catch (Exception e) { + // fall through... + } + } + return new ImporterTopLevel(cx); + } + + public static boolean hasTopCall(Context cx) + { + return (cx.topCallScope != null); + } + + public static Scriptable getTopCallScope(Context cx) + { + Scriptable scope = cx.topCallScope; + if (scope == null) { + throw new IllegalStateException(); + } + return scope; + } + + public static Object doTopCall(Callable callable, + Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (scope == null) throw new IllegalArgumentException(); + if (cx.topCallScope != null) throw new IllegalStateException(); + + Object result; + cx.topCallScope = ScriptableObject.getTopLevelScope(scope); + cx.useDynamicScope = cx.hasFeature(Context.FEATURE_DYNAMIC_SCOPE); + ContextFactory f = cx.getFactory(); + try { + result = f.doTopCall(callable, cx, scope, thisObj, args); + } finally { + cx.topCallScope = null; + // Cleanup cached references + cx.cachedXMLLib = null; + + if (cx.currentActivationCall != null) { + // Function should always call exitActivationFunction + // if it creates activation record + throw new IllegalStateException(); + } + } + return result; + } + + /** + * Return <tt>possibleDynamicScope</tt> if <tt>staticTopScope</tt> + * is present on its prototype chain and return <tt>staticTopScope</tt> + * otherwise. + * Should only be called when <tt>staticTopScope</tt> is top scope. + */ + static Scriptable checkDynamicScope(Scriptable possibleDynamicScope, + Scriptable staticTopScope) + { + // Return cx.topCallScope if scope + if (possibleDynamicScope == staticTopScope) { + return possibleDynamicScope; + } + Scriptable proto = possibleDynamicScope; + for (;;) { + proto = proto.getPrototype(); + if (proto == staticTopScope) { + return possibleDynamicScope; + } + if (proto == null) { + return staticTopScope; + } + } + } + + public static void addInstructionCount(Context cx, int instructionsToAdd) + { + cx.instructionCount += instructionsToAdd; + if (cx.instructionCount > cx.instructionThreshold) + { + cx.observeInstructionCount(cx.instructionCount); + cx.instructionCount = 0; + } + } + + public static void initScript(NativeFunction funObj, Scriptable thisObj, + Context cx, Scriptable scope, + boolean evalScript) + { + if (cx.topCallScope == null) + throw new IllegalStateException(); + + int varCount = funObj.getParamAndVarCount(); + if (varCount != 0) { + + Scriptable varScope = scope; + // Never define any variables from var statements inside with + // object. See bug 38590. + while (varScope instanceof NativeWith) { + varScope = varScope.getParentScope(); + } + + for (int i = varCount; i-- != 0;) { + String name = funObj.getParamOrVarName(i); + boolean isConst = funObj.getParamOrVarConst(i); + // Don't overwrite existing def if already defined in object + // or prototypes of object. + if (!ScriptableObject.hasProperty(scope, name)) { + if (!evalScript) { + // Global var definitions are supposed to be DONTDELETE + if (isConst) + ScriptableObject.defineConstProperty(varScope, name); + else + ScriptableObject.defineProperty( + varScope, name, Undefined.instance, + ScriptableObject.PERMANENT); + } else { + varScope.put(name, varScope, Undefined.instance); + } + } else { + ScriptableObject.redefineProperty(scope, name, isConst); + } + } + } + } + + public static Scriptable createFunctionActivation(NativeFunction funObj, + Scriptable scope, + Object[] args) + { + return new NativeCall(funObj, scope, args); + } + + + public static void enterActivationFunction(Context cx, + Scriptable scope) + { + if (cx.topCallScope == null) + throw new IllegalStateException(); + NativeCall call = (NativeCall)scope; + call.parentActivationCall = cx.currentActivationCall; + cx.currentActivationCall = call; + } + + public static void exitActivationFunction(Context cx) + { + NativeCall call = cx.currentActivationCall; + cx.currentActivationCall = call.parentActivationCall; + call.parentActivationCall = null; + } + + static NativeCall findFunctionActivation(Context cx, Function f) + { + NativeCall call = cx.currentActivationCall; + while (call != null) { + if (call.function == f) + return call; + call = call.parentActivationCall; + } + return null; + } + + public static Scriptable newCatchScope(Throwable t, + Scriptable lastCatchScope, + String exceptionName, + Context cx, Scriptable scope) + { + Object obj; + boolean cacheObj; + + getObj: + if (t instanceof JavaScriptException) { + cacheObj = false; + obj = ((JavaScriptException)t).getValue(); + } else { + cacheObj = true; + + // Create wrapper object unless it was associated with + // the previous scope object + + if (lastCatchScope != null) { + NativeObject last = (NativeObject)lastCatchScope; + obj = last.getAssociatedValue(t); + if (obj == null) Kit.codeBug(); + break getObj; + } + + RhinoException re; + String errorName; + String errorMsg; + Throwable javaException = null; + + if (t instanceof EcmaError) { + EcmaError ee = (EcmaError)t; + re = ee; + errorName = ee.getName(); + errorMsg = ee.getErrorMessage(); + } else if (t instanceof WrappedException) { + WrappedException we = (WrappedException)t; + re = we; + javaException = we.getWrappedException(); + errorName = "JavaException"; + errorMsg = javaException.getClass().getName() + +": "+javaException.getMessage(); + } else if (t instanceof EvaluatorException) { + // Pure evaluator exception, nor WrappedException instance + EvaluatorException ee = (EvaluatorException)t; + re = ee; + errorName = "InternalError"; + errorMsg = ee.getMessage(); + } else if (cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS)) { + // With FEATURE_ENHANCED_JAVA_ACCESS, scripts can catch + // all exception types + re = new WrappedException(t); + errorName = "JavaException"; + errorMsg = t.toString(); + } else { + // Script can catch only instances of JavaScriptException, + // EcmaError and EvaluatorException + throw Kit.codeBug(); + } + + String sourceUri = re.sourceName(); + if (sourceUri == null) { + sourceUri = ""; + } + int line = re.lineNumber(); + Object args[]; + if (line > 0) { + args = new Object[] { errorMsg, sourceUri, new Integer(line) }; + } else { + args = new Object[] { errorMsg, sourceUri }; + } + + Scriptable errorObject = cx.newObject(scope, errorName, args); + ScriptableObject.putProperty(errorObject, "name", errorName); + + if (javaException != null) { + Object wrap = cx.getWrapFactory().wrap(cx, scope, javaException, + null); + ScriptableObject.defineProperty( + errorObject, "javaException", wrap, + ScriptableObject.PERMANENT | ScriptableObject.READONLY); + } + Object wrap = cx.getWrapFactory().wrap(cx, scope, re, null); + ScriptableObject.defineProperty( + errorObject, "rhinoException", wrap, + ScriptableObject.PERMANENT | ScriptableObject.READONLY); + + obj = errorObject; + } + + NativeObject catchScopeObject = new NativeObject(); + // See ECMA 12.4 + catchScopeObject.defineProperty( + exceptionName, obj, ScriptableObject.PERMANENT); + + // Add special Rhino object __exception__ defined in the catch + // scope that can be used to retrieve the Java exception associated + // with the JavaScript exception (to get stack trace info, etc.) + /*APPJET NOJAVA*/ + /*catchScopeObject.defineProperty( + "__exception__", Context.javaToJS(t, scope), + ScriptableObject.PERMANENT|ScriptableObject.DONTENUM);*/ + + if (cacheObj) { + catchScopeObject.associateValue(t, obj); + } + return catchScopeObject; + } + + public static Scriptable enterWith(Object obj, Context cx, + Scriptable scope) + { + Scriptable sobj = toObjectOrNull(cx, obj); + if (sobj == null) { + throw typeError1("msg.undef.with", toString(obj)); + } + if (sobj instanceof XMLObject) { + XMLObject xmlObject = (XMLObject)sobj; + return xmlObject.enterWith(scope); + } + return new NativeWith(scope, sobj); + } + + public static Scriptable leaveWith(Scriptable scope) + { + NativeWith nw = (NativeWith)scope; + return nw.getParentScope(); + } + + public static Scriptable enterDotQuery(Object value, Scriptable scope) + { + if (!(value instanceof XMLObject)) { + throw notXmlError(value); + } + XMLObject object = (XMLObject)value; + return object.enterDotQuery(scope); + } + + public static Object updateDotQuery(boolean value, Scriptable scope) + { + // Return null to continue looping + NativeWith nw = (NativeWith)scope; + return nw.updateDotQuery(value); + } + + public static Scriptable leaveDotQuery(Scriptable scope) + { + NativeWith nw = (NativeWith)scope; + return nw.getParentScope(); + } + + public static void setFunctionProtoAndParent(BaseFunction fn, + Scriptable scope) + { + fn.setParentScope(scope); + fn.setPrototype(ScriptableObject.getFunctionPrototype(scope)); + } + + public static void setObjectProtoAndParent(ScriptableObject object, + Scriptable scope) + { + // Compared with function it always sets the scope to top scope + scope = ScriptableObject.getVeryTopLevelScope(scope); // APPJET + object.setParentScope(scope); + Scriptable proto + = ScriptableObject.getClassPrototype(scope, object.getClassName()); + object.setPrototype(proto); + } + + public static void initFunction(Context cx, Scriptable scope, + NativeFunction function, int type, + boolean fromEvalCode) + { + if (type == FunctionNode.FUNCTION_STATEMENT) { + String name = function.getFunctionName(); + if (name != null && name.length() != 0) { + if (!fromEvalCode) { + // ECMA specifies that functions defined in global and + // function scope outside eval should have DONTDELETE set. + ScriptableObject.defineProperty + (scope, name, function, ScriptableObject.PERMANENT); + } else { + scope.put(name, scope, function); + } + } + } else if (type == FunctionNode.FUNCTION_EXPRESSION_STATEMENT) { + String name = function.getFunctionName(); + if (name != null && name.length() != 0) { + // Always put function expression statements into initial + // activation object ignoring the with statement to follow + // SpiderMonkey + while (scope instanceof NativeWith) { + scope = scope.getParentScope(); + } + scope.put(name, scope, function); + } + } else { + throw Kit.codeBug(); + } + } + + public static Scriptable newArrayLiteral(Object[] objects, + int[] skipIndices, + Context cx, Scriptable scope) + { + final int SKIP_DENSITY = 2; + int count = objects.length; + int skipCount = 0; + if (skipIndices != null) { + skipCount = skipIndices.length; + } + int length = count + skipCount; + if (length > 1 && skipCount * SKIP_DENSITY < length) { + // If not too sparse, create whole array for constructor + Object[] sparse; + if (skipCount == 0) { + sparse = objects; + } else { + sparse = new Object[length]; + int skip = 0; + for (int i = 0, j = 0; i != length; ++i) { + if (skip != skipCount && skipIndices[skip] == i) { + sparse[i] = Scriptable.NOT_FOUND; + ++skip; + continue; + } + sparse[i] = objects[j]; + ++j; + } + } + return cx.newObject(scope, "Array", sparse); + } + + Scriptable arrayObj = cx.newObject(scope, "Array", + ScriptRuntime.emptyArgs); + int skip = 0; + for (int i = 0, j = 0; i != length; ++i) { + if (skip != skipCount && skipIndices[skip] == i) { + ++skip; + continue; + } + ScriptableObject.putProperty(arrayObj, i, objects[j]); + ++j; + } + return arrayObj; + } + + /** + * This method is here for backward compat with existing compiled code. It + * is called when an object literal is compiled. The next instance will be + * the version called from new code. + * @deprecated This method only present for compatibility. + */ + public static Scriptable newObjectLiteral(Object[] propertyIds, + Object[] propertyValues, + Context cx, Scriptable scope) + { + // This will initialize to all zeros, exactly what we need for old-style + // getterSetters values (no getters or setters in the list) + int [] getterSetters = new int[propertyIds.length]; + return newObjectLiteral(propertyIds, propertyValues, getterSetters, + cx, scope); + } + + public static Scriptable newObjectLiteral(Object[] propertyIds, + Object[] propertyValues, + int [] getterSetters, + Context cx, Scriptable scope) + { + Scriptable object = cx.newObject(scope); + for (int i = 0, end = propertyIds.length; i != end; ++i) { + Object id = propertyIds[i]; + int getterSetter = getterSetters[i]; + Object value = propertyValues[i]; + if (id instanceof String) { + if (getterSetter == 0) + ScriptableObject.putProperty(object, (String)id, value); + else { + Callable fun; + String definer; + if (getterSetter < 0) // < 0 means get foo() ... + definer = "__defineGetter__"; + else + definer = "__defineSetter__"; + fun = getPropFunctionAndThis(object, definer, cx); + // Must consume the last scriptable object in cx + lastStoredScriptable(cx); + Object[] outArgs = new Object[2]; + outArgs[0] = id; + outArgs[1] = value; + fun.call(cx, scope, object, outArgs); + } + } else { + int index = ((Integer)id).intValue(); + ScriptableObject.putProperty(object, index, value); + } + } + return object; + } + + public static boolean isArrayObject(Object obj) + { + return obj instanceof NativeArray || obj instanceof Arguments; + } + + public static Object[] getArrayElements(Scriptable object) + { + Context cx = Context.getContext(); + long longLen = NativeArray.getLengthProperty(cx, object); + if (longLen > Integer.MAX_VALUE) { + // arrays beyond MAX_INT is not in Java in any case + throw new IllegalArgumentException(); + } + int len = (int) longLen; + if (len == 0) { + return ScriptRuntime.emptyArgs; + } else { + Object[] result = new Object[len]; + for (int i=0; i < len; i++) { + Object elem = ScriptableObject.getProperty(object, i); + result[i] = (elem == Scriptable.NOT_FOUND) ? Undefined.instance + : elem; + } + return result; + } + } + + static void checkDeprecated(Context cx, String name) { + int version = cx.getLanguageVersion(); + if (version >= Context.VERSION_1_4 || version == Context.VERSION_DEFAULT) { + String msg = getMessage1("msg.deprec.ctor", name); + if (version == Context.VERSION_DEFAULT) + Context.reportWarning(msg); + else + throw Context.reportRuntimeError(msg); + } + } + + public static String getMessage0(String messageId) + { + return getMessage(messageId, null); + } + + public static String getMessage1(String messageId, Object arg1) + { + Object[] arguments = {arg1}; + return getMessage(messageId, arguments); + } + + public static String getMessage2( + String messageId, Object arg1, Object arg2) + { + Object[] arguments = {arg1, arg2}; + return getMessage(messageId, arguments); + } + + public static String getMessage3( + String messageId, Object arg1, Object arg2, Object arg3) + { + Object[] arguments = {arg1, arg2, arg3}; + return getMessage(messageId, arguments); + } + + public static String getMessage4( + String messageId, Object arg1, Object arg2, Object arg3, Object arg4) + { + Object[] arguments = {arg1, arg2, arg3, arg4}; + return getMessage(messageId, arguments); + } + + /* OPT there's a noticable delay for the first error! Maybe it'd + * make sense to use a ListResourceBundle instead of a properties + * file to avoid (synchronized) text parsing. + */ + public static String getMessage(String messageId, Object[] arguments) + { + final String defaultResource + = "org.mozilla.javascript.resources.Messages"; + + Context cx = Context.getCurrentContext(); + Locale locale = cx != null ? cx.getLocale() : Locale.getDefault(); + + // ResourceBundle does cacheing. + ResourceBundle rb = ResourceBundle.getBundle(defaultResource, locale); + + String formatString; + try { + formatString = rb.getString(messageId); + } catch (java.util.MissingResourceException mre) { + throw new RuntimeException + ("no message resource found for message property "+ messageId); + } + + /* + * It's OK to format the string, even if 'arguments' is null; + * we need to format it anyway, to make double ''s collapse to + * single 's. + */ + MessageFormat formatter = new MessageFormat(formatString); + return formatter.format(arguments); + } + + public static EcmaError constructError(String error, String message) + { + int[] linep = new int[1]; + String filename = Context.getSourcePositionFromStack(linep); + return constructError(error, message, filename, linep[0], null, 0); + } + + public static EcmaError constructError(String error, + String message, + int lineNumberDelta) + { + int[] linep = new int[1]; + String filename = Context.getSourcePositionFromStack(linep); + if (linep[0] != 0) { + linep[0] += lineNumberDelta; + } + return constructError(error, message, filename, linep[0], null, 0); + } + + public static EcmaError constructError(String error, + String message, + String sourceName, + int lineNumber, + String lineSource, + int columnNumber) + { + return new EcmaError(error, message, sourceName, + lineNumber, lineSource, columnNumber); + } + + public static EcmaError typeError(String message) + { + return constructError("TypeError", message); + } + + public static EcmaError typeError0(String messageId) + { + String msg = getMessage0(messageId); + return typeError(msg); + } + + public static EcmaError typeError1(String messageId, String arg1) + { + String msg = getMessage1(messageId, arg1); + return typeError(msg); + } + + public static EcmaError typeError2(String messageId, String arg1, + String arg2) + { + String msg = getMessage2(messageId, arg1, arg2); + return typeError(msg); + } + + public static EcmaError typeError3(String messageId, String arg1, + String arg2, String arg3) + { + String msg = getMessage3(messageId, arg1, arg2, arg3); + return typeError(msg); + } + + public static RuntimeException undefReadError(Object object, Object id) + { + String idStr = (id == null) ? "null" : id.toString(); + return typeError2("msg.undef.prop.read", toString(object), idStr); + } + + public static RuntimeException undefCallError(Object object, Object id) + { + String idStr = (id == null) ? "null" : id.toString(); + return typeError2("msg.undef.method.call", toString(object), idStr); + } + + public static RuntimeException undefWriteError(Object object, + Object id, + Object value) + { + String idStr = (id == null) ? "null" : id.toString(); + String valueStr = (value instanceof Scriptable) + ? value.toString() : toString(value); + return typeError3("msg.undef.prop.write", toString(object), idStr, + valueStr); + } + + public static RuntimeException notFoundError(Scriptable object, + String property) + { + // XXX: use object to improve the error message + String msg = getMessage1("msg.is.not.defined", property); + throw constructError("ReferenceError", msg); + } + + public static RuntimeException notFunctionError(Object value) + { + return notFunctionError(value, value); + } + + public static RuntimeException notFunctionError(Object value, + Object messageHelper) + { + // Use value for better error reporting + String msg = (messageHelper == null) + ? "null" : messageHelper.toString(); + if (value == Scriptable.NOT_FOUND) { + return typeError1("msg.function.not.found", msg); + } + return typeError2("msg.isnt.function", msg, typeof(value)); + } + + public static RuntimeException notFunctionError(Object obj, Object value, + String propertyName) + { + // Use obj and value for better error reporting + String objString = toString(obj); + if (value == Scriptable.NOT_FOUND) { + return typeError2("msg.function.not.found.in", propertyName, + objString); + } + return typeError3("msg.isnt.function.in", propertyName, objString, + typeof(value)); + } + + private static RuntimeException notXmlError(Object value) + { + throw typeError1("msg.isnt.xml.object", toString(value)); + } + + private static void warnAboutNonJSObject(Object nonJSObject) + { + String message = +"RHINO USAGE WARNING: Missed Context.javaToJS() conversion:\n" ++"Rhino runtime detected object "+nonJSObject+" of class "+nonJSObject.getClass().getName()+" where it expected String, Number, Boolean or Scriptable instance. Please check your code for missing Context.javaToJS() call."; + Context.reportWarning(message); + // Just to be sure that it would be noticed + System.err.println(message); + } + + public static RegExpProxy getRegExpProxy(Context cx) + { + return cx.getRegExpProxy(); + } + + public static void setRegExpProxy(Context cx, RegExpProxy proxy) + { + if (proxy == null) throw new IllegalArgumentException(); + cx.regExpProxy = proxy; + } + + public static RegExpProxy checkRegExpProxy(Context cx) + { + RegExpProxy result = getRegExpProxy(cx); + if (result == null) { + throw Context.reportRuntimeError0("msg.no.regexp"); + } + return result; + } + + private static XMLLib currentXMLLib(Context cx) + { + // Scripts should be running to access this + if (cx.topCallScope == null) + throw new IllegalStateException(); + + XMLLib xmlLib = cx.cachedXMLLib; + if (xmlLib == null) { + xmlLib = XMLLib.extractFromScope(cx.topCallScope); + if (xmlLib == null) + throw new IllegalStateException(); + cx.cachedXMLLib = xmlLib; + } + + return xmlLib; + } + + /** + * Escapes the reserved characters in a value of an attribute + * + * @param value Unescaped text + * @return The escaped text + */ + public static String escapeAttributeValue(Object value, Context cx) + { + XMLLib xmlLib = currentXMLLib(cx); + return xmlLib.escapeAttributeValue(value); + } + + /** + * Escapes the reserved characters in a value of a text node + * + * @param value Unescaped text + * @return The escaped text + */ + public static String escapeTextValue(Object value, Context cx) + { + XMLLib xmlLib = currentXMLLib(cx); + return xmlLib.escapeTextValue(value); + } + + public static Ref memberRef(Object obj, Object elem, + Context cx, int memberTypeFlags) + { + if (!(obj instanceof XMLObject)) { + throw notXmlError(obj); + } + XMLObject xmlObject = (XMLObject)obj; + return xmlObject.memberRef(cx, elem, memberTypeFlags); + } + + public static Ref memberRef(Object obj, Object namespace, Object elem, + Context cx, int memberTypeFlags) + { + if (!(obj instanceof XMLObject)) { + throw notXmlError(obj); + } + XMLObject xmlObject = (XMLObject)obj; + return xmlObject.memberRef(cx, namespace, elem, memberTypeFlags); + } + + public static Ref nameRef(Object name, Context cx, + Scriptable scope, int memberTypeFlags) + { + XMLLib xmlLib = currentXMLLib(cx); + return xmlLib.nameRef(cx, name, scope, memberTypeFlags); + } + + public static Ref nameRef(Object namespace, Object name, Context cx, + Scriptable scope, int memberTypeFlags) + { + XMLLib xmlLib = currentXMLLib(cx); + return xmlLib.nameRef(cx, namespace, name, scope, memberTypeFlags); + } + + private static void storeIndexResult(Context cx, int index) + { + cx.scratchIndex = index; + } + + static int lastIndexResult(Context cx) + { + return cx.scratchIndex; + } + + public static void storeUint32Result(Context cx, long value) + { + if ((value >>> 32) != 0) + throw new IllegalArgumentException(); + cx.scratchUint32 = value; + } + + public static long lastUint32Result(Context cx) + { + long value = cx.scratchUint32; + if ((value >>> 32) != 0) + throw new IllegalStateException(); + return value; + } + + private static void storeScriptable(Context cx, Scriptable value) + { + // The previosly stored scratchScriptable should be consumed + if (cx.scratchScriptable != null) + throw new IllegalStateException(); + cx.scratchScriptable = value; + } + + public static Scriptable lastStoredScriptable(Context cx) + { + Scriptable result = cx.scratchScriptable; + cx.scratchScriptable = null; + return result; + } + + static String makeUrlForGeneratedScript + (boolean isEval, String masterScriptUrl, int masterScriptLine) + { + if (isEval) { + return masterScriptUrl+'#'+masterScriptLine+"(eval)"; + } else { + return masterScriptUrl+'#'+masterScriptLine+"(Function)"; + } + } + + static boolean isGeneratedScript(String sourceUrl) { + // ALERT: this may clash with a valid URL containing (eval) or + // (Function) + return sourceUrl.indexOf("(eval)") >= 0 + || sourceUrl.indexOf("(Function)") >= 0; + } + + private static RuntimeException errorWithClassName(String msg, Object val) + { + return Context.reportRuntimeError1(msg, val.getClass().getName()); + } + + public static final Object[] emptyArgs = new Object[0]; + public static final String[] emptyStrings = new String[0]; + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Scriptable.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Scriptable.java new file mode 100644 index 0000000..74e5ba7 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Scriptable.java @@ -0,0 +1,342 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * This is interface that all objects in JavaScript must implement. + * The interface provides for the management of properties and for + * performing conversions. + * <p> + * Host system implementors may find it easier to extend the ScriptableObject + * class rather than implementing Scriptable when writing host objects. + * <p> + * There are many static methods defined in ScriptableObject that perform + * the multiple calls to the Scriptable interface needed in order to + * manipulate properties in prototype chains. + * <p> + * + * @see org.mozilla.javascript.ScriptableObject + * @author Norris Boyd + * @author Nick Thompson + * @author Brendan Eich + */ + +public interface Scriptable { + + /** + * Get the name of the set of objects implemented by this Java class. + * This corresponds to the [[Class]] operation in ECMA and is used + * by Object.prototype.toString() in ECMA.<p> + * See ECMA 8.6.2 and 15.2.4.2. + */ + public String getClassName(); + + /** + * Value returned from <code>get</code> if the property is not + * found. + */ + public static final Object NOT_FOUND = UniqueTag.NOT_FOUND; + + /** + * Get a named property from the object. + * + * Looks property up in this object and returns the associated value + * if found. Returns NOT_FOUND if not found. + * Note that this method is not expected to traverse the prototype + * chain. This is different from the ECMA [[Get]] operation. + * + * Depending on the property selector, the runtime will call + * this method or the form of <code>get</code> that takes an + * integer: + * <table> + * <tr><th>JavaScript code</th><th>Java code</th></tr> + * <tr><td>a.b </td><td>a.get("b", a)</td></tr> + * <tr><td>a["foo"] </td><td>a.get("foo", a)</td></tr> + * <tr><td>a[3] </td><td>a.get(3, a)</td></tr> + * <tr><td>a["3"] </td><td>a.get(3, a)</td></tr> + * <tr><td>a[3.0] </td><td>a.get(3, a)</td></tr> + * <tr><td>a["3.0"] </td><td>a.get("3.0", a)</td></tr> + * <tr><td>a[1.1] </td><td>a.get("1.1", a)</td></tr> + * <tr><td>a[-4] </td><td>a.get(-4, a)</td></tr> + * </table> + * <p> + * The values that may be returned are limited to the following: + * <UL> + * <LI>java.lang.Boolean objects</LI> + * <LI>java.lang.String objects</LI> + * <LI>java.lang.Number objects</LI> + * <LI>org.mozilla.javascript.Scriptable objects</LI> + * <LI>null</LI> + * <LI>The value returned by Context.getUndefinedValue()</LI> + * <LI>NOT_FOUND</LI> + * </UL> + * @param name the name of the property + * @param start the object in which the lookup began + * @return the value of the property (may be null), or NOT_FOUND + * @see org.mozilla.javascript.Context#getUndefinedValue + */ + public Object get(String name, Scriptable start); + + /** + * Get a property from the object selected by an integral index. + * + * Identical to <code>get(String, Scriptable)</code> except that + * an integral index is used to select the property. + * + * @param index the numeric index for the property + * @param start the object in which the lookup began + * @return the value of the property (may be null), or NOT_FOUND + * @see org.mozilla.javascript.Scriptable#get(String,Scriptable) + */ + public Object get(int index, Scriptable start); + + /** + * Indicates whether or not a named property is defined in an object. + * + * Does not traverse the prototype chain.<p> + * + * The property is specified by a String name + * as defined for the <code>get</code> method.<p> + * + * @param name the name of the property + * @param start the object in which the lookup began + * @return true if and only if the named property is found in the object + * @see org.mozilla.javascript.Scriptable#get(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#getProperty(Scriptable, String) + */ + public boolean has(String name, Scriptable start); + + /** + * Indicates whether or not an indexed property is defined in an object. + * + * Does not traverse the prototype chain.<p> + * + * The property is specified by an integral index + * as defined for the <code>get</code> method.<p> + * + * @param index the numeric index for the property + * @param start the object in which the lookup began + * @return true if and only if the indexed property is found in the object + * @see org.mozilla.javascript.Scriptable#get(int, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#getProperty(Scriptable, int) + */ + public boolean has(int index, Scriptable start); + + /** + * Sets a named property in this object. + * <p> + * The property is specified by a string name + * as defined for <code>get</code>. + * <p> + * The possible values that may be passed in are as defined for + * <code>get</code>. A class that implements this method may choose + * to ignore calls to set certain properties, in which case those + * properties are effectively read-only.<p> + * For properties defined in a prototype chain, + * use <code>putProperty</code> in ScriptableObject. <p> + * Note that if a property <i>a</i> is defined in the prototype <i>p</i> + * of an object <i>o</i>, then evaluating <code>o.a = 23</code> will cause + * <code>set</code> to be called on the prototype <i>p</i> with + * <i>o</i> as the <i>start</i> parameter. + * To preserve JavaScript semantics, it is the Scriptable + * object's responsibility to modify <i>o</i>. <p> + * This design allows properties to be defined in prototypes and implemented + * in terms of getters and setters of Java values without consuming slots + * in each instance.<p> + * <p> + * The values that may be set are limited to the following: + * <UL> + * <LI>java.lang.Boolean objects</LI> + * <LI>java.lang.String objects</LI> + * <LI>java.lang.Number objects</LI> + * <LI>org.mozilla.javascript.Scriptable objects</LI> + * <LI>null</LI> + * <LI>The value returned by Context.getUndefinedValue()</LI> + * </UL><p> + * Arbitrary Java objects may be wrapped in a Scriptable by first calling + * <code>Context.toObject</code>. This allows the property of a JavaScript + * object to contain an arbitrary Java object as a value.<p> + * Note that <code>has</code> will be called by the runtime first before + * <code>set</code> is called to determine in which object the + * property is defined. + * Note that this method is not expected to traverse the prototype chain, + * which is different from the ECMA [[Put]] operation. + * @param name the name of the property + * @param start the object whose property is being set + * @param value value to set the property to + * @see org.mozilla.javascript.Scriptable#has(String, Scriptable) + * @see org.mozilla.javascript.Scriptable#get(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#putProperty(Scriptable, String, Object) + * @see org.mozilla.javascript.Context#toObject(Object, Scriptable) + */ + public void put(String name, Scriptable start, Object value); + + /** + * Sets an indexed property in this object. + * <p> + * The property is specified by an integral index + * as defined for <code>get</code>.<p> + * + * Identical to <code>put(String, Scriptable, Object)</code> except that + * an integral index is used to select the property. + * + * @param index the numeric index for the property + * @param start the object whose property is being set + * @param value value to set the property to + * @see org.mozilla.javascript.Scriptable#has(int, Scriptable) + * @see org.mozilla.javascript.Scriptable#get(int, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#putProperty(Scriptable, int, Object) + * @see org.mozilla.javascript.Context#toObject(Object, Scriptable) + */ + public void put(int index, Scriptable start, Object value); + + /** + * Removes a property from this object. + * This operation corresponds to the ECMA [[Delete]] except that + * the no result is returned. The runtime will guarantee that this + * method is called only if the property exists. After this method + * is called, the runtime will call Scriptable.has to see if the + * property has been removed in order to determine the boolean + * result of the delete operator as defined by ECMA 11.4.1. + * <p> + * A property can be made permanent by ignoring calls to remove + * it.<p> + * The property is specified by a String name + * as defined for <code>get</code>. + * <p> + * To delete properties defined in a prototype chain, + * see deleteProperty in ScriptableObject. + * @param name the identifier for the property + * @see org.mozilla.javascript.Scriptable#get(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#deleteProperty(Scriptable, String) + */ + public void delete(String name); + + /** + * Removes a property from this object. + * + * The property is specified by an integral index + * as defined for <code>get</code>. + * <p> + * To delete properties defined in a prototype chain, + * see deleteProperty in ScriptableObject. + * + * Identical to <code>delete(String)</code> except that + * an integral index is used to select the property. + * + * @param index the numeric index for the property + * @see org.mozilla.javascript.Scriptable#get(int, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#deleteProperty(Scriptable, int) + */ + public void delete(int index); + + /** + * Get the prototype of the object. + * @return the prototype + */ + public Scriptable getPrototype(); + + /** + * Set the prototype of the object. + * @param prototype the prototype to set + */ + public void setPrototype(Scriptable prototype); + + /** + * Get the parent scope of the object. + * @return the parent scope + */ + public Scriptable getParentScope(); + + /** + * Set the parent scope of the object. + * @param parent the parent scope to set + */ + public void setParentScope(Scriptable parent); + + /** + * Get an array of property ids. + * + * Not all property ids need be returned. Those properties + * whose ids are not returned are considered non-enumerable. + * + * @return an array of Objects. Each entry in the array is either + * a java.lang.String or a java.lang.Number + */ + public Object[] getIds(); + + /** + * Get the default value of the object with a given hint. + * The hints are String.class for type String, Number.class for type + * Number, Scriptable.class for type Object, and Boolean.class for + * type Boolean. <p> + * + * A <code>hint</code> of null means "no hint". + * + * See ECMA 8.6.2.6. + * + * @param hint the type hint + * @return the default value + */ + public Object getDefaultValue(Class hint); + + /** + * The instanceof operator. + * + * <p> + * The JavaScript code "lhs instanceof rhs" causes rhs.hasInstance(lhs) to + * be called. + * + * <p> + * The return value is implementation dependent so that embedded host objects can + * return an appropriate value. See the JS 1.3 language documentation for more + * detail. + * + * <p>This operator corresponds to the proposed EMCA [[HasInstance]] operator. + * + * @param instance The value that appeared on the LHS of the instanceof + * operator + * + * @return an implementation dependent value + */ + public boolean hasInstance(Scriptable instance); +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptableObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptableObject.java new file mode 100644 index 0000000..53de1fc --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/ScriptableObject.java @@ -0,0 +1,2428 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Bob Jervis + * Roger Lawrence + * Steve Weiss + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +import java.lang.reflect.*; +import java.util.Hashtable; +import java.io.*; +import org.mozilla.javascript.debug.DebuggableObject; + +/** + * This is the default implementation of the Scriptable interface. This + * class provides convenient default behavior that makes it easier to + * define host objects. + * <p> + * Various properties and methods of JavaScript objects can be conveniently + * defined using methods of ScriptableObject. + * <p> + * Classes extending ScriptableObject must define the getClassName method. + * + * @see org.mozilla.javascript.Scriptable + * @author Norris Boyd + */ + +public abstract class ScriptableObject implements Scriptable, Serializable, + DebuggableObject, + ConstProperties +{ + + /** + * The empty property attribute. + * + * Used by getAttributes() and setAttributes(). + * + * @see org.mozilla.javascript.ScriptableObject#getAttributes(String) + * @see org.mozilla.javascript.ScriptableObject#setAttributes(String, int) + */ + public static final int EMPTY = 0x00; + + /** + * Property attribute indicating assignment to this property is ignored. + * + * @see org.mozilla.javascript.ScriptableObject + * #put(String, Scriptable, Object) + * @see org.mozilla.javascript.ScriptableObject#getAttributes(String) + * @see org.mozilla.javascript.ScriptableObject#setAttributes(String, int) + */ + public static final int READONLY = 0x01; + + /** + * Property attribute indicating property is not enumerated. + * + * Only enumerated properties will be returned by getIds(). + * + * @see org.mozilla.javascript.ScriptableObject#getIds() + * @see org.mozilla.javascript.ScriptableObject#getAttributes(String) + * @see org.mozilla.javascript.ScriptableObject#setAttributes(String, int) + */ + public static final int DONTENUM = 0x02; + + /** + * Property attribute indicating property cannot be deleted. + * + * @see org.mozilla.javascript.ScriptableObject#delete(String) + * @see org.mozilla.javascript.ScriptableObject#getAttributes(String) + * @see org.mozilla.javascript.ScriptableObject#setAttributes(String, int) + */ + public static final int PERMANENT = 0x04; + + /** + * Property attribute indicating that this is a const property that has not + * been assigned yet. The first 'const' assignment to the property will + * clear this bit. + */ + public static final int UNINITIALIZED_CONST = 0x08; + + public static final int CONST = PERMANENT|READONLY|UNINITIALIZED_CONST; + /** + * The prototype of this object. + */ + private Scriptable prototypeObject; + + /** + * The parent scope of this object. + */ + private Scriptable parentScopeObject; + + private static final Slot REMOVED = new Slot(null, 0, READONLY); + + static { + REMOVED.wasDeleted = 1; + } + + private transient Slot[] slots; + // If count >= 0, it gives number of keys or if count < 0, + // it indicates sealed object where ~count gives number of keys + private int count; + + // cache; may be removed for smaller memory footprint + private transient Slot lastAccess = REMOVED; + + // associated values are not serialized + private transient volatile Hashtable associatedValues; + + private static final int SLOT_QUERY = 1; + private static final int SLOT_MODIFY = 2; + private static final int SLOT_REMOVE = 3; + private static final int SLOT_MODIFY_GETTER_SETTER = 4; + private static final int SLOT_MODIFY_CONST = 5; + + private static class Slot implements Serializable + { + static final long serialVersionUID = -3539051633409902634L; + + String name; // This can change due to caching + int indexOrHash; + private volatile short attributes; + transient volatile byte wasDeleted; + volatile Object value; + transient volatile Slot next; + + Slot(String name, int indexOrHash, int attributes) + { + this.name = name; + this.indexOrHash = indexOrHash; + this.attributes = (short)attributes; + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + if (name != null) { + indexOrHash = name.hashCode(); + } + } + + final int getAttributes() + { + return attributes; + } + + final synchronized void setAttributes(int value) + { + checkValidAttributes(value); + attributes = (short)value; + } + + final void checkNotReadonly() + { + if ((attributes & READONLY) != 0) { + String str = (name != null ? name + : Integer.toString(indexOrHash)); + throw Context.reportRuntimeError1("msg.modify.readonly", str); + } + } + + } + + private static final class GetterSlot extends Slot + { + static final long serialVersionUID = -4900574849788797588L; + + Object getter; + Object setter; + + GetterSlot(String name, int indexOrHash, int attributes) + { + super(name, indexOrHash, attributes); + } + } + + static void checkValidAttributes(int attributes) + { + final int mask = READONLY | DONTENUM | PERMANENT | UNINITIALIZED_CONST; + if ((attributes & ~mask) != 0) { + throw new IllegalArgumentException(String.valueOf(attributes)); + } + } + + public ScriptableObject() + { + } + + public ScriptableObject(Scriptable scope, Scriptable prototype) + { + if (scope == null) + throw new IllegalArgumentException(); + + parentScopeObject = scope; + prototypeObject = prototype; + } + + /** + * Return the name of the class. + * + * This is typically the same name as the constructor. + * Classes extending ScriptableObject must implement this abstract + * method. + */ + public abstract String getClassName(); + + /** + * Returns true if the named property is defined. + * + * @param name the name of the property + * @param start the object in which the lookup began + * @return true if and only if the property was found in the object + */ + public boolean has(String name, Scriptable start) + { + return null != getSlot(name, 0, SLOT_QUERY); + } + + /** + * Returns true if the property index is defined. + * + * @param index the numeric index for the property + * @param start the object in which the lookup began + * @return true if and only if the property was found in the object + */ + public boolean has(int index, Scriptable start) + { + return null != getSlot(null, index, SLOT_QUERY); + } + + /** + * Returns the value of the named property or NOT_FOUND. + * + * If the property was created using defineProperty, the + * appropriate getter method is called. + * + * @param name the name of the property + * @param start the object in which the lookup began + * @return the value of the property (may be null), or NOT_FOUND + */ + public Object get(String name, Scriptable start) + { + return getImpl(name, 0, start); + } + + /** + * Returns the value of the indexed property or NOT_FOUND. + * + * @param index the numeric index for the property + * @param start the object in which the lookup began + * @return the value of the property (may be null), or NOT_FOUND + */ + public Object get(int index, Scriptable start) + { + return getImpl(null, index, start); + } + + /** + * Sets the value of the named property, creating it if need be. + * + * If the property was created using defineProperty, the + * appropriate setter method is called. <p> + * + * If the property's attributes include READONLY, no action is + * taken. + * This method will actually set the property in the start + * object. + * + * @param name the name of the property + * @param start the object whose property is being set + * @param value value to set the property to + */ + public void put(String name, Scriptable start, Object value) + { + if (putImpl(name, 0, start, value, EMPTY)) + return; + + if (start == this) throw Kit.codeBug(); + start.put(name, start, value); + } + + /** + * Sets the value of the indexed property, creating it if need be. + * + * @param index the numeric index for the property + * @param start the object whose property is being set + * @param value value to set the property to + */ + public void put(int index, Scriptable start, Object value) + { + if (putImpl(null, index, start, value, EMPTY)) + return; + + if (start == this) throw Kit.codeBug(); + start.put(index, start, value); + } + + /** + * Removes a named property from the object. + * + * If the property is not found, or it has the PERMANENT attribute, + * no action is taken. + * + * @param name the name of the property + */ + public void delete(String name) + { + checkNotSealed(name, 0); + accessSlot(name, 0, SLOT_REMOVE); + } + + /** + * Removes the indexed property from the object. + * + * If the property is not found, or it has the PERMANENT attribute, + * no action is taken. + * + * @param index the numeric index for the property + */ + public void delete(int index) + { + checkNotSealed(null, index); + accessSlot(null, index, SLOT_REMOVE); + } + + /** + * Sets the value of the named const property, creating it if need be. + * + * If the property was created using defineProperty, the + * appropriate setter method is called. <p> + * + * If the property's attributes include READONLY, no action is + * taken. + * This method will actually set the property in the start + * object. + * + * @param name the name of the property + * @param start the object whose property is being set + * @param value value to set the property to + */ + public void putConst(String name, Scriptable start, Object value) + { + if (putImpl(name, 0, start, value, READONLY)) + return; + + if (start == this) throw Kit.codeBug(); + if (start instanceof ConstProperties) + ((ConstProperties)start).putConst(name, start, value); + else + start.put(name, start, value); + } + + public void defineConst(String name, Scriptable start) + { + if (putImpl(name, 0, start, Undefined.instance, UNINITIALIZED_CONST)) + return; + + if (start == this) throw Kit.codeBug(); + if (start instanceof ConstProperties) + ((ConstProperties)start).defineConst(name, start); + } + /** + * Returns true if the named property is defined as a const on this object. + * @param name + * @return true if the named property is defined as a const, false + * otherwise. + */ + public boolean isConst(String name) + { + Slot slot = getSlot(name, 0, SLOT_QUERY); + if (slot == null) { + return false; + } + return (slot.getAttributes() & (PERMANENT|READONLY)) == + (PERMANENT|READONLY); + + } + /** + * @deprecated Use {@link #getAttributes(String name)}. The engine always + * ignored the start argument. + */ + public final int getAttributes(String name, Scriptable start) + { + return getAttributes(name); + } + + /** + * @deprecated Use {@link #getAttributes(int index)}. The engine always + * ignored the start argument. + */ + public final int getAttributes(int index, Scriptable start) + { + return getAttributes(index); + } + + /** + * @deprecated Use {@link #setAttributes(String name, int attributes)}. + * The engine always ignored the start argument. + */ + public final void setAttributes(String name, Scriptable start, + int attributes) + { + setAttributes(name, attributes); + } + + /** + * @deprecated Use {@link #setAttributes(int index, int attributes)}. + * The engine always ignored the start argument. + */ + public void setAttributes(int index, Scriptable start, + int attributes) + { + setAttributes(index, attributes); + } + + /** + * Get the attributes of a named property. + * + * The property is specified by <code>name</code> + * as defined for <code>has</code>.<p> + * + * @param name the identifier for the property + * @return the bitset of attributes + * @exception EvaluatorException if the named property is not found + * @see org.mozilla.javascript.ScriptableObject#has(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#READONLY + * @see org.mozilla.javascript.ScriptableObject#DONTENUM + * @see org.mozilla.javascript.ScriptableObject#PERMANENT + * @see org.mozilla.javascript.ScriptableObject#EMPTY + */ + public int getAttributes(String name) + { + return findAttributeSlot(name, 0, SLOT_QUERY).getAttributes(); + } + + /** + * Get the attributes of an indexed property. + * + * @param index the numeric index for the property + * @exception EvaluatorException if the named property is not found + * is not found + * @return the bitset of attributes + * @see org.mozilla.javascript.ScriptableObject#has(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#READONLY + * @see org.mozilla.javascript.ScriptableObject#DONTENUM + * @see org.mozilla.javascript.ScriptableObject#PERMANENT + * @see org.mozilla.javascript.ScriptableObject#EMPTY + */ + public int getAttributes(int index) + { + return findAttributeSlot(null, index, SLOT_QUERY).getAttributes(); + } + + /** + * Set the attributes of a named property. + * + * The property is specified by <code>name</code> + * as defined for <code>has</code>.<p> + * + * The possible attributes are READONLY, DONTENUM, + * and PERMANENT. Combinations of attributes + * are expressed by the bitwise OR of attributes. + * EMPTY is the state of no attributes set. Any unused + * bits are reserved for future use. + * + * @param name the name of the property + * @param attributes the bitset of attributes + * @exception EvaluatorException if the named property is not found + * @see org.mozilla.javascript.Scriptable#has(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#READONLY + * @see org.mozilla.javascript.ScriptableObject#DONTENUM + * @see org.mozilla.javascript.ScriptableObject#PERMANENT + * @see org.mozilla.javascript.ScriptableObject#EMPTY + */ + public void setAttributes(String name, int attributes) + { + checkNotSealed(name, 0); + findAttributeSlot(name, 0, SLOT_MODIFY).setAttributes(attributes); + } + + /** + * Set the attributes of an indexed property. + * + * @param index the numeric index for the property + * @param attributes the bitset of attributes + * @exception EvaluatorException if the named property is not found + * @see org.mozilla.javascript.Scriptable#has(String, Scriptable) + * @see org.mozilla.javascript.ScriptableObject#READONLY + * @see org.mozilla.javascript.ScriptableObject#DONTENUM + * @see org.mozilla.javascript.ScriptableObject#PERMANENT + * @see org.mozilla.javascript.ScriptableObject#EMPTY + */ + public void setAttributes(int index, int attributes) + { + checkNotSealed(null, index); + findAttributeSlot(null, index, SLOT_MODIFY).setAttributes(attributes); + } + + /** + * XXX: write docs. + */ + public void setGetterOrSetter(String name, int index, + Callable getterOrSeter, boolean isSetter) + { + if (name != null && index != 0) + throw new IllegalArgumentException(name); + + checkNotSealed(name, index); + GetterSlot gslot = (GetterSlot)getSlot(name, index, + SLOT_MODIFY_GETTER_SETTER); + gslot.checkNotReadonly(); + if (isSetter) { + gslot.setter = getterOrSeter; + } else { + gslot.getter = getterOrSeter; + } + gslot.value = Undefined.instance; + } + + /** + * Get the getter or setter for a given property. Used by __lookupGetter__ + * and __lookupSetter__. + * + * @param name Name of the object. If nonnull, index must be 0. + * @param index Index of the object. If nonzero, name must be null. + * @param isSetter If true, return the setter, otherwise return the getter. + * @exception IllegalArgumentException if both name and index are nonnull + * and nonzero respectively. + * @return Null if the property does not exist. Otherwise returns either + * the getter or the setter for the property, depending on + * the value of isSetter (may be undefined if unset). + */ + public Object getGetterOrSetter(String name, int index, boolean isSetter) + { + if (name != null && index != 0) + throw new IllegalArgumentException(name); + Slot slot = getSlot(name, index, SLOT_QUERY); + if (slot == null) + return null; + if (slot instanceof GetterSlot) { + GetterSlot gslot = (GetterSlot)slot; + Object result = isSetter ? gslot.setter : gslot.getter; + return result != null ? result : Undefined.instance; + } else + return Undefined.instance; + } + + /** + * Returns whether a property is a getter or a setter + * @param name property name + * @param index property index + * @param setter true to check for a setter, false for a getter + * @return whether the property is a getter or a setter + */ + protected boolean isGetterOrSetter(String name, int index, boolean setter) { + Slot slot = getSlot(name, index, SLOT_QUERY); + if (slot instanceof GetterSlot) { + if (setter && ((GetterSlot)slot).setter != null) return true; + if (!setter && ((GetterSlot)slot).getter != null) return true; + } + return false; + } + + void addLazilyInitializedValue(String name, int index, + LazilyLoadedCtor init, int attributes) + { + if (name != null && index != 0) + throw new IllegalArgumentException(name); + checkNotSealed(name, index); + GetterSlot gslot = (GetterSlot)getSlot(name, index, + SLOT_MODIFY_GETTER_SETTER); + gslot.setAttributes(attributes); + gslot.getter = null; + gslot.setter = null; + gslot.value = init; + } + + /** + * Returns the prototype of the object. + */ + public Scriptable getPrototype() + { + return prototypeObject; + } + + /** + * Sets the prototype of the object. + */ + public void setPrototype(Scriptable m) + { + prototypeObject = m; + } + + /** + * Returns the parent (enclosing) scope of the object. + */ + public Scriptable getParentScope() + { + return parentScopeObject; + } + + /** + * Sets the parent (enclosing) scope of the object. + */ + public void setParentScope(Scriptable m) + { + parentScopeObject = m; + } + + /** + * Returns an array of ids for the properties of the object. + * + * <p>Any properties with the attribute DONTENUM are not listed. <p> + * + * @return an array of java.lang.Objects with an entry for every + * listed property. Properties accessed via an integer index will + * have a corresponding + * Integer entry in the returned array. Properties accessed by + * a String will have a String entry in the returned array. + */ + public Object[] getIds() { + return getIds(false); + } + + /** + * Returns an array of ids for the properties of the object. + * + * <p>All properties, even those with attribute DONTENUM, are listed. <p> + * + * @return an array of java.lang.Objects with an entry for every + * listed property. Properties accessed via an integer index will + * have a corresponding + * Integer entry in the returned array. Properties accessed by + * a String will have a String entry in the returned array. + */ + public Object[] getAllIds() { + return getIds(true); + } + + /** + * Implements the [[DefaultValue]] internal method. + * + * <p>Note that the toPrimitive conversion is a no-op for + * every type other than Object, for which [[DefaultValue]] + * is called. See ECMA 9.1.<p> + * + * A <code>hint</code> of null means "no hint". + * + * @param typeHint the type hint + * @return the default value for the object + * + * See ECMA 8.6.2.6. + */ + public Object getDefaultValue(Class typeHint) + { + return getDefaultValue(this, typeHint); + } + + public static Object getDefaultValue(Scriptable object, Class typeHint) + { + Context cx = null; + for (int i=0; i < 2; i++) { + boolean tryToString; + if (typeHint == ScriptRuntime.StringClass) { + tryToString = (i == 0); + } else { + tryToString = (i == 1); + } + + String methodName; + Object[] args; + if (tryToString) { + methodName = "toString"; + args = ScriptRuntime.emptyArgs; + } else { + methodName = "valueOf"; + args = new Object[1]; + String hint; + if (typeHint == null) { + hint = "undefined"; + } else if (typeHint == ScriptRuntime.StringClass) { + hint = "string"; + } else if (typeHint == ScriptRuntime.ScriptableClass) { + hint = "object"; + } else if (typeHint == ScriptRuntime.FunctionClass) { + hint = "function"; + } else if (typeHint == ScriptRuntime.BooleanClass + || typeHint == Boolean.TYPE) + { + hint = "boolean"; + } else if (typeHint == ScriptRuntime.NumberClass || + typeHint == ScriptRuntime.ByteClass || + typeHint == Byte.TYPE || + typeHint == ScriptRuntime.ShortClass || + typeHint == Short.TYPE || + typeHint == ScriptRuntime.IntegerClass || + typeHint == Integer.TYPE || + typeHint == ScriptRuntime.FloatClass || + typeHint == Float.TYPE || + typeHint == ScriptRuntime.DoubleClass || + typeHint == Double.TYPE) + { + hint = "number"; + } else { + throw Context.reportRuntimeError1( + "msg.invalid.type", typeHint.toString()); + } + args[0] = hint; + } + Object v = getProperty(object, methodName); + if (!(v instanceof Function)) + continue; + Function fun = (Function) v; + if (cx == null) + cx = Context.getContext(); + v = fun.call(cx, fun.getParentScope(), object, args); + if (v != null) { + if (!(v instanceof Scriptable)) { + return v; + } + if (typeHint == ScriptRuntime.ScriptableClass + || typeHint == ScriptRuntime.FunctionClass) + { + return v; + } + if (tryToString && v instanceof Wrapper) { + // Let a wrapped java.lang.String pass for a primitive + // string. + Object u = ((Wrapper)v).unwrap(); + if (u instanceof String) + return u; + } + } + } + // fall through to error + String arg = (typeHint == null) ? "undefined" : typeHint.getName(); + throw ScriptRuntime.typeError1("msg.default.value", arg); + } + + /** + * Implements the instanceof operator. + * + * <p>This operator has been proposed to ECMA. + * + * @param instance The value that appeared on the LHS of the instanceof + * operator + * @return true if "this" appears in value's prototype chain + * + */ + public boolean hasInstance(Scriptable instance) { + // Default for JS objects (other than Function) is to do prototype + // chasing. This will be overridden in NativeFunction and non-JS + // objects. + + return ScriptRuntime.jsDelegatesTo(instance, this); + } + + /** + * Emulate the SpiderMonkey (and Firefox) feature of allowing + * custom objects to avoid detection by normal "object detection" + * code patterns. This is used to implement document.all. + * See https://bugzilla.mozilla.org/show_bug.cgi?id=412247. + * This is an analog to JOF_DETECTING from SpiderMonkey; see + * https://bugzilla.mozilla.org/show_bug.cgi?id=248549. + * Other than this special case, embeddings should return false. + * @return true if this object should avoid object detection + * @since 1.7R1 + */ + public boolean avoidObjectDetection() { + return false; + } + + /** + * Custom <tt>==</tt> operator. + * Must return {@link Scriptable#NOT_FOUND} if this object does not + * have custom equality operator for the given value, + * <tt>Boolean.TRUE</tt> if this object is equivalent to <tt>value</tt>, + * <tt>Boolean.FALSE</tt> if this object is not equivalent to + * <tt>value</tt>. + * <p> + * The default implementation returns Boolean.TRUE + * if <tt>this == value</tt> or {@link Scriptable#NOT_FOUND} otherwise. + * It indicates that by default custom equality is available only if + * <tt>value</tt> is <tt>this</tt> in which case true is returned. + */ + protected Object equivalentValues(Object value) + { + return (this == value) ? Boolean.TRUE : Scriptable.NOT_FOUND; + } + + /** + * Defines JavaScript objects from a Java class that implements Scriptable. + * + * If the given class has a method + * <pre> + * static void init(Context cx, Scriptable scope, boolean sealed);</pre> + * + * or its compatibility form + * <pre> + * static void init(Scriptable scope);</pre> + * + * then it is invoked and no further initialization is done.<p> + * + * However, if no such a method is found, then the class's constructors and + * methods are used to initialize a class in the following manner.<p> + * + * First, the zero-parameter constructor of the class is called to + * create the prototype. If no such constructor exists, + * a {@link EvaluatorException} is thrown. <p> + * + * Next, all methods are scanned for special prefixes that indicate that they + * have special meaning for defining JavaScript objects. + * These special prefixes are + * <ul> + * <li><code>jsFunction_</code> for a JavaScript function + * <li><code>jsStaticFunction_</code> for a JavaScript function that + * is a property of the constructor + * <li><code>jsGet_</code> for a getter of a JavaScript property + * <li><code>jsSet_</code> for a setter of a JavaScript property + * <li><code>jsConstructor</code> for a JavaScript function that + * is the constructor + * </ul><p> + * + * If the method's name begins with "jsFunction_", a JavaScript function + * is created with a name formed from the rest of the Java method name + * following "jsFunction_". So a Java method named "jsFunction_foo" will + * define a JavaScript method "foo". Calling this JavaScript function + * will cause the Java method to be called. The parameters of the method + * must be of number and types as defined by the FunctionObject class. + * The JavaScript function is then added as a property + * of the prototype. <p> + * + * If the method's name begins with "jsStaticFunction_", it is handled + * similarly except that the resulting JavaScript function is added as a + * property of the constructor object. The Java method must be static. + * + * If the method's name begins with "jsGet_" or "jsSet_", the method is + * considered to define a property. Accesses to the defined property + * will result in calls to these getter and setter methods. If no + * setter is defined, the property is defined as READONLY.<p> + * + * If the method's name is "jsConstructor", the method is + * considered to define the body of the constructor. Only one + * method of this name may be defined. + * If no method is found that can serve as constructor, a Java + * constructor will be selected to serve as the JavaScript + * constructor in the following manner. If the class has only one + * Java constructor, that constructor is used to define + * the JavaScript constructor. If the the class has two constructors, + * one must be the zero-argument constructor (otherwise an + * {@link EvaluatorException} would have already been thrown + * when the prototype was to be created). In this case + * the Java constructor with one or more parameters will be used + * to define the JavaScript constructor. If the class has three + * or more constructors, an {@link EvaluatorException} + * will be thrown.<p> + * + * Finally, if there is a method + * <pre> + * static void finishInit(Scriptable scope, FunctionObject constructor, + * Scriptable prototype)</pre> + * + * it will be called to finish any initialization. The <code>scope</code> + * argument will be passed, along with the newly created constructor and + * the newly created prototype.<p> + * + * @param scope The scope in which to define the constructor. + * @param clazz The Java class to use to define the JavaScript objects + * and properties. + * @exception IllegalAccessException if access is not available + * to a reflected class member + * @exception InstantiationException if unable to instantiate + * the named class + * @exception InvocationTargetException if an exception is thrown + * during execution of methods of the named class + * @see org.mozilla.javascript.Function + * @see org.mozilla.javascript.FunctionObject + * @see org.mozilla.javascript.ScriptableObject#READONLY + * @see org.mozilla.javascript.ScriptableObject + * #defineProperty(String, Class, int) + */ + public static void defineClass(Scriptable scope, Class clazz) + throws IllegalAccessException, InstantiationException, + InvocationTargetException + { + defineClass(scope, clazz, false, false); + } + + /** + * Defines JavaScript objects from a Java class, optionally + * allowing sealing. + * + * Similar to <code>defineClass(Scriptable scope, Class clazz)</code> + * except that sealing is allowed. An object that is sealed cannot have + * properties added or removed. Note that sealing is not allowed in + * the current ECMA/ISO language specification, but is likely for + * the next version. + * + * @param scope The scope in which to define the constructor. + * @param clazz The Java class to use to define the JavaScript objects + * and properties. The class must implement Scriptable. + * @param sealed Whether or not to create sealed standard objects that + * cannot be modified. + * @exception IllegalAccessException if access is not available + * to a reflected class member + * @exception InstantiationException if unable to instantiate + * the named class + * @exception InvocationTargetException if an exception is thrown + * during execution of methods of the named class + * @since 1.4R3 + */ + public static void defineClass(Scriptable scope, Class clazz, + boolean sealed) + throws IllegalAccessException, InstantiationException, + InvocationTargetException + { + defineClass(scope, clazz, sealed, false); + } + + /** + * Defines JavaScript objects from a Java class, optionally + * allowing sealing and mapping of Java inheritance to JavaScript + * prototype-based inheritance. + * + * Similar to <code>defineClass(Scriptable scope, Class clazz)</code> + * except that sealing and inheritance mapping are allowed. An object + * that is sealed cannot have properties added or removed. Note that + * sealing is not allowed in the current ECMA/ISO language specification, + * but is likely for the next version. + * + * @param scope The scope in which to define the constructor. + * @param clazz The Java class to use to define the JavaScript objects + * and properties. The class must implement Scriptable. + * @param sealed Whether or not to create sealed standard objects that + * cannot be modified. + * @param mapInheritance Whether or not to map Java inheritance to + * JavaScript prototype-based inheritance. + * @return the class name for the prototype of the specified class + * @exception IllegalAccessException if access is not available + * to a reflected class member + * @exception InstantiationException if unable to instantiate + * the named class + * @exception InvocationTargetException if an exception is thrown + * during execution of methods of the named class + * @since 1.6R2 + */ + public static String defineClass(Scriptable scope, Class clazz, + boolean sealed, boolean mapInheritance) + throws IllegalAccessException, InstantiationException, + InvocationTargetException + { + BaseFunction ctor = buildClassCtor(scope, clazz, sealed, + mapInheritance); + if (ctor == null) + return null; + String name = ctor.getClassPrototype().getClassName(); + defineProperty(scope, name, ctor, ScriptableObject.DONTENUM); + return name; + } + + static BaseFunction buildClassCtor(Scriptable scope, Class clazz, + boolean sealed, + boolean mapInheritance) + throws IllegalAccessException, InstantiationException, + InvocationTargetException + { + Method[] methods = FunctionObject.getMethodList(clazz); + for (int i=0; i < methods.length; i++) { + Method method = methods[i]; + if (!method.getName().equals("init")) + continue; + Class[] parmTypes = method.getParameterTypes(); + if (parmTypes.length == 3 && + parmTypes[0] == ScriptRuntime.ContextClass && + parmTypes[1] == ScriptRuntime.ScriptableClass && + parmTypes[2] == Boolean.TYPE && + Modifier.isStatic(method.getModifiers())) + { + Object args[] = { Context.getContext(), scope, + sealed ? Boolean.TRUE : Boolean.FALSE }; + method.invoke(null, args); + return null; + } + if (parmTypes.length == 1 && + parmTypes[0] == ScriptRuntime.ScriptableClass && + Modifier.isStatic(method.getModifiers())) + { + Object args[] = { scope }; + method.invoke(null, args); + return null; + } + + } + + // If we got here, there isn't an "init" method with the right + // parameter types. + + Constructor[] ctors = clazz.getConstructors(); + Constructor protoCtor = null; + for (int i=0; i < ctors.length; i++) { + if (ctors[i].getParameterTypes().length == 0) { + protoCtor = ctors[i]; + break; + } + } + if (protoCtor == null) { + throw Context.reportRuntimeError1( + "msg.zero.arg.ctor", clazz.getName()); + } + + Scriptable proto = (Scriptable) protoCtor.newInstance(ScriptRuntime.emptyArgs); + String className = proto.getClassName(); + + // Set the prototype's prototype, trying to map Java inheritance to JS + // prototype-based inheritance if requested to do so. + Scriptable superProto = null; + if (mapInheritance) { + Class superClass = clazz.getSuperclass(); + if (ScriptRuntime.ScriptableClass.isAssignableFrom(superClass) + && !Modifier.isAbstract(superClass.getModifiers())) { + String name = ScriptableObject.defineClass(scope, superClass, sealed, mapInheritance); + if (name != null) { + superProto = ScriptableObject.getClassPrototype(scope, name); + } + } + } + if (superProto == null) { + superProto = ScriptableObject.getObjectPrototype(scope); + } + proto.setPrototype(superProto); + + // Find out whether there are any methods that begin with + // "js". If so, then only methods that begin with special + // prefixes will be defined as JavaScript entities. + final String functionPrefix = "jsFunction_"; + final String staticFunctionPrefix = "jsStaticFunction_"; + final String getterPrefix = "jsGet_"; + final String setterPrefix = "jsSet_"; + final String ctorName = "jsConstructor"; + + Member ctorMember = FunctionObject.findSingleMethod(methods, ctorName); + + if (ctorMember == null) { + if (ctors.length == 1) { + ctorMember = ctors[0]; + } else if (ctors.length == 2) { + if (ctors[0].getParameterTypes().length == 0) + ctorMember = ctors[1]; + else if (ctors[1].getParameterTypes().length == 0) + ctorMember = ctors[0]; + } + if (ctorMember == null) { + throw Context.reportRuntimeError1( + "msg.ctor.multiple.parms", clazz.getName()); + } + } + + FunctionObject ctor = new FunctionObject(className, ctorMember, scope); + if (ctor.isVarArgsMethod()) { + throw Context.reportRuntimeError1 + ("msg.varargs.ctor", ctorMember.getName()); + } + ctor.initAsConstructor(scope, proto); + + Method finishInit = null; + for (int i=0; i < methods.length; i++) { + if (methods[i] == ctorMember) { + continue; + } + String name = methods[i].getName(); + if (name.equals("finishInit")) { + Class[] parmTypes = methods[i].getParameterTypes(); + if (parmTypes.length == 3 && + parmTypes[0] == ScriptRuntime.ScriptableClass && + parmTypes[1] == FunctionObject.class && + parmTypes[2] == ScriptRuntime.ScriptableClass && + Modifier.isStatic(methods[i].getModifiers())) + { + finishInit = methods[i]; + continue; + } + } + // ignore any compiler generated methods. + if (name.indexOf('$') != -1) + continue; + if (name.equals(ctorName)) + continue; + + String prefix = null; + if (name.startsWith(functionPrefix)) { + prefix = functionPrefix; + } else if (name.startsWith(staticFunctionPrefix)) { + prefix = staticFunctionPrefix; + if (!Modifier.isStatic(methods[i].getModifiers())) { + throw Context.reportRuntimeError( + "jsStaticFunction must be used with static method."); + } + } else if (name.startsWith(getterPrefix)) { + prefix = getterPrefix; + } else if (name.startsWith(setterPrefix)) { + prefix = setterPrefix; + } else { + continue; + } + name = name.substring(prefix.length()); + if (prefix == setterPrefix) + continue; // deal with set when we see get + if (prefix == getterPrefix) { + if (!(proto instanceof ScriptableObject)) { + throw Context.reportRuntimeError2( + "msg.extend.scriptable", + proto.getClass().toString(), name); + } + Method setter = FunctionObject.findSingleMethod( + methods, + setterPrefix + name); + int attr = ScriptableObject.PERMANENT | + ScriptableObject.DONTENUM | + (setter != null ? 0 + : ScriptableObject.READONLY); + ((ScriptableObject) proto).defineProperty(name, null, + methods[i], setter, + attr); + continue; + } + + FunctionObject f = new FunctionObject(name, methods[i], proto); + if (f.isVarArgsConstructor()) { + throw Context.reportRuntimeError1 + ("msg.varargs.fun", ctorMember.getName()); + } + Scriptable dest = prefix == staticFunctionPrefix + ? ctor + : proto; + defineProperty(dest, name, f, DONTENUM); + if (sealed) { + f.sealObject(); + } + } + + // Call user code to complete initialization if necessary. + if (finishInit != null) { + Object[] finishArgs = { scope, ctor, proto }; + finishInit.invoke(null, finishArgs); + } + + // Seal the object if necessary. + if (sealed) { + ctor.sealObject(); + if (proto instanceof ScriptableObject) { + ((ScriptableObject) proto).sealObject(); + } + } + + return ctor; + } + + /** + * Define a JavaScript property. + * + * Creates the property with an initial value and sets its attributes. + * + * @param propertyName the name of the property to define. + * @param value the initial value of the property + * @param attributes the attributes of the JavaScript property + * @see org.mozilla.javascript.Scriptable#put(String, Scriptable, Object) + */ + public void defineProperty(String propertyName, Object value, + int attributes) + { + checkNotSealed(propertyName, 0); + put(propertyName, this, value); + setAttributes(propertyName, attributes); + } + + /** + * Utility method to add properties to arbitrary Scriptable object. + * If destination is instance of ScriptableObject, calls + * defineProperty there, otherwise calls put in destination + * ignoring attributes + */ + public static void defineProperty(Scriptable destination, + String propertyName, Object value, + int attributes) + { + if (!(destination instanceof ScriptableObject)) { + destination.put(propertyName, destination, value); + return; + } + ScriptableObject so = (ScriptableObject)destination; + so.defineProperty(propertyName, value, attributes); + } + + /** + * Utility method to add properties to arbitrary Scriptable object. + * If destination is instance of ScriptableObject, calls + * defineProperty there, otherwise calls put in destination + * ignoring attributes + */ + public static void defineConstProperty(Scriptable destination, + String propertyName) + { + if (destination instanceof ConstProperties) { + ConstProperties cp = (ConstProperties)destination; + cp.defineConst(propertyName, destination); + } else + defineProperty(destination, propertyName, Undefined.instance, CONST); + } + + /** + * Define a JavaScript property with getter and setter side effects. + * + * If the setter is not found, the attribute READONLY is added to + * the given attributes. <p> + * + * The getter must be a method with zero parameters, and the setter, if + * found, must be a method with one parameter.<p> + * + * @param propertyName the name of the property to define. This name + * also affects the name of the setter and getter + * to search for. If the propertyId is "foo", then + * <code>clazz</code> will be searched for "getFoo" + * and "setFoo" methods. + * @param clazz the Java class to search for the getter and setter + * @param attributes the attributes of the JavaScript property + * @see org.mozilla.javascript.Scriptable#put(String, Scriptable, Object) + */ + public void defineProperty(String propertyName, Class clazz, + int attributes) + { + int length = propertyName.length(); + if (length == 0) throw new IllegalArgumentException(); + char[] buf = new char[3 + length]; + propertyName.getChars(0, length, buf, 3); + buf[3] = Character.toUpperCase(buf[3]); + buf[0] = 'g'; + buf[1] = 'e'; + buf[2] = 't'; + String getterName = new String(buf); + buf[0] = 's'; + String setterName = new String(buf); + + Method[] methods = FunctionObject.getMethodList(clazz); + Method getter = FunctionObject.findSingleMethod(methods, getterName); + Method setter = FunctionObject.findSingleMethod(methods, setterName); + if (setter == null) + attributes |= ScriptableObject.READONLY; + defineProperty(propertyName, null, getter, + setter == null ? null : setter, attributes); + } + + /** + * Define a JavaScript property. + * + * Use this method only if you wish to define getters and setters for + * a given property in a ScriptableObject. To create a property without + * special getter or setter side effects, use + * <code>defineProperty(String,int)</code>. + * + * If <code>setter</code> is null, the attribute READONLY is added to + * the given attributes.<p> + * + * Several forms of getters or setters are allowed. In all cases the + * type of the value parameter can be any one of the following types: + * Object, String, boolean, Scriptable, byte, short, int, long, float, + * or double. The runtime will perform appropriate conversions based + * upon the type of the parameter (see description in FunctionObject). + * The first forms are nonstatic methods of the class referred to + * by 'this': + * <pre> + * Object getFoo(); + * void setFoo(SomeType value);</pre> + * Next are static methods that may be of any class; the object whose + * property is being accessed is passed in as an extra argument: + * <pre> + * static Object getFoo(Scriptable obj); + * static void setFoo(Scriptable obj, SomeType value);</pre> + * Finally, it is possible to delegate to another object entirely using + * the <code>delegateTo</code> parameter. In this case the methods are + * nonstatic methods of the class delegated to, and the object whose + * property is being accessed is passed in as an extra argument: + * <pre> + * Object getFoo(Scriptable obj); + * void setFoo(Scriptable obj, SomeType value);</pre> + * + * @param propertyName the name of the property to define. + * @param delegateTo an object to call the getter and setter methods on, + * or null, depending on the form used above. + * @param getter the method to invoke to get the value of the property + * @param setter the method to invoke to set the value of the property + * @param attributes the attributes of the JavaScript property + */ + public void defineProperty(String propertyName, Object delegateTo, + Method getter, Method setter, int attributes) + { + MemberBox getterBox = null; + if (getter != null) { + getterBox = new MemberBox(getter); + + boolean delegatedForm; + if (!Modifier.isStatic(getter.getModifiers())) { + delegatedForm = (delegateTo != null); + getterBox.delegateTo = delegateTo; + } else { + delegatedForm = true; + // Ignore delegateTo for static getter but store + // non-null delegateTo indicator. + getterBox.delegateTo = Void.TYPE; + } + + String errorId = null; + Class[] parmTypes = getter.getParameterTypes(); + if (parmTypes.length == 0) { + if (delegatedForm) { + errorId = "msg.obj.getter.parms"; + } + } else if (parmTypes.length == 1) { + Object argType = parmTypes[0]; + // Allow ScriptableObject for compatibility + if (!(argType == ScriptRuntime.ScriptableClass || + argType == ScriptRuntime.ScriptableObjectClass)) + { + errorId = "msg.bad.getter.parms"; + } else if (!delegatedForm) { + errorId = "msg.bad.getter.parms"; + } + } else { + errorId = "msg.bad.getter.parms"; + } + if (errorId != null) { + throw Context.reportRuntimeError1(errorId, getter.toString()); + } + } + + MemberBox setterBox = null; + if (setter != null) { + if (setter.getReturnType() != Void.TYPE) + throw Context.reportRuntimeError1("msg.setter.return", + setter.toString()); + + setterBox = new MemberBox(setter); + + boolean delegatedForm; + if (!Modifier.isStatic(setter.getModifiers())) { + delegatedForm = (delegateTo != null); + setterBox.delegateTo = delegateTo; + } else { + delegatedForm = true; + // Ignore delegateTo for static setter but store + // non-null delegateTo indicator. + setterBox.delegateTo = Void.TYPE; + } + + String errorId = null; + Class[] parmTypes = setter.getParameterTypes(); + if (parmTypes.length == 1) { + if (delegatedForm) { + errorId = "msg.setter2.expected"; + } + } else if (parmTypes.length == 2) { + Object argType = parmTypes[0]; + // Allow ScriptableObject for compatibility + if (!(argType == ScriptRuntime.ScriptableClass || + argType == ScriptRuntime.ScriptableObjectClass)) + { + errorId = "msg.setter2.parms"; + } else if (!delegatedForm) { + errorId = "msg.setter1.parms"; + } + } else { + errorId = "msg.setter.parms"; + } + if (errorId != null) { + throw Context.reportRuntimeError1(errorId, setter.toString()); + } + } + + GetterSlot gslot = (GetterSlot)getSlot(propertyName, 0, + SLOT_MODIFY_GETTER_SETTER); + gslot.setAttributes(attributes); + gslot.getter = getterBox; + gslot.setter = setterBox; + } + + /** + * Search for names in a class, adding the resulting methods + * as properties. + * + * <p> Uses reflection to find the methods of the given names. Then + * FunctionObjects are constructed from the methods found, and + * are added to this object as properties with the given names. + * + * @param names the names of the Methods to add as function properties + * @param clazz the class to search for the Methods + * @param attributes the attributes of the new properties + * @see org.mozilla.javascript.FunctionObject + */ + public void defineFunctionProperties(String[] names, Class clazz, + int attributes) + { + Method[] methods = FunctionObject.getMethodList(clazz); + for (int i=0; i < names.length; i++) { + String name = names[i]; + Method m = FunctionObject.findSingleMethod(methods, name); + if (m == null) { + throw Context.reportRuntimeError2( + "msg.method.not.found", name, clazz.getName()); + } + FunctionObject f = new FunctionObject(name, m, this); + defineProperty(name, f, attributes); + } + } + + /** + * Get the Object.prototype property. + * See ECMA 15.2.4. + */ + public static Scriptable getObjectPrototype(Scriptable scope) { + return getClassPrototype(scope, "Object"); + } + + /** + * Get the Function.prototype property. + * See ECMA 15.3.4. + */ + public static Scriptable getFunctionPrototype(Scriptable scope) { + return getClassPrototype(scope, "Function"); + } + + /** + * Get the prototype for the named class. + * + * For example, <code>getClassPrototype(s, "Date")</code> will first + * walk up the parent chain to find the outermost scope, then will + * search that scope for the Date constructor, and then will + * return Date.prototype. If any of the lookups fail, or + * the prototype is not a JavaScript object, then null will + * be returned. + * + * @param scope an object in the scope chain + * @param className the name of the constructor + * @return the prototype for the named class, or null if it + * cannot be found. + */ + public static Scriptable getClassPrototype(Scriptable scope, + String className) + { + scope = getTopLevelScope(scope); + Object ctor = getProperty(scope, className); + Object proto; + if (ctor instanceof BaseFunction) { + proto = ((BaseFunction)ctor).getPrototypeProperty(); + } else if (ctor instanceof Scriptable) { + Scriptable ctorObj = (Scriptable)ctor; + proto = ctorObj.get("prototype", ctorObj); + } else { + return null; + } + if (proto instanceof Scriptable) { + return (Scriptable)proto; + } + return null; + } + + /** + * Get the global scope. + * + * <p>Walks the parent scope chain to find an object with a null + * parent scope (the global object). + * + * @param obj a JavaScript object + * @return the corresponding global scope + */ + public static Scriptable getTopLevelScope(Scriptable obj) + { + for (;;) { + Scriptable parent = obj.getParentScope(); + if (parent == null) { + return obj; + } + obj = parent; + } + } + + // APPJET + public static Scriptable getVeryTopLevelScope(Scriptable obj) { + return ScriptRuntime.getLibraryScopeOrNull(obj); + } + + /** + * Seal this object. + * + * A sealed object may not have properties added or removed. Once + * an object is sealed it may not be unsealed. + * + * @since 1.4R3 + */ + public synchronized void sealObject() { + if (count >= 0) { + count = ~count; + } + } + + /** + * Return true if this object is sealed. + * + * It is an error to attempt to add or remove properties to + * a sealed object. + * + * @return true if sealed, false otherwise. + * @since 1.4R3 + */ + public final boolean isSealed() { + return count < 0; + } + + private void checkNotSealed(String name, int index) + { + if (!isSealed()) + return; + + String str = (name != null) ? name : Integer.toString(index); + throw Context.reportRuntimeError1("msg.modify.sealed", str); + } + + /** + * Gets a named property from an object or any object in its prototype chain. + * <p> + * Searches the prototype chain for a property named <code>name</code>. + * <p> + * @param obj a JavaScript object + * @param name a property name + * @return the value of a property with name <code>name</code> found in + * <code>obj</code> or any object in its prototype chain, or + * <code>Scriptable.NOT_FOUND</code> if not found + * @since 1.5R2 + */ + public static Object getProperty(Scriptable obj, String name) + { + Scriptable start = obj; + Object result; + do { + result = obj.get(name, start); + if (result != Scriptable.NOT_FOUND) + break; + obj = obj.getPrototype(); + } while (obj != null); + return result; + } + + /** + * Gets an indexed property from an object or any object in its prototype chain. + * <p> + * Searches the prototype chain for a property with integral index + * <code>index</code>. Note that if you wish to look for properties with numerical + * but non-integral indicies, you should use getProperty(Scriptable,String) with + * the string value of the index. + * <p> + * @param obj a JavaScript object + * @param index an integral index + * @return the value of a property with index <code>index</code> found in + * <code>obj</code> or any object in its prototype chain, or + * <code>Scriptable.NOT_FOUND</code> if not found + * @since 1.5R2 + */ + public static Object getProperty(Scriptable obj, int index) + { + Scriptable start = obj; + Object result; + do { + result = obj.get(index, start); + if (result != Scriptable.NOT_FOUND) + break; + obj = obj.getPrototype(); + } while (obj != null); + return result; + } + + /** + * Returns whether a named property is defined in an object or any object + * in its prototype chain. + * <p> + * Searches the prototype chain for a property named <code>name</code>. + * <p> + * @param obj a JavaScript object + * @param name a property name + * @return the true if property was found + * @since 1.5R2 + */ + public static boolean hasProperty(Scriptable obj, String name) + { + return null != getBase(obj, name); + } + + /** + * If hasProperty(obj, name) would return true, then if the property that + * was found is compatible with the new property, this method just returns. + * If the property is not compatible, then an exception is thrown. + * + * A property redefinition is incompatible if the first definition was a + * const declaration or if this one is. They are compatible only if neither + * was const. + */ + public static void redefineProperty(Scriptable obj, String name, + boolean isConst) + { + Scriptable base = getBase(obj, name); + if (base == null) + return; + if (base instanceof ConstProperties) { + ConstProperties cp = (ConstProperties)base; + + if (cp.isConst(name)) + throw Context.reportRuntimeError1("msg.const.redecl", name); + } + if (isConst) + throw Context.reportRuntimeError1("msg.var.redecl", name); + } + /** + * Returns whether an indexed property is defined in an object or any object + * in its prototype chain. + * <p> + * Searches the prototype chain for a property with index <code>index</code>. + * <p> + * @param obj a JavaScript object + * @param index a property index + * @return the true if property was found + * @since 1.5R2 + */ + public static boolean hasProperty(Scriptable obj, int index) + { + return null != getBase(obj, index); + } + + /** + * Puts a named property in an object or in an object in its prototype chain. + * <p> + * Searches for the named property in the prototype chain. If it is found, + * the value of the property in <code>obj</code> is changed through a call + * to {@link Scriptable#put(String, Scriptable, Object)} on the + * prototype passing <code>obj</code> as the <code>start</code> argument. + * This allows the prototype to veto the property setting in case the + * prototype defines the property with [[ReadOnly]] attribute. If the + * property is not found, it is added in <code>obj</code>. + * @param obj a JavaScript object + * @param name a property name + * @param value any JavaScript value accepted by Scriptable.put + * @since 1.5R2 + */ + public static void putProperty(Scriptable obj, String name, Object value) + { + Scriptable base = getBase(obj, name); + if (base == null) + base = obj; + base.put(name, obj, value); + } + + /** + * Puts a named property in an object or in an object in its prototype chain. + * <p> + * Searches for the named property in the prototype chain. If it is found, + * the value of the property in <code>obj</code> is changed through a call + * to {@link Scriptable#put(String, Scriptable, Object)} on the + * prototype passing <code>obj</code> as the <code>start</code> argument. + * This allows the prototype to veto the property setting in case the + * prototype defines the property with [[ReadOnly]] attribute. If the + * property is not found, it is added in <code>obj</code>. + * @param obj a JavaScript object + * @param name a property name + * @param value any JavaScript value accepted by Scriptable.put + * @since 1.5R2 + */ + public static void putConstProperty(Scriptable obj, String name, Object value) + { + Scriptable base = getBase(obj, name); + if (base == null) + base = obj; + if (base instanceof ConstProperties) + ((ConstProperties)base).putConst(name, obj, value); + } + + /** + * Puts an indexed property in an object or in an object in its prototype chain. + * <p> + * Searches for the indexed property in the prototype chain. If it is found, + * the value of the property in <code>obj</code> is changed through a call + * to {@link Scriptable#put(int, Scriptable, Object)} on the prototype + * passing <code>obj</code> as the <code>start</code> argument. This allows + * the prototype to veto the property setting in case the prototype defines + * the property with [[ReadOnly]] attribute. If the property is not found, + * it is added in <code>obj</code>. + * @param obj a JavaScript object + * @param index a property index + * @param value any JavaScript value accepted by Scriptable.put + * @since 1.5R2 + */ + public static void putProperty(Scriptable obj, int index, Object value) + { + Scriptable base = getBase(obj, index); + if (base == null) + base = obj; + base.put(index, obj, value); + } + + /** + * Removes the property from an object or its prototype chain. + * <p> + * Searches for a property with <code>name</code> in obj or + * its prototype chain. If it is found, the object's delete + * method is called. + * @param obj a JavaScript object + * @param name a property name + * @return true if the property doesn't exist or was successfully removed + * @since 1.5R2 + */ + public static boolean deleteProperty(Scriptable obj, String name) + { + Scriptable base = getBase(obj, name); + if (base == null) + return true; + base.delete(name); + return !base.has(name, obj); + } + + /** + * Removes the property from an object or its prototype chain. + * <p> + * Searches for a property with <code>index</code> in obj or + * its prototype chain. If it is found, the object's delete + * method is called. + * @param obj a JavaScript object + * @param index a property index + * @return true if the property doesn't exist or was successfully removed + * @since 1.5R2 + */ + public static boolean deleteProperty(Scriptable obj, int index) + { + Scriptable base = getBase(obj, index); + if (base == null) + return true; + base.delete(index); + return !base.has(index, obj); + } + + /** + * Returns an array of all ids from an object and its prototypes. + * <p> + * @param obj a JavaScript object + * @return an array of all ids from all object in the prototype chain. + * If a given id occurs multiple times in the prototype chain, + * it will occur only once in this list. + * @since 1.5R2 + */ + public static Object[] getPropertyIds(Scriptable obj) + { + if (obj == null) { + return ScriptRuntime.emptyArgs; + } + Object[] result = obj.getIds(); + ObjToIntMap map = null; + for (;;) { + obj = obj.getPrototype(); + if (obj == null) { + break; + } + Object[] ids = obj.getIds(); + if (ids.length == 0) { + continue; + } + if (map == null) { + if (result.length == 0) { + result = ids; + continue; + } + map = new ObjToIntMap(result.length + ids.length); + for (int i = 0; i != result.length; ++i) { + map.intern(result[i]); + } + result = null; // Allow to GC the result + } + for (int i = 0; i != ids.length; ++i) { + map.intern(ids[i]); + } + } + if (map != null) { + result = map.getKeys(); + } + return result; + } + + /** + * Call a method of an object. + * @param obj the JavaScript object + * @param methodName the name of the function property + * @param args the arguments for the call + * + * @see Context#getCurrentContext() + */ + public static Object callMethod(Scriptable obj, String methodName, + Object[] args) + { + return callMethod(null, obj, methodName, args); + } + + /** + * Call a method of an object. + * @param cx the Context object associated with the current thread. + * @param obj the JavaScript object + * @param methodName the name of the function property + * @param args the arguments for the call + */ + public static Object callMethod(Context cx, Scriptable obj, + String methodName, + Object[] args) + { + Object funObj = getProperty(obj, methodName); + if (!(funObj instanceof Function)) { + throw ScriptRuntime.notFunctionError(obj, methodName); + } + Function fun = (Function)funObj; + // XXX: What should be the scope when calling funObj? + // The following favor scope stored in the object on the assumption + // that is more useful especially under dynamic scope setup. + // An alternative is to check for dynamic scope flag + // and use ScriptableObject.getTopLevelScope(fun) if the flag is not + // set. But that require access to Context and messy code + // so for now it is not checked. + Scriptable scope = ScriptableObject.getTopLevelScope(obj); + if (cx != null) { + return fun.call(cx, scope, obj, args); + } else { + return Context.call(null, fun, scope, obj, args); + } + } + + private static Scriptable getBase(Scriptable obj, String name) + { + do { + if (obj.has(name, obj)) + break; + obj = obj.getPrototype(); + } while(obj != null); + return obj; + } + + private static Scriptable getBase(Scriptable obj, int index) + { + do { + if (obj.has(index, obj)) + break; + obj = obj.getPrototype(); + } while(obj != null); + return obj; + } + + /** + * Get arbitrary application-specific value associated with this object. + * @param key key object to select particular value. + * @see #associateValue(Object key, Object value) + */ + public final Object getAssociatedValue(Object key) + { + Hashtable h = associatedValues; + if (h == null) + return null; + return h.get(key); + } + + /** + * Get arbitrary application-specific value associated with the top scope + * of the given scope. + * The method first calls {@link #getTopLevelScope(Scriptable scope)} + * and then searches the prototype chain of the top scope for the first + * object containing the associated value with the given key. + * + * @param scope the starting scope. + * @param key key object to select particular value. + * @see #getAssociatedValue(Object key) + */ + public static Object getTopScopeValue(Scriptable scope, Object key) + { + scope = ScriptableObject.getTopLevelScope(scope); + for (;;) { + if (scope instanceof ScriptableObject) { + ScriptableObject so = (ScriptableObject)scope; + Object value = so.getAssociatedValue(key); + if (value != null) { + return value; + } + } + scope = scope.getPrototype(); + if (scope == null) { + return null; + } + } + } + + /** + * Associate arbitrary application-specific value with this object. + * Value can only be associated with the given object and key only once. + * The method ignores any subsequent attempts to change the already + * associated value. + * <p> The associated values are not serialized. + * @param key key object to select particular value. + * @param value the value to associate + * @return the passed value if the method is called first time for the + * given key or old value for any subsequent calls. + * @see #getAssociatedValue(Object key) + */ + public final Object associateValue(Object key, Object value) + { + if (value == null) throw new IllegalArgumentException(); + Hashtable h = associatedValues; + if (h == null) { + synchronized (this) { + h = associatedValues; + if (h == null) { + h = new Hashtable(); + associatedValues = h; + } + } + } + return Kit.initHash(h, key, value); + } + + private Object getImpl(String name, int index, Scriptable start) + { + Slot slot = getSlot(name, index, SLOT_QUERY); + if (slot == null) { + return Scriptable.NOT_FOUND; + } + if (!(slot instanceof GetterSlot)) { + return slot.value; + } + Object getterObj = ((GetterSlot)slot).getter; + if (getterObj != null) { + if (getterObj instanceof MemberBox) { + MemberBox nativeGetter = (MemberBox)getterObj; + Object getterThis; + Object[] args; + if (nativeGetter.delegateTo == null) { + getterThis = start; + args = ScriptRuntime.emptyArgs; + } else { + getterThis = nativeGetter.delegateTo; + args = new Object[] { start }; + } + return nativeGetter.invoke(getterThis, args); + } else { + Function f = (Function)getterObj; + Context cx = Context.getContext(); + return f.call(cx, f.getParentScope(), start, + ScriptRuntime.emptyArgs); + } + } + Object value = slot.value; + if (value instanceof LazilyLoadedCtor) { + LazilyLoadedCtor initializer = (LazilyLoadedCtor)value; + try { + initializer.init(); + } finally { + value = initializer.getValue(); + slot.value = value; + } + } + return value; + } + + /** + * + * @param name + * @param index + * @param start + * @param value + * @param constFlag EMPTY means normal put. UNINITIALIZED_CONST means + * defineConstProperty. READONLY means const initialization expression. + * @return false if this != start and no slot was found. true if this == start + * or this != start and a READONLY slot was found. + */ + private boolean putImpl(String name, int index, Scriptable start, + Object value, int constFlag) + { + Slot slot; + if (this != start) { + slot = getSlot(name, index, SLOT_QUERY); + if (slot == null) { + return false; + } + } else { + checkNotSealed(name, index); + // either const hoisted declaration or initialization + if (constFlag != EMPTY) { + slot = getSlot(name, index, SLOT_MODIFY_CONST); + int attr = slot.getAttributes(); + if ((attr & READONLY) == 0) + throw Context.reportRuntimeError1("msg.var.redecl", name); + if ((attr & UNINITIALIZED_CONST) != 0) { + slot.value = value; + // clear the bit on const initialization + if (constFlag != UNINITIALIZED_CONST) + slot.setAttributes(attr & ~UNINITIALIZED_CONST); + } + return true; + } + slot = getSlot(name, index, SLOT_MODIFY); + } + if ((slot.getAttributes() & READONLY) != 0) + return true; + if (slot instanceof GetterSlot) { + Object setterObj = ((GetterSlot)slot).setter; + if (setterObj != null) { + Context cx = Context.getContext(); + if (setterObj instanceof MemberBox) { + MemberBox nativeSetter = (MemberBox)setterObj; + Class pTypes[] = nativeSetter.argTypes; + // XXX: cache tag since it is already calculated in + // defineProperty ? + Class valueType = pTypes[pTypes.length - 1]; + int tag = FunctionObject.getTypeTag(valueType); + Object actualArg = FunctionObject.convertArg(cx, start, + value, tag); + Object setterThis; + Object[] args; + if (nativeSetter.delegateTo == null) { + setterThis = start; + args = new Object[] { actualArg }; + } else { + setterThis = nativeSetter.delegateTo; + args = new Object[] { start, actualArg }; + } + nativeSetter.invoke(setterThis, args); + } else { + Function f = (Function)setterObj; + f.call(cx, f.getParentScope(), start, + new Object[] { value }); + } + return true; + } + } + if (this == start) { + slot.value = value; + return true; + } else { + return false; + } + } + + private Slot findAttributeSlot(String name, int index, int accessType) + { + Slot slot = getSlot(name, index, accessType); + if (slot == null) { + String str = (name != null ? name : Integer.toString(index)); + throw Context.reportRuntimeError1("msg.prop.not.found", str); + } + return slot; + } + + /** + * Locate the slot with given name or index. + * + * @param name property name or null if slot holds spare array index. + * @param index index or 0 if slot holds property name. + */ + private Slot getSlot(String name, int index, int accessType) + { + Slot slot; + + // Query last access cache and check that it was not deleted. + lastAccessCheck: + { + slot = lastAccess; + if (name != null) { + if (name != slot.name) + break lastAccessCheck; + // No String.equals here as successful slot search update + // name object with fresh reference of the same string. + } else { + if (slot.name != null || index != slot.indexOrHash) + break lastAccessCheck; + } + + if (slot.wasDeleted != 0) + break lastAccessCheck; + + if (accessType == SLOT_MODIFY_GETTER_SETTER && + !(slot instanceof GetterSlot)) + break lastAccessCheck; + + return slot; + } + + slot = accessSlot(name, index, accessType); + if (slot != null) { + // Update the cache + lastAccess = slot; + } + return slot; + } + + private Slot accessSlot(String name, int index, int accessType) + { + int indexOrHash = (name != null ? name.hashCode() : index); + + if (accessType == SLOT_QUERY || + accessType == SLOT_MODIFY || + accessType == SLOT_MODIFY_CONST || + accessType == SLOT_MODIFY_GETTER_SETTER) + { + // Check the hashtable without using synchronization + + Slot[] slotsLocalRef = slots; // Get stable local reference + if (slotsLocalRef == null) { + if (accessType == SLOT_QUERY) + return null; + } else { + int tableSize = slotsLocalRef.length; + int slotIndex = getSlotIndex(tableSize, indexOrHash); + Slot slot = slotsLocalRef[slotIndex]; + while (slot != null) { + String sname = slot.name; + if (sname != null) { + if (sname == name) + break; + if (name != null && indexOrHash == slot.indexOrHash) { + if (name.equals(sname)) { + // This will avoid calling String.equals when + // slot is accessed with same string object + // next time. + slot.name = name; + break; + } + } + } else if (name == null && + indexOrHash == slot.indexOrHash) { + break; + } + slot = slot.next; + } + if (accessType == SLOT_QUERY) { + return slot; + } else if (accessType == SLOT_MODIFY) { + if (slot != null) + return slot; + } else if (accessType == SLOT_MODIFY_GETTER_SETTER) { + if (slot instanceof GetterSlot) + return slot; + } else if (accessType == SLOT_MODIFY_CONST) { + if (slot != null) + return slot; + } + } + + // A new slot has to be inserted or the old has to be replaced + // by GetterSlot. Time to synchronize. + + synchronized (this) { + // Refresh local ref if another thread triggered grow + slotsLocalRef = slots; + int insertPos; + if (count == 0) { + // Always throw away old slots if any on empty insert + slotsLocalRef = new Slot[5]; + slots = slotsLocalRef; + insertPos = getSlotIndex(slotsLocalRef.length, indexOrHash); + } else { + int tableSize = slotsLocalRef.length; + insertPos = getSlotIndex(tableSize, indexOrHash); + Slot prev = slotsLocalRef[insertPos]; + Slot slot = prev; + while (slot != null) { + if (slot.indexOrHash == indexOrHash && + (slot.name == name || + (name != null && name.equals(slot.name)))) + { + break; + } + prev = slot; + slot = slot.next; + } + + if (slot != null) { + // Another thread just added a slot with same + // name/index before this one entered synchronized + // block. This is a race in application code and + // probably indicates bug there. But for the hashtable + // implementation it is harmless with the only + // complication is the need to replace the added slot + // if we need GetterSlot and the old one is not. + if (accessType == SLOT_MODIFY_GETTER_SETTER && + !(slot instanceof GetterSlot)) + { + GetterSlot newSlot = new GetterSlot(name, indexOrHash, + slot.getAttributes()); + newSlot.value = slot.value; + newSlot.next = slot.next; + if (prev == slot) { + slotsLocalRef[insertPos] = newSlot; + } else { + prev.next = newSlot; + } + slot.wasDeleted = (byte)1; + if (slot == lastAccess) { + lastAccess = REMOVED; + } + slot = newSlot; + } else if (accessType == SLOT_MODIFY_CONST) { + return null; + } + return slot; + } + + // Check if the table is not too full before inserting. + if (4 * (count + 1) > 3 * slotsLocalRef.length) { + slotsLocalRef = new Slot[slotsLocalRef.length * 2 + 1]; + copyTable(slots, slotsLocalRef, count); + slots = slotsLocalRef; + insertPos = getSlotIndex(slotsLocalRef.length, + indexOrHash); + } + } + + Slot newSlot = (accessType == SLOT_MODIFY_GETTER_SETTER + ? new GetterSlot(name, indexOrHash, 0) + : new Slot(name, indexOrHash, 0)); + if (accessType == SLOT_MODIFY_CONST) + newSlot.setAttributes(CONST); + ++count; + addKnownAbsentSlot(slotsLocalRef, newSlot, insertPos); + return newSlot; + } + + } else if (accessType == SLOT_REMOVE) { + synchronized (this) { + Slot[] slotsLocalRef = slots; + if (count != 0) { + int tableSize = slots.length; + int slotIndex = getSlotIndex(tableSize, indexOrHash); + Slot prev = slotsLocalRef[slotIndex]; + Slot slot = prev; + while (slot != null) { + if (slot.indexOrHash == indexOrHash && + (slot.name == name || + (name != null && name.equals(slot.name)))) + { + break; + } + prev = slot; + slot = slot.next; + } + if (slot != null && (slot.getAttributes() & PERMANENT) == 0) { + count--; + if (prev == slot) { + slotsLocalRef[slotIndex] = slot.next; + } else { + prev.next = slot.next; + } + // Mark the slot as removed to handle a case when + // another thread manages to put just removed slot + // into lastAccess cache. + slot.wasDeleted = (byte)1; + if (slot == lastAccess) { + lastAccess = REMOVED; + } + } + } + } + return null; + + } else { + throw Kit.codeBug(); + } + } + + private static int getSlotIndex(int tableSize, int indexOrHash) + { + return (indexOrHash & 0x7fffffff) % tableSize; + } + + // Must be inside synchronized (this) + private static void copyTable(Slot[] slots, Slot[] newSlots, int count) + { + if (count == 0) throw Kit.codeBug(); + + int tableSize = newSlots.length; + int i = slots.length; + for (;;) { + --i; + Slot slot = slots[i]; + while (slot != null) { + int insertPos = getSlotIndex(tableSize, slot.indexOrHash); + Slot next = slot.next; + addKnownAbsentSlot(newSlots, slot, insertPos); + slot.next = null; + slot = next; + if (--count == 0) + return; + } + } + } + + /** + * Add slot with keys that are known to absent from the table. + * This is an optimization to use when inserting into empty table, + * after table growth or during deserialization. + */ + private static void addKnownAbsentSlot(Slot[] slots, Slot slot, int insertPos) + { + if (slots[insertPos] == null) { + slots[insertPos] = slot; + } else { + Slot prev = slots[insertPos]; + while (prev.next != null) { + prev = prev.next; + } + prev.next = slot; + } + } + + Object[] getIds(boolean getAll) { + Slot[] s = slots; + Object[] a = ScriptRuntime.emptyArgs; + if (s == null) + return a; + int c = 0; + for (int i=0; i < s.length; i++) { + Slot slot = s[i]; + while (slot != null) { + if (getAll || (slot.getAttributes() & DONTENUM) == 0) { + if (c == 0) + a = new Object[s.length]; + a[c++] = (slot.name != null ? (Object) slot.name + : new Integer(slot.indexOrHash)); + } + slot = slot.next; + } + } + if (c == a.length) + return a; + Object[] result = new Object[c]; + System.arraycopy(a, 0, result, 0, c); + return result; + } + + private synchronized void writeObject(ObjectOutputStream out) + throws IOException + { + out.defaultWriteObject(); + int objectsCount = count; + if (objectsCount < 0) { + // "this" was sealed + objectsCount = ~objectsCount; + } + if (objectsCount == 0) { + out.writeInt(0); + } else { + out.writeInt(slots.length); + for (int i = 0; i < slots.length; ++i) { + Slot slot = slots[i]; + while (slot != null) { + out.writeObject(slot); + slot = slot.next; + if (--objectsCount == 0) + return; + } + } + } + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + lastAccess = REMOVED; + + int tableSize = in.readInt(); + if (tableSize != 0) { + slots = new Slot[tableSize]; + int objectsCount = count; + if (objectsCount < 0) { + // "this" was sealed + objectsCount = ~objectsCount; + } + for (int i = 0; i != objectsCount; ++i) { + Slot slot = (Slot)in.readObject(); + int slotIndex = getSlotIndex(tableSize, slot.indexOrHash); + addKnownAbsentSlot(slots, slot, slotIndex); + } + } + } + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecureCaller.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecureCaller.java new file mode 100644 index 0000000..bc8ed86 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecureCaller.java @@ -0,0 +1,198 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.lang.ref.SoftReference; +import java.lang.reflect.UndeclaredThrowableException; +import java.net.URL; +import java.security.AccessController; +import java.security.CodeSource; +import java.security.PrivilegedAction; +import java.security.PrivilegedActionException; +import java.security.PrivilegedExceptionAction; +import java.security.SecureClassLoader; +import java.util.Map; +import java.util.WeakHashMap; + +/** + * @author Attila Szegedi + */ +public abstract class SecureCaller +{ + private static final byte[] secureCallerImplBytecode = loadBytecode(); + + // We're storing a CodeSource -> (ClassLoader -> SecureRenderer), since we + // need to have one renderer per class loader. We're using weak hash maps + // and soft references all the way, since we don't want to interfere with + // cleanup of either CodeSource or ClassLoader objects. + private static final Map callers = new WeakHashMap(); + + public abstract Object call(Callable callable, Context cx, + Scriptable scope, Scriptable thisObj, Object[] args); + + /** + * Call the specified callable using a protection domain belonging to the + * specified code source. + */ + static Object callSecurely(final CodeSource codeSource, Callable callable, + Context cx, Scriptable scope, Scriptable thisObj, Object[] args) + { + final Thread thread = Thread.currentThread(); + // Run in doPrivileged as we might be checked for "getClassLoader" + // runtime permission + final ClassLoader classLoader = (ClassLoader)AccessController.doPrivileged( + new PrivilegedAction() { + public Object run() { + return thread.getContextClassLoader(); + } + }); + Map classLoaderMap; + synchronized(callers) + { + classLoaderMap = (Map)callers.get(codeSource); + if(classLoaderMap == null) + { + classLoaderMap = new WeakHashMap(); + callers.put(codeSource, classLoaderMap); + } + } + SecureCaller caller; + synchronized(classLoaderMap) + { + SoftReference ref = (SoftReference)classLoaderMap.get(classLoader); + if(ref != null) + { + caller = (SecureCaller)ref.get(); + } + else + { + caller = null; + } + if(caller == null) + { + try + { + // Run in doPrivileged as we'll be checked for + // "createClassLoader" runtime permission + caller = (SecureCaller)AccessController.doPrivileged( + new PrivilegedExceptionAction() + { + public Object run() throws Exception + { + ClassLoader effectiveClassLoader; + Class thisClass = getClass(); + if(classLoader.loadClass(thisClass.getName()) != thisClass) { + effectiveClassLoader = thisClass.getClassLoader(); + } else { + effectiveClassLoader = classLoader; + } + SecureClassLoaderImpl secCl = + new SecureClassLoaderImpl(effectiveClassLoader); + Class c = secCl.defineAndLinkClass( + SecureCaller.class.getName() + "Impl", + secureCallerImplBytecode, codeSource); + return c.newInstance(); + } + }); + classLoaderMap.put(classLoader, new SoftReference(caller)); + } + catch(PrivilegedActionException ex) + { + throw new UndeclaredThrowableException(ex.getCause()); + } + } + } + return caller.call(callable, cx, scope, thisObj, args); + } + + private static class SecureClassLoaderImpl extends SecureClassLoader + { + SecureClassLoaderImpl(ClassLoader parent) + { + super(parent); + } + + Class defineAndLinkClass(String name, byte[] bytes, CodeSource cs) + { + Class cl = defineClass(name, bytes, 0, bytes.length, cs); + resolveClass(cl); + return cl; + } + } + + private static byte[] loadBytecode() + { + return (byte[])AccessController.doPrivileged(new PrivilegedAction() + { + public Object run() + { + return loadBytecodePrivileged(); + } + }); + } + + private static byte[] loadBytecodePrivileged() + { + URL url = SecureCaller.class.getResource("SecureCallerImpl.clazz"); + try + { + InputStream in = url.openStream(); + try + { + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + for(;;) + { + int r = in.read(); + if(r == -1) + { + return bout.toByteArray(); + } + bout.write(r); + } + } + finally + { + in.close(); + } + } + catch(IOException e) + { + throw new UndeclaredThrowableException(e); + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecurityController.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecurityController.java new file mode 100644 index 0000000..ed85dbf --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecurityController.java @@ -0,0 +1,211 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * This class describes the support needed to implement security. + * <p> + * Three main pieces of functionality are required to implement + * security for JavaScript. First, it must be possible to define + * classes with an associated security domain. (This security + * domain may be any object incorporating notion of access + * restrictions that has meaning to an embedding; for a client-side + * JavaScript embedding this would typically be + * java.security.ProtectionDomain or similar object depending on an + * origin URL and/or a digital certificate.) + * Next it must be possible to get a security domain object that + * allows a particular action only if all security domains + * associated with code on the current Java stack allows it. And + * finally, it must be possible to execute script code with + * associated security domain injected into Java stack. + * <p> + * These three pieces of functionality are encapsulated in the + * SecurityController class. + * + * @see org.mozilla.javascript.Context#setSecurityController(SecurityController) + * @see java.lang.ClassLoader + * @since 1.5 Release 4 + */ +public abstract class SecurityController +{ + private static SecurityController global; + +// The method must NOT be public or protected + static SecurityController global() + { + return global; + } + + /** + * Check if global {@link SecurityController} was already installed. + * @see #initGlobal(SecurityController controller) + */ + public static boolean hasGlobal() + { + return global != null; + } + + /** + * Initialize global controller that will be used for all + * security-related operations. The global controller takes precedence + * over already installed {@link Context}-specific controllers and cause + * any subsequent call to + * {@link Context#setSecurityController(SecurityController)} + * to throw an exception. + * <p> + * The method can only be called once. + * + * @see #hasGlobal() + */ + public static void initGlobal(SecurityController controller) + { + if (controller == null) throw new IllegalArgumentException(); + if (global != null) { + throw new SecurityException("Cannot overwrite already installed global SecurityController"); + } + global = controller; + } + + /** + * Get class loader-like object that can be used + * to define classes with the given security context. + * @param parentLoader parent class loader to delegate search for classes + * not defined by the class loader itself + * @param securityDomain some object specifying the security + * context of the code that is defined by the returned class loader. + */ + public abstract GeneratedClassLoader createClassLoader( + ClassLoader parentLoader, Object securityDomain); + + /** + * Create {@link GeneratedClassLoader} with restrictions imposed by + * staticDomain and all current stack frames. + * The method uses the SecurityController instance associated with the + * current {@link Context} to construct proper dynamic domain and create + * corresponding class loader. + * <par> + * If no SecurityController is associated with the current {@link Context} , + * the method calls {@link Context#createClassLoader(ClassLoader parent)}. + * + * @param parent parent class loader. If null, + * {@link Context#getApplicationClassLoader()} will be used. + * @param staticDomain static security domain. + */ + public static GeneratedClassLoader createLoader( + ClassLoader parent, Object staticDomain) + { + Context cx = Context.getContext(); + if (parent == null) { + parent = cx.getApplicationClassLoader(); + } + SecurityController sc = cx.getSecurityController(); + GeneratedClassLoader loader; + if (sc == null) { + loader = cx.createClassLoader(parent); + } else { + Object dynamicDomain = sc.getDynamicSecurityDomain(staticDomain); + loader = sc.createClassLoader(parent, dynamicDomain); + } + return loader; + } + + public static Class getStaticSecurityDomainClass() { + SecurityController sc = Context.getContext().getSecurityController(); + return sc == null ? null : sc.getStaticSecurityDomainClassInternal(); + } + + public Class getStaticSecurityDomainClassInternal() + { + return null; + } + + /** + * Get dynamic security domain that allows an action only if it is allowed + * by the current Java stack and <i>securityDomain</i>. If + * <i>securityDomain</i> is null, return domain representing permissions + * allowed by the current stack. + */ + public abstract Object getDynamicSecurityDomain(Object securityDomain); + + /** + * Call {@link + * Callable#call(Context cx, Scriptable scope, Scriptable thisObj, + * Object[] args)} + * of <i>callable</i> under restricted security domain where an action is + * allowed only if it is allowed according to the Java stack on the + * moment of the <i>execWithDomain</i> call and <i>securityDomain</i>. + * Any call to {@link #getDynamicSecurityDomain(Object)} during + * execution of <tt>callable.call(cx, scope, thisObj, args)</tt> + * should return a domain incorporate restrictions imposed by + * <i>securityDomain</i> and Java stack on the moment of callWithDomain + * invocation. + * <p> + * The method should always be overridden, it is not declared abstract + * for compatibility reasons. + */ + public Object callWithDomain(Object securityDomain, Context cx, + final Callable callable, Scriptable scope, + final Scriptable thisObj, final Object[] args) + { + return execWithDomain(cx, scope, new Script() + { + public Object exec(Context cx, Scriptable scope) + { + return callable.call(cx, scope, thisObj, args); + } + + }, securityDomain); + } + + /** + * @deprecated The application should not override this method and instead + * override + * {@link #callWithDomain(Object securityDomain, Context cx, Callable callable, Scriptable scope, Scriptable thisObj, Object[] args)}. + */ + public Object execWithDomain(Context cx, Scriptable scope, + Script script, Object securityDomain) + { + throw new IllegalStateException("callWithDomain should be overridden"); + } + + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecurityUtilities.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecurityUtilities.java new file mode 100644 index 0000000..275ad92 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SecurityUtilities.java @@ -0,0 +1,80 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.security.ProtectionDomain; + +/** + * @author Attila Szegedi + */ +public class SecurityUtilities +{ + /** + * Retrieves a system property within a privileged block. Use it only when + * the property is used from within Rhino code and is not passed out of it. + * @param name the name of the system property + * @return the value of the system property + */ + public static String getSystemProperty(final String name) + { + return (String)AccessController.doPrivileged( + new PrivilegedAction() + { + public Object run() + { + return System.getProperty(name); + } + }); + } + + public static ProtectionDomain getProtectionDomain(final Class clazz) + { + return (ProtectionDomain)AccessController.doPrivileged( + new PrivilegedAction() + { + public Object run() + { + return clazz.getProtectionDomain(); + } + }); + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SpecialRef.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SpecialRef.java new file mode 100644 index 0000000..b037eaf --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/SpecialRef.java @@ -0,0 +1,151 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov, igor@fastmail.fm + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +class SpecialRef extends Ref +{ + static final long serialVersionUID = -7521596632456797847L; + + private static final int SPECIAL_NONE = 0; + private static final int SPECIAL_PROTO = 1; + private static final int SPECIAL_PARENT = 2; + + private Scriptable target; + private int type; + private String name; + + private SpecialRef(Scriptable target, int type, String name) + { + this.target = target; + this.type = type; + this.name = name; + } + + static Ref createSpecial(Context cx, Object object, String name) + { + Scriptable target = ScriptRuntime.toObjectOrNull(cx, object); + if (target == null) { + throw ScriptRuntime.undefReadError(object, name); + } + + int type; + if (name.equals("__proto__")) { + type = SPECIAL_PROTO; + } else if (name.equals("__parent__")) { + type = SPECIAL_PARENT; + } else { + throw new IllegalArgumentException(name); + } + + if (!cx.hasFeature(Context.FEATURE_PARENT_PROTO_PROPERTIES)) { + // Clear special after checking for valid name! + type = SPECIAL_NONE; + } + + return new SpecialRef(target, type, name); + } + + public Object get(Context cx) + { + switch (type) { + case SPECIAL_NONE: + return ScriptRuntime.getObjectProp(target, name, cx); + case SPECIAL_PROTO: + return target.getPrototype(); + case SPECIAL_PARENT: + return target.getParentScope(); + default: + throw Kit.codeBug(); + } + } + + public Object set(Context cx, Object value) + { + switch (type) { + case SPECIAL_NONE: + return ScriptRuntime.setObjectProp(target, name, value, cx); + case SPECIAL_PROTO: + case SPECIAL_PARENT: + { + Scriptable obj = ScriptRuntime.toObjectOrNull(cx, value); + if (obj != null) { + // Check that obj does not contain on its prototype/scope + // chain to prevent cycles + Scriptable search = obj; + do { + if (search == target) { + throw Context.reportRuntimeError1( + "msg.cyclic.value", name); + } + if (type == SPECIAL_PROTO) { + search = search.getPrototype(); + } else { + search = search.getParentScope(); + } + } while (search != null); + } + if (type == SPECIAL_PROTO) { + target.setPrototype(obj); + } else { + target.setParentScope(obj); + } + return obj; + } + default: + throw Kit.codeBug(); + } + } + + public boolean has(Context cx) + { + if (type == SPECIAL_NONE) { + return ScriptRuntime.hasObjectElem(target, name, cx); + } + return true; + } + + public boolean delete(Context cx) + { + if (type == SPECIAL_NONE) { + return ScriptRuntime.deleteObjectElem(target, name, cx); + } + return false; + } +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Synchronizer.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Synchronizer.java new file mode 100644 index 0000000..f2fca52 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Synchronizer.java @@ -0,0 +1,81 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Delegator.java, released + * Sep 27, 2000. + * + * The Initial Developer of the Original Code is + * Matthias Radestock. <matthias@sorted.org>. + * Portions created by the Initial Developer are Copyright (C) 2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * This class provides support for implementing Java-style synchronized + * methods in Javascript. + * + * Synchronized functions are created from ordinary Javascript + * functions by the <code>Synchronizer</code> constructor, e.g. + * <code>new Packages.org.mozilla.javascript.Synchronizer(fun)</code>. + * The resulting object is a function that establishes an exclusive + * lock on the <code>this</code> object of its invocation. + * + * The Rhino shell provides a short-cut for the creation of + * synchronized methods: <code>sync(fun)</code> has the same effect as + * calling the above constructor. + * + * @see org.mozilla.javascript.Delegator + * @author Matthias Radestock + */ + +public class Synchronizer extends Delegator { + + /** + * Create a new synchronized function from an existing one. + * + * @param obj the existing function + */ + public Synchronizer(Scriptable obj) { + super(obj); + } + + /** + * @see org.mozilla.javascript.Function#call + */ + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + synchronized(thisObj instanceof Wrapper ? ((Wrapper)thisObj).unwrap() : thisObj) { + return ((Function)obj).call(cx,scope,thisObj,args); + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java new file mode 100644 index 0000000..be96487 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java @@ -0,0 +1,436 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Roger Lawrence + * Mike McCabe + * Igor Bukanov + * Bob Jervis + * Milen Nankov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * This class implements the JavaScript scanner. + * + * It is based on the C source files jsscan.c and jsscan.h + * in the jsref package. + * + * @see org.mozilla.javascript.Parser + * + * @author Mike McCabe + * @author Brendan Eich + */ + +public class Token +{ + + // debug flags + public static final boolean printTrees = + /*APPJET: some info not generated with this off; we disable + actual printing in Interpreter and CodeGen */true; + static final boolean printICode = false; + static final boolean printNames = printTrees || printICode; + + /** + * Token types. These values correspond to JSTokenType values in + * jsscan.c. + */ + + public final static int + // start enum + ERROR = -1, // well-known as the only code < EOF + EOF = 0, // end of file token - (not EOF_CHAR) + EOL = 1, // end of line + + // Interpreter reuses the following as bytecodes + FIRST_BYTECODE_TOKEN = 2, + + ENTERWITH = 2, + LEAVEWITH = 3, + RETURN = 4, + GOTO = 5, + IFEQ = 6, + IFNE = 7, + SETNAME = 8, + BITOR = 9, + BITXOR = 10, + BITAND = 11, + EQ = 12, + NE = 13, + LT = 14, + LE = 15, + GT = 16, + GE = 17, + LSH = 18, + RSH = 19, + URSH = 20, + ADD = 21, + SUB = 22, + MUL = 23, + DIV = 24, + MOD = 25, + NOT = 26, + BITNOT = 27, + POS = 28, + NEG = 29, + NEW = 30, + DELPROP = 31, + TYPEOF = 32, + GETPROP = 33, + GETPROPNOWARN = 34, + SETPROP = 35, + GETELEM = 36, + SETELEM = 37, + CALL = 38, + NAME = 39, + NUMBER = 40, + STRING = 41, + NULL = 42, + THIS = 43, + FALSE = 44, + TRUE = 45, + SHEQ = 46, // shallow equality (===) + SHNE = 47, // shallow inequality (!==) + REGEXP = 48, + BINDNAME = 49, + THROW = 50, + RETHROW = 51, // rethrow caught exception: catch (e if ) use it + IN = 52, + INSTANCEOF = 53, + LOCAL_LOAD = 54, + GETVAR = 55, + SETVAR = 56, + CATCH_SCOPE = 57, + ENUM_INIT_KEYS = 58, + ENUM_INIT_VALUES = 59, + ENUM_INIT_ARRAY= 60, + ENUM_NEXT = 61, + ENUM_ID = 62, + THISFN = 63, + RETURN_RESULT = 64, // to return previously stored return result + ARRAYLIT = 65, // array literal + OBJECTLIT = 66, // object literal + GET_REF = 67, // *reference + SET_REF = 68, // *reference = something + DEL_REF = 69, // delete reference + REF_CALL = 70, // f(args) = something or f(args)++ + REF_SPECIAL = 71, // reference for special properties like __proto + YIELD = 72, // JS 1.7 yield pseudo keyword + + // For XML support: + DEFAULTNAMESPACE = 73, // default xml namespace = + ESCXMLATTR = 74, + ESCXMLTEXT = 75, + REF_MEMBER = 76, // Reference for x.@y, x..y etc. + REF_NS_MEMBER = 77, // Reference for x.ns::y, x..ns::y etc. + REF_NAME = 78, // Reference for @y, @[y] etc. + REF_NS_NAME = 79; // Reference for ns::y, @ns::y@[y] etc. + + // End of interpreter bytecodes + public final static int + LAST_BYTECODE_TOKEN = REF_NS_NAME, + + TRY = 80, + SEMI = 81, // semicolon + LB = 82, // left and right brackets + RB = 83, + LC = 84, // left and right curlies (braces) + RC = 85, + LP = 86, // left and right parentheses + RP = 87, + COMMA = 88, // comma operator + + ASSIGN = 89, // simple assignment (=) + ASSIGN_BITOR = 90, // |= + ASSIGN_BITXOR = 91, // ^= + ASSIGN_BITAND = 92, // |= + ASSIGN_LSH = 93, // <<= + ASSIGN_RSH = 94, // >>= + ASSIGN_URSH = 95, // >>>= + ASSIGN_ADD = 96, // += + ASSIGN_SUB = 97, // -= + ASSIGN_MUL = 98, // *= + ASSIGN_DIV = 99, // /= + ASSIGN_MOD = 100; // %= + + public final static int + FIRST_ASSIGN = ASSIGN, + LAST_ASSIGN = ASSIGN_MOD, + + HOOK = 101, // conditional (?:) + COLON = 102, + OR = 103, // logical or (||) + AND = 104, // logical and (&&) + INC = 105, // increment/decrement (++ --) + DEC = 106, + DOT = 107, // member operator (.) + FUNCTION = 108, // function keyword + EXPORT = 109, // export keyword + IMPORT = 110, // import keyword + IF = 111, // if keyword + ELSE = 112, // else keyword + SWITCH = 113, // switch keyword + CASE = 114, // case keyword + DEFAULT = 115, // default keyword + WHILE = 116, // while keyword + DO = 117, // do keyword + FOR = 118, // for keyword + BREAK = 119, // break keyword + CONTINUE = 120, // continue keyword + VAR = 121, // var keyword + WITH = 122, // with keyword + CATCH = 123, // catch keyword + FINALLY = 124, // finally keyword + VOID = 125, // void keyword + RESERVED = 126, // reserved keywords + + EMPTY = 127, + + /* types used for the parse tree - these never get returned + * by the scanner. + */ + + BLOCK = 128, // statement block + LABEL = 129, // label + TARGET = 130, + LOOP = 131, + EXPR_VOID = 132, // expression statement in functions + EXPR_RESULT = 133, // expression statement in scripts + JSR = 134, + SCRIPT = 135, // top-level node for entire script + TYPEOFNAME = 136, // for typeof(simple-name) + USE_STACK = 137, + SETPROP_OP = 138, // x.y op= something + SETELEM_OP = 139, // x[y] op= something + LOCAL_BLOCK = 140, + SET_REF_OP = 141, // *reference op= something + + // For XML support: + DOTDOT = 142, // member operator (..) + COLONCOLON = 143, // namespace::name + XML = 144, // XML type + DOTQUERY = 145, // .() -- e.g., x.emps.emp.(name == "terry") + XMLATTR = 146, // @ + XMLEND = 147, + + // Optimizer-only-tokens + TO_OBJECT = 148, + TO_DOUBLE = 149, + + GET = 150, // JS 1.5 get pseudo keyword + SET = 151, // JS 1.5 set pseudo keyword + LET = 152, // JS 1.7 let pseudo keyword + CONST = 153, + SETCONST = 154, + SETCONSTVAR = 155, + ARRAYCOMP = 156, // array comprehension + LETEXPR = 157, + WITHEXPR = 158, + DEBUGGER = 159, + LAST_TOKEN = 159; + + public static String name(int token) + { + if (!printNames) { + return String.valueOf(token); + } + switch (token) { + case ERROR: return "ERROR"; + case EOF: return "EOF"; + case EOL: return "EOL"; + case ENTERWITH: return "ENTERWITH"; + case LEAVEWITH: return "LEAVEWITH"; + case RETURN: return "RETURN"; + case GOTO: return "GOTO"; + case IFEQ: return "IFEQ"; + case IFNE: return "IFNE"; + case SETNAME: return "SETNAME"; + case BITOR: return "BITOR"; + case BITXOR: return "BITXOR"; + case BITAND: return "BITAND"; + case EQ: return "EQ"; + case NE: return "NE"; + case LT: return "LT"; + case LE: return "LE"; + case GT: return "GT"; + case GE: return "GE"; + case LSH: return "LSH"; + case RSH: return "RSH"; + case URSH: return "URSH"; + case ADD: return "ADD"; + case SUB: return "SUB"; + case MUL: return "MUL"; + case DIV: return "DIV"; + case MOD: return "MOD"; + case NOT: return "NOT"; + case BITNOT: return "BITNOT"; + case POS: return "POS"; + case NEG: return "NEG"; + case NEW: return "NEW"; + case DELPROP: return "DELPROP"; + case TYPEOF: return "TYPEOF"; + case GETPROP: return "GETPROP"; + case GETPROPNOWARN: return "GETPROPNOWARN"; + case SETPROP: return "SETPROP"; + case GETELEM: return "GETELEM"; + case SETELEM: return "SETELEM"; + case CALL: return "CALL"; + case NAME: return "NAME"; + case NUMBER: return "NUMBER"; + case STRING: return "STRING"; + case NULL: return "NULL"; + case THIS: return "THIS"; + case FALSE: return "FALSE"; + case TRUE: return "TRUE"; + case SHEQ: return "SHEQ"; + case SHNE: return "SHNE"; + case REGEXP: return "OBJECT"; + case BINDNAME: return "BINDNAME"; + case THROW: return "THROW"; + case RETHROW: return "RETHROW"; + case IN: return "IN"; + case INSTANCEOF: return "INSTANCEOF"; + case LOCAL_LOAD: return "LOCAL_LOAD"; + case GETVAR: return "GETVAR"; + case SETVAR: return "SETVAR"; + case CATCH_SCOPE: return "CATCH_SCOPE"; + case ENUM_INIT_KEYS: return "ENUM_INIT_KEYS"; + case ENUM_INIT_VALUES:return "ENUM_INIT_VALUES"; + case ENUM_INIT_ARRAY: return "ENUM_INIT_ARRAY"; + case ENUM_NEXT: return "ENUM_NEXT"; + case ENUM_ID: return "ENUM_ID"; + case THISFN: return "THISFN"; + case RETURN_RESULT: return "RETURN_RESULT"; + case ARRAYLIT: return "ARRAYLIT"; + case OBJECTLIT: return "OBJECTLIT"; + case GET_REF: return "GET_REF"; + case SET_REF: return "SET_REF"; + case DEL_REF: return "DEL_REF"; + case REF_CALL: return "REF_CALL"; + case REF_SPECIAL: return "REF_SPECIAL"; + case DEFAULTNAMESPACE:return "DEFAULTNAMESPACE"; + case ESCXMLTEXT: return "ESCXMLTEXT"; + case ESCXMLATTR: return "ESCXMLATTR"; + case REF_MEMBER: return "REF_MEMBER"; + case REF_NS_MEMBER: return "REF_NS_MEMBER"; + case REF_NAME: return "REF_NAME"; + case REF_NS_NAME: return "REF_NS_NAME"; + case TRY: return "TRY"; + case SEMI: return "SEMI"; + case LB: return "LB"; + case RB: return "RB"; + case LC: return "LC"; + case RC: return "RC"; + case LP: return "LP"; + case RP: return "RP"; + case COMMA: return "COMMA"; + case ASSIGN: return "ASSIGN"; + case ASSIGN_BITOR: return "ASSIGN_BITOR"; + case ASSIGN_BITXOR: return "ASSIGN_BITXOR"; + case ASSIGN_BITAND: return "ASSIGN_BITAND"; + case ASSIGN_LSH: return "ASSIGN_LSH"; + case ASSIGN_RSH: return "ASSIGN_RSH"; + case ASSIGN_URSH: return "ASSIGN_URSH"; + case ASSIGN_ADD: return "ASSIGN_ADD"; + case ASSIGN_SUB: return "ASSIGN_SUB"; + case ASSIGN_MUL: return "ASSIGN_MUL"; + case ASSIGN_DIV: return "ASSIGN_DIV"; + case ASSIGN_MOD: return "ASSIGN_MOD"; + case HOOK: return "HOOK"; + case COLON: return "COLON"; + case OR: return "OR"; + case AND: return "AND"; + case INC: return "INC"; + case DEC: return "DEC"; + case DOT: return "DOT"; + case FUNCTION: return "FUNCTION"; + case EXPORT: return "EXPORT"; + case IMPORT: return "IMPORT"; + case IF: return "IF"; + case ELSE: return "ELSE"; + case SWITCH: return "SWITCH"; + case CASE: return "CASE"; + case DEFAULT: return "DEFAULT"; + case WHILE: return "WHILE"; + case DO: return "DO"; + case FOR: return "FOR"; + case BREAK: return "BREAK"; + case CONTINUE: return "CONTINUE"; + case VAR: return "VAR"; + case WITH: return "WITH"; + case CATCH: return "CATCH"; + case FINALLY: return "FINALLY"; + case VOID: return "VOID"; + case RESERVED: return "RESERVED"; + case EMPTY: return "EMPTY"; + case BLOCK: return "BLOCK"; + case LABEL: return "LABEL"; + case TARGET: return "TARGET"; + case LOOP: return "LOOP"; + case EXPR_VOID: return "EXPR_VOID"; + case EXPR_RESULT: return "EXPR_RESULT"; + case JSR: return "JSR"; + case SCRIPT: return "SCRIPT"; + case TYPEOFNAME: return "TYPEOFNAME"; + case USE_STACK: return "USE_STACK"; + case SETPROP_OP: return "SETPROP_OP"; + case SETELEM_OP: return "SETELEM_OP"; + case LOCAL_BLOCK: return "LOCAL_BLOCK"; + case SET_REF_OP: return "SET_REF_OP"; + case DOTDOT: return "DOTDOT"; + case COLONCOLON: return "COLONCOLON"; + case XML: return "XML"; + case DOTQUERY: return "DOTQUERY"; + case XMLATTR: return "XMLATTR"; + case XMLEND: return "XMLEND"; + case TO_OBJECT: return "TO_OBJECT"; + case TO_DOUBLE: return "TO_DOUBLE"; + case GET: return "GET"; + case SET: return "SET"; + case LET: return "LET"; + case YIELD: return "YIELD"; + case CONST: return "CONST"; + case SETCONST: return "SETCONST"; + case ARRAYCOMP: return "ARRAYCOMP"; + case WITHEXPR: return "WITHEXPR"; + case LETEXPR: return "LETEXPR"; + case DEBUGGER: return "DEBUGGER"; + } + + // Token without name + throw new IllegalStateException(String.valueOf(token)); + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/TokenStream.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/TokenStream.java new file mode 100644 index 0000000..c8c3045 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/TokenStream.java @@ -0,0 +1,1500 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Roger Lawrence + * Mike McCabe + * Igor Bukanov + * Ethan Hugg + * Bob Jervis + * Terry Lucas + * Milen Nankov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.*; + +/** + * This class implements the JavaScript scanner. + * + * It is based on the C source files jsscan.c and jsscan.h + * in the jsref package. + * + * @see org.mozilla.javascript.Parser + * + * @author Mike McCabe + * @author Brendan Eich + */ + +class TokenStream +{ + /* + * For chars - because we need something out-of-range + * to check. (And checking EOF by exception is annoying.) + * Note distinction from EOF token type! + */ + private final static int + EOF_CHAR = -1; + + TokenStream(Parser parser, Reader sourceReader, String sourceString, + int lineno) + { + this.parser = parser; + this.lineno = lineno; + if (sourceReader != null) { + if (sourceString != null) Kit.codeBug(); + this.sourceReader = sourceReader; + this.sourceBuffer = new char[512]; + this.sourceEnd = 0; + } else { + if (sourceString == null) Kit.codeBug(); + this.sourceString = sourceString; + this.sourceEnd = sourceString.length(); + } + this.sourceCursor = 0; + } + + /* This function uses the cached op, string and number fields in + * TokenStream; if getToken has been called since the passed token + * was scanned, the op or string printed may be incorrect. + */ + String tokenToString(int token) + { + if (Token.printTrees) { + String name = Token.name(token); + + switch (token) { + case Token.STRING: + case Token.REGEXP: + case Token.NAME: + return name + " `" + this.string + "'"; + + case Token.NUMBER: + return "NUMBER " + this.number; + } + + return name; + } + return ""; + } + + static boolean isKeyword(String s) + { + return Token.EOF != stringToKeyword(s); + } + + private static int stringToKeyword(String name) + { +// #string_id_map# +// The following assumes that Token.EOF == 0 + final int + Id_break = Token.BREAK, + Id_case = Token.CASE, + Id_continue = Token.CONTINUE, + Id_default = Token.DEFAULT, + Id_delete = Token.DELPROP, + Id_do = Token.DO, + Id_else = Token.ELSE, + Id_export = Token.EXPORT, + Id_false = Token.FALSE, + Id_for = Token.FOR, + Id_function = Token.FUNCTION, + Id_if = Token.IF, + Id_in = Token.IN, + Id_let = Token.LET, + Id_new = Token.NEW, + Id_null = Token.NULL, + Id_return = Token.RETURN, + Id_switch = Token.SWITCH, + Id_this = Token.THIS, + Id_true = Token.TRUE, + Id_typeof = Token.TYPEOF, + Id_var = Token.VAR, + Id_void = Token.VOID, + Id_while = Token.WHILE, + Id_with = Token.WITH, + Id_yield = Token.YIELD, + + // the following are #ifdef RESERVE_JAVA_KEYWORDS in jsscan.c + Id_abstract = Token.RESERVED, + Id_boolean = Token.RESERVED, + Id_byte = Token.RESERVED, + Id_catch = Token.CATCH, + Id_char = Token.RESERVED, + Id_class = Token.RESERVED, + Id_const = Token.CONST, + Id_debugger = Token.DEBUGGER, + Id_double = Token.RESERVED, + Id_enum = Token.RESERVED, + Id_extends = Token.RESERVED, + Id_final = Token.RESERVED, + Id_finally = Token.FINALLY, + Id_float = Token.RESERVED, + Id_goto = Token.RESERVED, + Id_implements = Token.RESERVED, + Id_import = Token.IMPORT, + Id_instanceof = Token.INSTANCEOF, + Id_int = Token.RESERVED, + Id_interface = Token.RESERVED, + Id_long = Token.RESERVED, + Id_native = Token.RESERVED, + Id_package = Token.RESERVED, + Id_private = Token.RESERVED, + Id_protected = Token.RESERVED, + Id_public = Token.RESERVED, + Id_short = Token.RESERVED, + Id_static = Token.RESERVED, + Id_super = Token.RESERVED, + Id_synchronized = Token.RESERVED, + Id_throw = Token.THROW, + Id_throws = Token.RESERVED, + Id_transient = Token.RESERVED, + Id_try = Token.TRY, + Id_volatile = Token.RESERVED; + + int id; + String s = name; +// #generated# Last update: 2007-04-18 13:53:30 PDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 2: c=s.charAt(1); + if (c=='f') { if (s.charAt(0)=='i') {id=Id_if; break L0;} } + else if (c=='n') { if (s.charAt(0)=='i') {id=Id_in; break L0;} } + else if (c=='o') { if (s.charAt(0)=='d') {id=Id_do; break L0;} } + break L; + case 3: switch (s.charAt(0)) { + case 'f': if (s.charAt(2)=='r' && s.charAt(1)=='o') {id=Id_for; break L0;} break L; + case 'i': if (s.charAt(2)=='t' && s.charAt(1)=='n') {id=Id_int; break L0;} break L; + case 'l': if (s.charAt(2)=='t' && s.charAt(1)=='e') {id=Id_let; break L0;} break L; + case 'n': if (s.charAt(2)=='w' && s.charAt(1)=='e') {id=Id_new; break L0;} break L; + case 't': if (s.charAt(2)=='y' && s.charAt(1)=='r') {id=Id_try; break L0;} break L; + case 'v': if (s.charAt(2)=='r' && s.charAt(1)=='a') {id=Id_var; break L0;} break L; + } break L; + case 4: switch (s.charAt(0)) { + case 'b': X="byte";id=Id_byte; break L; + case 'c': c=s.charAt(3); + if (c=='e') { if (s.charAt(2)=='s' && s.charAt(1)=='a') {id=Id_case; break L0;} } + else if (c=='r') { if (s.charAt(2)=='a' && s.charAt(1)=='h') {id=Id_char; break L0;} } + break L; + case 'e': c=s.charAt(3); + if (c=='e') { if (s.charAt(2)=='s' && s.charAt(1)=='l') {id=Id_else; break L0;} } + else if (c=='m') { if (s.charAt(2)=='u' && s.charAt(1)=='n') {id=Id_enum; break L0;} } + break L; + case 'g': X="goto";id=Id_goto; break L; + case 'l': X="long";id=Id_long; break L; + case 'n': X="null";id=Id_null; break L; + case 't': c=s.charAt(3); + if (c=='e') { if (s.charAt(2)=='u' && s.charAt(1)=='r') {id=Id_true; break L0;} } + else if (c=='s') { if (s.charAt(2)=='i' && s.charAt(1)=='h') {id=Id_this; break L0;} } + break L; + case 'v': X="void";id=Id_void; break L; + case 'w': X="with";id=Id_with; break L; + } break L; + case 5: switch (s.charAt(2)) { + case 'a': X="class";id=Id_class; break L; + case 'e': c=s.charAt(0); + if (c=='b') { X="break";id=Id_break; } + else if (c=='y') { X="yield";id=Id_yield; } + break L; + case 'i': X="while";id=Id_while; break L; + case 'l': X="false";id=Id_false; break L; + case 'n': c=s.charAt(0); + if (c=='c') { X="const";id=Id_const; } + else if (c=='f') { X="final";id=Id_final; } + break L; + case 'o': c=s.charAt(0); + if (c=='f') { X="float";id=Id_float; } + else if (c=='s') { X="short";id=Id_short; } + break L; + case 'p': X="super";id=Id_super; break L; + case 'r': X="throw";id=Id_throw; break L; + case 't': X="catch";id=Id_catch; break L; + } break L; + case 6: switch (s.charAt(1)) { + case 'a': X="native";id=Id_native; break L; + case 'e': c=s.charAt(0); + if (c=='d') { X="delete";id=Id_delete; } + else if (c=='r') { X="return";id=Id_return; } + break L; + case 'h': X="throws";id=Id_throws; break L; + /*APPJET*//* case 'm': X="import";id=Id_import; break L;*/ + case 'o': X="double";id=Id_double; break L; + case 't': X="static";id=Id_static; break L; + case 'u': X="public";id=Id_public; break L; + case 'w': X="switch";id=Id_switch; break L; + case 'x': X="export";id=Id_export; break L; + case 'y': X="typeof";id=Id_typeof; break L; + } break L; + case 7: switch (s.charAt(1)) { + case 'a': X="package";id=Id_package; break L; + case 'e': X="default";id=Id_default; break L; + case 'i': X="finally";id=Id_finally; break L; + case 'o': X="boolean";id=Id_boolean; break L; + case 'r': X="private";id=Id_private; break L; + case 'x': X="extends";id=Id_extends; break L; + } break L; + case 8: switch (s.charAt(0)) { + case 'a': X="abstract";id=Id_abstract; break L; + case 'c': X="continue";id=Id_continue; break L; + case 'd': X="debugger";id=Id_debugger; break L; + case 'f': X="function";id=Id_function; break L; + case 'v': X="volatile";id=Id_volatile; break L; + } break L; + case 9: c=s.charAt(0); + if (c=='i') { X="interface";id=Id_interface; } + else if (c=='p') { X="protected";id=Id_protected; } + else if (c=='t') { X="transient";id=Id_transient; } + break L; + case 10: c=s.charAt(1); + if (c=='m') { X="implements";id=Id_implements; } + else if (c=='n') { X="instanceof";id=Id_instanceof; } + break L; + case 12: X="synchronized";id=Id_synchronized; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + } +// #/generated# +// #/string_id_map# + if (id == 0) { return Token.EOF; } + return id & 0xff; + } + + final int getLineno() { return lineno; } + + final String getString() { return string; } + + final double getNumber() { return number; } + + final boolean eof() { return hitEOF; } + + final int getToken() throws IOException + { + int c; + + retry: + for (;;) { + // Eat whitespace, possibly sensitive to newlines. + for (;;) { + c = getChar(); + if (c == EOF_CHAR) { + return Token.EOF; + } else if (c == '\n') { + dirtyLine = false; + return Token.EOL; + } else if (!isJSSpace(c)) { + if (c != '-') { + dirtyLine = true; + } + break; + } + } + + if (c == '@') return Token.XMLATTR; + + // identifier/keyword/instanceof? + // watch out for starting with a <backslash> + boolean identifierStart; + boolean isUnicodeEscapeStart = false; + if (c == '\\') { + c = getChar(); + if (c == 'u') { + identifierStart = true; + isUnicodeEscapeStart = true; + stringBufferTop = 0; + } else { + identifierStart = false; + ungetChar(c); + c = '\\'; + } + } else { + identifierStart = Character.isJavaIdentifierStart((char)c); + if (identifierStart) { + stringBufferTop = 0; + addToString(c); + } + } + + if (identifierStart) { + boolean containsEscape = isUnicodeEscapeStart; + for (;;) { + if (isUnicodeEscapeStart) { + // strictly speaking we should probably push-back + // all the bad characters if the <backslash>uXXXX + // sequence is malformed. But since there isn't a + // correct context(is there?) for a bad Unicode + // escape sequence in an identifier, we can report + // an error here. + int escapeVal = 0; + for (int i = 0; i != 4; ++i) { + c = getChar(); + escapeVal = Kit.xDigitToInt(c, escapeVal); + // Next check takes care about c < 0 and bad escape + if (escapeVal < 0) { break; } + } + if (escapeVal < 0) { + parser.addError("msg.invalid.escape"); + return Token.ERROR; + } + addToString(escapeVal); + isUnicodeEscapeStart = false; + } else { + c = getChar(); + if (c == '\\') { + c = getChar(); + if (c == 'u') { + isUnicodeEscapeStart = true; + containsEscape = true; + } else { + /*APPJET*/ + parser.addError("msg.illegal.character.appjet", + "\\"+Character.toString((char)c)); + return Token.ERROR; + } + } else { + if (c == EOF_CHAR + || !Character.isJavaIdentifierPart((char)c)) + { + break; + } + addToString(c); + } + } + } + ungetChar(c); + + String str = getStringFromBuffer(); + /*APPJET*//*MOVED*/this.string = (String)allStrings.intern(str); + /*APPJET this move lets the names of RESERVED tokens and other + tokens be determined, and also fixes broken yield/let parsing + under pre-1.7 JS */ + if (!containsEscape) { + // OPT we shouldn't have to make a string (object!) to + // check if it's a keyword. + + // Return the corresponding token if it's a keyword + int result = stringToKeyword(str); + if (result != Token.EOF) { + if ((result == Token.LET || result == Token.YIELD) && + parser.compilerEnv.getLanguageVersion() + < Context.VERSION_1_7) + { + // LET and YIELD are tokens only in 1.7 and later + result = Token.NAME; + } + if (result != Token.RESERVED) { + return result; + } else if (!parser.compilerEnv. + isReservedKeywordAsIdentifier()) + { + return result; + } else { + // If implementation permits to use future reserved + // keywords in violation with the EcmaScript, + // treat it as name but issue warning + parser.addWarning("msg.reserved.keyword", str); + } + } + } + return Token.NAME; + } + + // is it a number? + if (isDigit(c) || (c == '.' && isDigit(peekChar()))) { + + stringBufferTop = 0; + int base = 10; + + if (c == '0') { + c = getChar(); + if (c == 'x' || c == 'X') { + base = 16; + c = getChar(); + } else if (isDigit(c)) { + base = 8; + } else { + addToString('0'); + } + } + + if (base == 16) { + while (0 <= Kit.xDigitToInt(c, 0)) { + addToString(c); + c = getChar(); + } + } else { + while ('0' <= c && c <= '9') { + /* + * We permit 08 and 09 as decimal numbers, which + * makes our behavior a superset of the ECMA + * numeric grammar. We might not always be so + * permissive, so we warn about it. + */ + if (base == 8 && c >= '8') { + parser.addWarning("msg.bad.octal.literal", + c == '8' ? "8" : "9"); + base = 10; + } + addToString(c); + c = getChar(); + } + } + + boolean isInteger = true; + + if (base == 10 && (c == '.' || c == 'e' || c == 'E')) { + isInteger = false; + if (c == '.') { + do { + addToString(c); + c = getChar(); + } while (isDigit(c)); + } + if (c == 'e' || c == 'E') { + addToString(c); + c = getChar(); + if (c == '+' || c == '-') { + addToString(c); + c = getChar(); + } + if (!isDigit(c)) { + parser.addError("msg.missing.exponent"); + return Token.ERROR; + } + do { + addToString(c); + c = getChar(); + } while (isDigit(c)); + } + } + ungetChar(c); + String numString = getStringFromBuffer(); + + double dval; + if (base == 10 && !isInteger) { + try { + // Use Java conversion to number from string... + dval = Double.valueOf(numString).doubleValue(); + } + catch (NumberFormatException ex) { + parser.addError("msg.caught.nfe"); + return Token.ERROR; + } + } else { + dval = ScriptRuntime.stringToNumber(numString, 0, base); + } + + this.number = dval; + return Token.NUMBER; + } + + // is it a string? + if (c == '"' || c == '\'') { + // We attempt to accumulate a string the fast way, by + // building it directly out of the reader. But if there + // are any escaped characters in the string, we revert to + // building it out of a StringBuffer. + + /*APPJET*/ + if (c == '"' && tryReadTripleQuotedString()) { + return Token.STRING; + } + + int quoteChar = c; + stringBufferTop = 0; + + c = getChar(); + strLoop: while (c != quoteChar) { + if (c == '\n' || c == EOF_CHAR) { + ungetChar(c); + /*APPJET*/ + parser.addError("msg.unterminated.string.lit", + Character.toString((char)quoteChar)); + return Token.ERROR; + } + + if (c == '\\') { + // We've hit an escaped character + int escapeVal; + + c = getChar(); + switch (c) { + case 'b': c = '\b'; break; + case 'f': c = '\f'; break; + case 'n': c = '\n'; break; + case 'r': c = '\r'; break; + case 't': c = '\t'; break; + + // \v a late addition to the ECMA spec, + // it is not in Java, so use 0xb + case 'v': c = 0xb; break; + + case 'u': + // Get 4 hex digits; if the u escape is not + // followed by 4 hex digits, use 'u' + the + // literal character sequence that follows. + int escapeStart = stringBufferTop; + addToString('u'); + escapeVal = 0; + for (int i = 0; i != 4; ++i) { + c = getChar(); + escapeVal = Kit.xDigitToInt(c, escapeVal); + if (escapeVal < 0) { + continue strLoop; + } + addToString(c); + } + // prepare for replace of stored 'u' sequence + // by escape value + stringBufferTop = escapeStart; + c = escapeVal; + break; + case 'x': + // Get 2 hex digits, defaulting to 'x'+literal + // sequence, as above. + c = getChar(); + escapeVal = Kit.xDigitToInt(c, 0); + if (escapeVal < 0) { + addToString('x'); + continue strLoop; + } else { + int c1 = c; + c = getChar(); + escapeVal = Kit.xDigitToInt(c, escapeVal); + if (escapeVal < 0) { + addToString('x'); + addToString(c1); + continue strLoop; + } else { + // got 2 hex digits + c = escapeVal; + } + } + break; + + case '\n': + // Remove line terminator after escape to follow + // SpiderMonkey and C/C++ + c = getChar(); + continue strLoop; + + default: + if ('0' <= c && c < '8') { + int val = c - '0'; + c = getChar(); + if ('0' <= c && c < '8') { + val = 8 * val + c - '0'; + c = getChar(); + if ('0' <= c && c < '8' && val <= 037) { + // c is 3rd char of octal sequence only + // if the resulting val <= 0377 + val = 8 * val + c - '0'; + c = getChar(); + } + } + ungetChar(c); + c = val; + } + } + } + addToString(c); + c = getChar(); + } + + String str = getStringFromBuffer(); + this.string = (String)allStrings.intern(str); + return Token.STRING; + } + + switch (c) { + case ';': return Token.SEMI; + case '[': return Token.LB; + case ']': return Token.RB; + case '{': return Token.LC; + case '}': return Token.RC; + case '(': return Token.LP; + case ')': return Token.RP; + case ',': return Token.COMMA; + case '?': return Token.HOOK; + case ':': + if (matchChar(':')) { + return Token.COLONCOLON; + } else { + return Token.COLON; + } + case '.': + if (matchChar('.')) { + return Token.DOTDOT; + } else if (matchChar('(')) { + return Token.DOTQUERY; + } else { + return Token.DOT; + } + + case '|': + if (matchChar('|')) { + return Token.OR; + } else if (matchChar('=')) { + return Token.ASSIGN_BITOR; + } else { + return Token.BITOR; + } + + case '^': + if (matchChar('=')) { + return Token.ASSIGN_BITXOR; + } else { + return Token.BITXOR; + } + + case '&': + if (matchChar('&')) { + return Token.AND; + } else if (matchChar('=')) { + return Token.ASSIGN_BITAND; + } else { + return Token.BITAND; + } + + case '=': + if (matchChar('=')) { + if (matchChar('=')) + return Token.SHEQ; + else + return Token.EQ; + } else { + return Token.ASSIGN; + } + + case '!': + if (matchChar('=')) { + if (matchChar('=')) + return Token.SHNE; + else + return Token.NE; + } else { + return Token.NOT; + } + + case '<': + /* NB:treat HTML begin-comment as comment-till-eol */ + if (matchChar('!')) { + if (matchChar('-')) { + if (matchChar('-')) { + skipLine(); + continue retry; + } + ungetChar('-'); + } + ungetChar('!'); + } + if (matchChar('<')) { + if (matchChar('=')) { + return Token.ASSIGN_LSH; + } else { + return Token.LSH; + } + } else { + if (matchChar('=')) { + return Token.LE; + } else { + return Token.LT; + } + } + + case '>': + if (matchChar('>')) { + if (matchChar('>')) { + if (matchChar('=')) { + return Token.ASSIGN_URSH; + } else { + return Token.URSH; + } + } else { + if (matchChar('=')) { + return Token.ASSIGN_RSH; + } else { + return Token.RSH; + } + } + } else { + if (matchChar('=')) { + return Token.GE; + } else { + return Token.GT; + } + } + + case '*': + if (matchChar('=')) { + return Token.ASSIGN_MUL; + } else { + return Token.MUL; + } + + case '/': + // is it a // comment? + if (matchChar('/')) { + skipLine(); + continue retry; + } + if (matchChar('*')) { + boolean lookForSlash = false; + for (;;) { + c = getChar(); + if (c == EOF_CHAR) { + parser.addError("msg.unterminated.comment"); + return Token.ERROR; + } else if (c == '*') { + lookForSlash = true; + } else if (c == '/') { + if (lookForSlash) { + continue retry; + } + } else { + lookForSlash = false; + } + } + } + + if (matchChar('=')) { + return Token.ASSIGN_DIV; + } else { + return Token.DIV; + } + + case '%': + if (matchChar('=')) { + return Token.ASSIGN_MOD; + } else { + return Token.MOD; + } + + case '~': + return Token.BITNOT; + + case '+': + if (matchChar('=')) { + return Token.ASSIGN_ADD; + } else if (matchChar('+')) { + return Token.INC; + } else { + return Token.ADD; + } + + case '-': + if (matchChar('=')) { + c = Token.ASSIGN_SUB; + } else if (matchChar('-')) { + if (!dirtyLine) { + // treat HTML end-comment after possible whitespace + // after line start as comment-utill-eol + if (matchChar('>')) { + skipLine(); + continue retry; + } + } + c = Token.DEC; + } else { + c = Token.SUB; + } + dirtyLine = true; + return c; + + default: + /*APPJET*/ + parser.addError("msg.illegal.character.appjet", + Character.toString((char)c)); + return Token.ERROR; + } + } + } + + private static boolean isAlpha(int c) + { + // Use 'Z' < 'a' + if (c <= 'Z') { + return 'A' <= c; + } else { + return 'a' <= c && c <= 'z'; + } + } + + static boolean isDigit(int c) + { + return '0' <= c && c <= '9'; + } + + /* As defined in ECMA. jsscan.c uses C isspace() (which allows + * \v, I think.) note that code in getChar() implicitly accepts + * '\r' == \u000D as well. + */ + static boolean isJSSpace(int c) + { + if (c <= 127) { + return c == 0x20 || c == 0x9 || c == 0xC || c == 0xB; + } else { + return c == 0xA0 + || Character.getType((char)c) == Character.SPACE_SEPARATOR; + } + } + + private static boolean isJSFormatChar(int c) + { + return c > 127 && Character.getType((char)c) == Character.FORMAT; + } + + /** + * Parser calls the method when it gets / or /= in literal context. + */ + void readRegExp(int startToken) + throws IOException + { + stringBufferTop = 0; + if (startToken == Token.ASSIGN_DIV) { + // Miss-scanned /= + addToString('='); + } else { + if (startToken != Token.DIV) Kit.codeBug(); + } + + int c; + while ((c = getChar()) != '/') { + if (c == '\n' || c == EOF_CHAR) { + ungetChar(c); + throw parser.reportError("msg.unterminated.re.lit"); + } + if (c == '\\') { + addToString(c); + c = getChar(); + } + + addToString(c); + } + int reEnd = stringBufferTop; + + while (true) { + if (matchChar('g')) + addToString('g'); + else if (matchChar('i')) + addToString('i'); + else if (matchChar('m')) + addToString('m'); + else + break; + } + + if (isAlpha(peekChar())) { + throw parser.reportError("msg.invalid.re.flag"); + } + + this.string = new String(stringBuffer, 0, reEnd); + this.regExpFlags = new String(stringBuffer, reEnd, + stringBufferTop - reEnd); + } + + boolean isXMLAttribute() + { + return xmlIsAttribute; + } + + int getFirstXMLToken() throws IOException + { + xmlOpenTagsCount = 0; + xmlIsAttribute = false; + xmlIsTagContent = false; + ungetChar('<'); + return getNextXMLToken(); + } + + int getNextXMLToken() throws IOException + { + stringBufferTop = 0; // remember the XML + + for (int c = getChar(); c != EOF_CHAR; c = getChar()) { + if (xmlIsTagContent) { + switch (c) { + case '>': + addToString(c); + xmlIsTagContent = false; + xmlIsAttribute = false; + break; + case '/': + addToString(c); + if (peekChar() == '>') { + c = getChar(); + addToString(c); + xmlIsTagContent = false; + xmlOpenTagsCount--; + } + break; + case '{': + ungetChar(c); + this.string = getStringFromBuffer(); + return Token.XML; + case '\'': + case '"': + addToString(c); + if (!readQuotedString(c)) return Token.ERROR; + break; + case '=': + addToString(c); + xmlIsAttribute = true; + break; + case ' ': + case '\t': + case '\r': + case '\n': + addToString(c); + break; + default: + addToString(c); + xmlIsAttribute = false; + break; + } + + if (!xmlIsTagContent && xmlOpenTagsCount == 0) { + this.string = getStringFromBuffer(); + return Token.XMLEND; + } + } else { + switch (c) { + case '<': + addToString(c); + c = peekChar(); + switch (c) { + case '!': + c = getChar(); // Skip ! + addToString(c); + c = peekChar(); + switch (c) { + case '-': + c = getChar(); // Skip - + addToString(c); + c = getChar(); + if (c == '-') { + addToString(c); + if(!readXmlComment()) return Token.ERROR; + } else { + // throw away the string in progress + stringBufferTop = 0; + this.string = null; + parser.addError("msg.XML.bad.form"); + return Token.ERROR; + } + break; + case '[': + c = getChar(); // Skip [ + addToString(c); + if (getChar() == 'C' && + getChar() == 'D' && + getChar() == 'A' && + getChar() == 'T' && + getChar() == 'A' && + getChar() == '[') + { + addToString('C'); + addToString('D'); + addToString('A'); + addToString('T'); + addToString('A'); + addToString('['); + if (!readCDATA()) return Token.ERROR; + + } else { + // throw away the string in progress + stringBufferTop = 0; + this.string = null; + parser.addError("msg.XML.bad.form"); + return Token.ERROR; + } + break; + default: + if(!readEntity()) return Token.ERROR; + break; + } + break; + case '?': + c = getChar(); // Skip ? + addToString(c); + if (!readPI()) return Token.ERROR; + break; + case '/': + // End tag + c = getChar(); // Skip / + addToString(c); + if (xmlOpenTagsCount == 0) { + // throw away the string in progress + stringBufferTop = 0; + this.string = null; + parser.addError("msg.XML.bad.form"); + return Token.ERROR; + } + xmlIsTagContent = true; + xmlOpenTagsCount--; + break; + default: + // Start tag + xmlIsTagContent = true; + xmlOpenTagsCount++; + break; + } + break; + case '{': + ungetChar(c); + this.string = getStringFromBuffer(); + return Token.XML; + default: + addToString(c); + break; + } + } + } + + stringBufferTop = 0; // throw away the string in progress + this.string = null; + parser.addError("msg.XML.bad.form"); + return Token.ERROR; + } + + /** + * + */ + private boolean readQuotedString(int quote) throws IOException + { + for (int c = getChar(); c != EOF_CHAR; c = getChar()) { + addToString(c); + if (c == quote) return true; + } + + stringBufferTop = 0; // throw away the string in progress + this.string = null; + parser.addError("msg.XML.bad.form"); + return false; + } + + /** + * + */ + private boolean readXmlComment() throws IOException + { + for (int c = getChar(); c != EOF_CHAR;) { + addToString(c); + if (c == '-' && peekChar() == '-') { + c = getChar(); + addToString(c); + if (peekChar() == '>') { + c = getChar(); // Skip > + addToString(c); + return true; + } else { + continue; + } + } + c = getChar(); + } + + stringBufferTop = 0; // throw away the string in progress + this.string = null; + parser.addError("msg.XML.bad.form"); + return false; + } + + /** + * + */ + private boolean readCDATA() throws IOException + { + for (int c = getChar(); c != EOF_CHAR;) { + addToString(c); + if (c == ']' && peekChar() == ']') { + c = getChar(); + addToString(c); + if (peekChar() == '>') { + c = getChar(); // Skip > + addToString(c); + return true; + } else { + continue; + } + } + c = getChar(); + } + + stringBufferTop = 0; // throw away the string in progress + this.string = null; + parser.addError("msg.XML.bad.form"); + return false; + } + + /** + * + */ + private boolean readEntity() throws IOException + { + int declTags = 1; + for (int c = getChar(); c != EOF_CHAR; c = getChar()) { + addToString(c); + switch (c) { + case '<': + declTags++; + break; + case '>': + declTags--; + if (declTags == 0) return true; + break; + } + } + + stringBufferTop = 0; // throw away the string in progress + this.string = null; + parser.addError("msg.XML.bad.form"); + return false; + } + + /** + * + */ + private boolean readPI() throws IOException + { + for (int c = getChar(); c != EOF_CHAR; c = getChar()) { + addToString(c); + if (c == '?' && peekChar() == '>') { + c = getChar(); // Skip > + addToString(c); + return true; + } + } + + stringBufferTop = 0; // throw away the string in progress + this.string = null; + parser.addError("msg.XML.bad.form"); + return false; + } + + private String getStringFromBuffer() + { + return new String(stringBuffer, 0, stringBufferTop); + } + + private void addToString(int c) + { + int N = stringBufferTop; + if (N == stringBuffer.length) { + char[] tmp = new char[stringBuffer.length * 2]; + System.arraycopy(stringBuffer, 0, tmp, 0, N); + stringBuffer = tmp; + } + stringBuffer[N] = (char)c; + stringBufferTop = N + 1; + } + + private void ungetChar(int c) + { + // can not unread past across line boundary + if (ungetCursor != 0 && ungetBuffer[ungetCursor - 1] == '\n') + Kit.codeBug(); + ungetBuffer[ungetCursor++] = c; + } + + private boolean matchChar(int test) throws IOException + { + int c = getChar(); + if (c == test) { + return true; + } else { + ungetChar(c); + return false; + } + } + + private int peekChar() throws IOException + { + int c = getChar(); + ungetChar(c); + return c; + } + + private int getChar() throws IOException + { + if (ungetCursor != 0) { + return ungetBuffer[--ungetCursor]; + } + + for(;;) { + int c; + if (sourceString != null) { + if (sourceCursor == sourceEnd) { + hitEOF = true; + return EOF_CHAR; + } + c = sourceString.charAt(sourceCursor++); + } else { + if (sourceCursor == sourceEnd) { + if (!fillSourceBuffer()) { + hitEOF = true; + return EOF_CHAR; + } + } + c = sourceBuffer[sourceCursor++]; + } + + if (lineEndChar >= 0) { + if (lineEndChar == '\r' && c == '\n') { + lineEndChar = '\n'; + continue; + } + lineEndChar = -1; + lineStart = sourceCursor - 1; + lineno++; + } + + if (c <= 127) { + if (c == '\n' || c == '\r') { + lineEndChar = c; + c = '\n'; + } + } else { + if (isJSFormatChar(c)) { + continue; + } + if (ScriptRuntime.isJSLineTerminator(c)) { + lineEndChar = c; + c = '\n'; + } + } + return c; + } + } + + private void skipLine() throws IOException + { + // skip to end of line + int c; + while ((c = getChar()) != EOF_CHAR && c != '\n') { } + ungetChar(c); + } + + final int getOffset() + { + int n = sourceCursor - lineStart; + if (lineEndChar >= 0) { --n; } + return n; + } + + final String getLine() + { + if (sourceString != null) { + // String case + int lineEnd = sourceCursor; + if (lineEndChar >= 0) { + --lineEnd; + } else { + for (; lineEnd != sourceEnd; ++lineEnd) { + int c = sourceString.charAt(lineEnd); + if (ScriptRuntime.isJSLineTerminator(c)) { + break; + } + } + } + return sourceString.substring(lineStart, lineEnd); + } else { + // Reader case + int lineLength = sourceCursor - lineStart; + if (lineEndChar >= 0) { + --lineLength; + } else { + // Read until the end of line + for (;; ++lineLength) { + int i = lineStart + lineLength; + if (i == sourceEnd) { + try { + if (!fillSourceBuffer()) { break; } + } catch (IOException ioe) { + // ignore it, we're already displaying an error... + break; + } + // i recalculuation as fillSourceBuffer can move saved + // line buffer and change lineStart + i = lineStart + lineLength; + } + int c = sourceBuffer[i]; + if (ScriptRuntime.isJSLineTerminator(c)) { + break; + } + } + } + return new String(sourceBuffer, lineStart, lineLength); + } + } + + private boolean fillSourceBuffer() throws IOException + { + if (sourceString != null) Kit.codeBug(); + if (sourceEnd == sourceBuffer.length) { + if (lineStart != 0) { + System.arraycopy(sourceBuffer, lineStart, sourceBuffer, 0, + sourceEnd - lineStart); + sourceEnd -= lineStart; + sourceCursor -= lineStart; + lineStart = 0; + } else { + char[] tmp = new char[sourceBuffer.length * 2]; + System.arraycopy(sourceBuffer, 0, tmp, 0, sourceEnd); + sourceBuffer = tmp; + } + } + int n = sourceReader.read(sourceBuffer, sourceEnd, + sourceBuffer.length - sourceEnd); + if (n < 0) { + return false; + } + sourceEnd += n; + return true; + } + + // stuff other than whitespace since start of line + private boolean dirtyLine; + + String regExpFlags; + + // Set this to an inital non-null value so that the Parser has + // something to retrieve even if an error has occured and no + // string is found. Fosters one class of error, but saves lots of + // code. + private String string = ""; + private double number; + + private char[] stringBuffer = new char[128]; + private int stringBufferTop; + private ObjToIntMap allStrings = new ObjToIntMap(50); + + // Room to backtrace from to < on failed match of the last - in <!-- + private final int[] ungetBuffer = new int[3]; + private int ungetCursor; + + private boolean hitEOF = false; + + private int lineStart = 0; + private int lineno; + private int lineEndChar = -1; + + private String sourceString; + private Reader sourceReader; + private char[] sourceBuffer; + private int sourceEnd; + private int sourceCursor; + + // for xml tokenizer + private boolean xmlIsAttribute; + private boolean xmlIsTagContent; + private int xmlOpenTagsCount; + + private Parser parser; + + /*APPJET*//* added method */ + private boolean tryReadTripleQuotedString() throws IOException { + // have to be kind of clever, because we don't want to + // add to the overhead of tokenizing, but there are constraints + // like "once you've gotten a newline and put it back (ungotten it), + // you can't put anything else back" + + // have seen one quote + int c = getChar(); + if (c != '"') { ungetChar(c); return false; } + // have seen two quotes + c = getChar(); + if (c != '"') { + ungetChar(c); + this.string = (String)allStrings.intern(""); + return true; + } + // have seen three quotes + + final boolean newPolicy = false; + + stringBufferTop = 0; + + boolean afterBackslash = false; + boolean done = false; + while (! done) { + c = getChar(); + if (c == EOF_CHAR) { + ungetChar(c); + throw parser.reportError("msg.unterminated.mstring.appjet"); + } + if (c == '"') { + int quoteCount = 0; + int quoteLimit = 3; + if (newPolicy && ! afterBackslash) + quoteLimit = 5; + while (c == '"' && quoteCount < quoteLimit) { + quoteCount++; + c = getChar(); + } + ungetChar(c); + + if (afterBackslash) { + if (quoteCount < 3) addToString('\\'); + } + else if (quoteCount >= 3) { + quoteCount -= 3; + done = true; + } + + while (quoteCount > 0) { + addToString('"'); quoteCount--; + } + afterBackslash = false; + } + else { + if (afterBackslash) { + addToString('\\'); + afterBackslash = false; + } + if (c == '\\') { + afterBackslash = true; + } + else { + addToString(c); + } + } + } + + String str = getStringFromBuffer(); + this.string = (String)allStrings.intern(str); + + return true; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/UintMap.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/UintMap.java new file mode 100644 index 0000000..0027819 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/UintMap.java @@ -0,0 +1,659 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +/** + * Map to associate non-negative integers to objects or integers. + * The map does not synchronize any of its operation, so either use + * it from a single thread or do own synchronization or perform all mutation + * operations on one thread before passing the map to others. + * + * @author Igor Bukanov + * + */ + +public class UintMap implements Serializable +{ + static final long serialVersionUID = 4242698212885848444L; + +// Map implementation via hashtable, +// follows "The Art of Computer Programming" by Donald E. Knuth + + public UintMap() { + this(4); + } + + public UintMap(int initialCapacity) { + if (initialCapacity < 0) Kit.codeBug(); + // Table grow when number of stored keys >= 3/4 of max capacity + int minimalCapacity = initialCapacity * 4 / 3; + int i; + for (i = 2; (1 << i) < minimalCapacity; ++i) { } + power = i; + if (check && power < 2) Kit.codeBug(); + } + + public boolean isEmpty() { + return keyCount == 0; + } + + public int size() { + return keyCount; + } + + public boolean has(int key) { + if (key < 0) Kit.codeBug(); + return 0 <= findIndex(key); + } + + /** + * Get object value assigned with key. + * @return key object value or null if key is absent + */ + public Object getObject(int key) { + if (key < 0) Kit.codeBug(); + if (values != null) { + int index = findIndex(key); + if (0 <= index) { + return values[index]; + } + } + return null; + } + + /** + * Get integer value assigned with key. + * @return key integer value or defaultValue if key is absent + */ + public int getInt(int key, int defaultValue) { + if (key < 0) Kit.codeBug(); + int index = findIndex(key); + if (0 <= index) { + if (ivaluesShift != 0) { + return keys[ivaluesShift + index]; + } + return 0; + } + return defaultValue; + } + + /** + * Get integer value assigned with key. + * @return key integer value or defaultValue if key does not exist or does + * not have int value + * @throws RuntimeException if key does not exist + */ + public int getExistingInt(int key) { + if (key < 0) Kit.codeBug(); + int index = findIndex(key); + if (0 <= index) { + if (ivaluesShift != 0) { + return keys[ivaluesShift + index]; + } + return 0; + } + // Key must exist + Kit.codeBug(); + return 0; + } + + /** + * Set object value of the key. + * If key does not exist, also set its int value to 0. + */ + public void put(int key, Object value) { + if (key < 0) Kit.codeBug(); + int index = ensureIndex(key, false); + if (values == null) { + values = new Object[1 << power]; + } + values[index] = value; + } + + /** + * Set int value of the key. + * If key does not exist, also set its object value to null. + */ + public void put(int key, int value) { + if (key < 0) Kit.codeBug(); + int index = ensureIndex(key, true); + if (ivaluesShift == 0) { + int N = 1 << power; + // keys.length can be N * 2 after clear which set ivaluesShift to 0 + if (keys.length != N * 2) { + int[] tmp = new int[N * 2]; + System.arraycopy(keys, 0, tmp, 0, N); + keys = tmp; + } + ivaluesShift = N; + } + keys[ivaluesShift + index] = value; + } + + public void remove(int key) { + if (key < 0) Kit.codeBug(); + int index = findIndex(key); + if (0 <= index) { + keys[index] = DELETED; + --keyCount; + // Allow to GC value and make sure that new key with the deleted + // slot shall get proper default values + if (values != null) { values[index] = null; } + if (ivaluesShift != 0) { keys[ivaluesShift + index] = 0; } + } + } + + public void clear() { + int N = 1 << power; + if (keys != null) { + for (int i = 0; i != N; ++i) { + keys[i] = EMPTY; + } + if (values != null) { + for (int i = 0; i != N; ++i) { + values[i] = null; + } + } + } + ivaluesShift = 0; + keyCount = 0; + occupiedCount = 0; + } + + /** Return array of present keys */ + public int[] getKeys() { + int[] keys = this.keys; + int n = keyCount; + int[] result = new int[n]; + for (int i = 0; n != 0; ++i) { + int entry = keys[i]; + if (entry != EMPTY && entry != DELETED) { + result[--n] = entry; + } + } + return result; + } + + private static int tableLookupStep(int fraction, int mask, int power) { + int shift = 32 - 2 * power; + if (shift >= 0) { + return ((fraction >>> shift) & mask) | 1; + } + else { + return (fraction & (mask >>> -shift)) | 1; + } + } + + private int findIndex(int key) { + int[] keys = this.keys; + if (keys != null) { + int fraction = key * A; + int index = fraction >>> (32 - power); + int entry = keys[index]; + if (entry == key) { return index; } + if (entry != EMPTY) { + // Search in table after first failed attempt + int mask = (1 << power) - 1; + int step = tableLookupStep(fraction, mask, power); + int n = 0; + do { + if (check) { + if (n >= occupiedCount) Kit.codeBug(); + ++n; + } + index = (index + step) & mask; + entry = keys[index]; + if (entry == key) { return index; } + } while (entry != EMPTY); + } + } + return -1; + } + +// Insert key that is not present to table without deleted entries +// and enough free space + private int insertNewKey(int key) { + if (check && occupiedCount != keyCount) Kit.codeBug(); + if (check && keyCount == 1 << power) Kit.codeBug(); + int[] keys = this.keys; + int fraction = key * A; + int index = fraction >>> (32 - power); + if (keys[index] != EMPTY) { + int mask = (1 << power) - 1; + int step = tableLookupStep(fraction, mask, power); + int firstIndex = index; + do { + if (check && keys[index] == DELETED) Kit.codeBug(); + index = (index + step) & mask; + if (check && firstIndex == index) Kit.codeBug(); + } while (keys[index] != EMPTY); + } + keys[index] = key; + ++occupiedCount; + ++keyCount; + return index; + } + + private void rehashTable(boolean ensureIntSpace) { + if (keys != null) { + // Check if removing deleted entries would free enough space + if (keyCount * 2 >= occupiedCount) { + // Need to grow: less then half of deleted entries + ++power; + } + } + int N = 1 << power; + int[] old = keys; + int oldShift = ivaluesShift; + if (oldShift == 0 && !ensureIntSpace) { + keys = new int[N]; + } + else { + ivaluesShift = N; keys = new int[N * 2]; + } + for (int i = 0; i != N; ++i) { keys[i] = EMPTY; } + + Object[] oldValues = values; + if (oldValues != null) { values = new Object[N]; } + + int oldCount = keyCount; + occupiedCount = 0; + if (oldCount != 0) { + keyCount = 0; + for (int i = 0, remaining = oldCount; remaining != 0; ++i) { + int key = old[i]; + if (key != EMPTY && key != DELETED) { + int index = insertNewKey(key); + if (oldValues != null) { + values[index] = oldValues[i]; + } + if (oldShift != 0) { + keys[ivaluesShift + index] = old[oldShift + i]; + } + --remaining; + } + } + } + } + +// Ensure key index creating one if necessary + private int ensureIndex(int key, boolean intType) { + int index = -1; + int firstDeleted = -1; + int[] keys = this.keys; + if (keys != null) { + int fraction = key * A; + index = fraction >>> (32 - power); + int entry = keys[index]; + if (entry == key) { return index; } + if (entry != EMPTY) { + if (entry == DELETED) { firstDeleted = index; } + // Search in table after first failed attempt + int mask = (1 << power) - 1; + int step = tableLookupStep(fraction, mask, power); + int n = 0; + do { + if (check) { + if (n >= occupiedCount) Kit.codeBug(); + ++n; + } + index = (index + step) & mask; + entry = keys[index]; + if (entry == key) { return index; } + if (entry == DELETED && firstDeleted < 0) { + firstDeleted = index; + } + } while (entry != EMPTY); + } + } + // Inserting of new key + if (check && keys != null && keys[index] != EMPTY) + Kit.codeBug(); + if (firstDeleted >= 0) { + index = firstDeleted; + } + else { + // Need to consume empty entry: check occupation level + if (keys == null || occupiedCount * 4 >= (1 << power) * 3) { + // Too litle unused entries: rehash + rehashTable(intType); + keys = this.keys; + return insertNewKey(key); + } + ++occupiedCount; + } + keys[index] = key; + ++keyCount; + return index; + } + + private void writeObject(ObjectOutputStream out) + throws IOException + { + out.defaultWriteObject(); + + int count = keyCount; + if (count != 0) { + boolean hasIntValues = (ivaluesShift != 0); + boolean hasObjectValues = (values != null); + out.writeBoolean(hasIntValues); + out.writeBoolean(hasObjectValues); + + for (int i = 0; count != 0; ++i) { + int key = keys[i]; + if (key != EMPTY && key != DELETED) { + --count; + out.writeInt(key); + if (hasIntValues) { + out.writeInt(keys[ivaluesShift + i]); + } + if (hasObjectValues) { + out.writeObject(values[i]); + } + } + } + } + } + + private void readObject(ObjectInputStream in) + throws IOException, ClassNotFoundException + { + in.defaultReadObject(); + + int writtenKeyCount = keyCount; + if (writtenKeyCount != 0) { + keyCount = 0; + boolean hasIntValues = in.readBoolean(); + boolean hasObjectValues = in.readBoolean(); + + int N = 1 << power; + if (hasIntValues) { + keys = new int[2 * N]; + ivaluesShift = N; + }else { + keys = new int[N]; + } + for (int i = 0; i != N; ++i) { + keys[i] = EMPTY; + } + if (hasObjectValues) { + values = new Object[N]; + } + for (int i = 0; i != writtenKeyCount; ++i) { + int key = in.readInt(); + int index = insertNewKey(key); + if (hasIntValues) { + int ivalue = in.readInt(); + keys[ivaluesShift + index] = ivalue; + } + if (hasObjectValues) { + values[index] = in.readObject(); + } + } + } + } + +// A == golden_ratio * (1 << 32) = ((sqrt(5) - 1) / 2) * (1 << 32) +// See Knuth etc. + private static final int A = 0x9e3779b9; + + private static final int EMPTY = -1; + private static final int DELETED = -2; + +// Structure of kyes and values arrays (N == 1 << power): +// keys[0 <= i < N]: key value or EMPTY or DELETED mark +// values[0 <= i < N]: value of key at keys[i] +// keys[N <= i < 2N]: int values of keys at keys[i - N] + + private transient int[] keys; + private transient Object[] values; + + private int power; + private int keyCount; + private transient int occupiedCount; // == keyCount + deleted_count + + // If ivaluesShift != 0, keys[ivaluesShift + index] contains integer + // values associated with keys + private transient int ivaluesShift; + +// If true, enables consitency checks + private static final boolean check = false; + +/* TEST START + + public static void main(String[] args) { + if (!check) { + System.err.println("Set check to true and re-run"); + throw new RuntimeException("Set check to true and re-run"); + } + + UintMap map; + map = new UintMap(); + testHash(map, 2); + map = new UintMap(); + testHash(map, 10 * 1000); + map = new UintMap(30 * 1000); + testHash(map, 10 * 100); + map.clear(); + testHash(map, 4); + map = new UintMap(0); + testHash(map, 10 * 100); + } + + private static void testHash(UintMap map, int N) { + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + map.put(i, i); + check(i == map.getInt(i, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + map.put(i, i); + check(i == map.getInt(i, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + map.put(i, new Integer(i)); + check(-1 == map.getInt(i, -1)); + Integer obj = (Integer)map.getObject(i); + check(obj != null && i == obj.intValue()); + } + + check(map.size() == N); + + System.out.print("."); System.out.flush(); + int[] keys = map.getKeys(); + check(keys.length == N); + for (int i = 0; i != N; ++i) { + int key = keys[i]; + check(map.has(key)); + check(!map.isIntType(key)); + check(map.isObjectType(key)); + Integer obj = (Integer) map.getObject(key); + check(obj != null && key == obj.intValue()); + } + + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + check(-1 == map.getInt(i, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + map.put(i * i, i); + check(i == map.getInt(i * i, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + check(i == map.getInt(i * i, -1)); + } + + System.out.print("."); System.out.flush(); + for (int i = 0; i != N; ++i) { + map.put(i * i, new Integer(i)); + check(-1 == map.getInt(i * i, -1)); + map.remove(i * i); + check(!map.has(i * i)); + map.put(i * i, i); + check(map.isIntType(i * i)); + check(null == map.getObject(i * i)); + map.remove(i * i); + check(!map.isObjectType(i * i)); + check(!map.isIntType(i * i)); + } + + int old_size = map.size(); + for (int i = 0; i != N; ++i) { + map.remove(i * i); + check(map.size() == old_size); + } + + System.out.print("."); System.out.flush(); + map.clear(); + check(map.size() == 0); + for (int i = 0; i != N; ++i) { + map.put(i * i, i); + map.put(i * i + 1, new Double(i+0.5)); + } + checkSameMaps(map, (UintMap)writeAndRead(map)); + + System.out.print("."); System.out.flush(); + map = new UintMap(0); + checkSameMaps(map, (UintMap)writeAndRead(map)); + map = new UintMap(1); + checkSameMaps(map, (UintMap)writeAndRead(map)); + map = new UintMap(1000); + checkSameMaps(map, (UintMap)writeAndRead(map)); + + System.out.print("."); System.out.flush(); + map = new UintMap(N / 10); + for (int i = 0; i != N; ++i) { + map.put(2*i+1, i); + } + checkSameMaps(map, (UintMap)writeAndRead(map)); + + System.out.print("."); System.out.flush(); + map = new UintMap(N / 10); + for (int i = 0; i != N; ++i) { + map.put(2*i+1, i); + } + for (int i = 0; i != N / 2; ++i) { + map.remove(2*i+1); + } + checkSameMaps(map, (UintMap)writeAndRead(map)); + + System.out.print("."); System.out.flush(); + map = new UintMap(); + for (int i = 0; i != N; ++i) { + map.put(2*i+1, new Double(i + 10)); + } + for (int i = 0; i != N / 2; ++i) { + map.remove(2*i+1); + } + checkSameMaps(map, (UintMap)writeAndRead(map)); + + System.out.println(); System.out.flush(); + + } + + private static void checkSameMaps(UintMap map1, UintMap map2) { + check(map1.size() == map2.size()); + int[] keys = map1.getKeys(); + check(keys.length == map1.size()); + for (int i = 0; i != keys.length; ++i) { + int key = keys[i]; + check(map2.has(key)); + check(map1.isObjectType(key) == map2.isObjectType(key)); + check(map1.isIntType(key) == map2.isIntType(key)); + Object o1 = map1.getObject(key); + Object o2 = map2.getObject(key); + if (map1.isObjectType(key)) { + check(o1.equals(o2)); + }else { + check(map1.getObject(key) == null); + check(map2.getObject(key) == null); + } + if (map1.isIntType(key)) { + check(map1.getExistingInt(key) == map2.getExistingInt(key)); + }else { + check(map1.getInt(key, -10) == -10); + check(map1.getInt(key, -11) == -11); + check(map2.getInt(key, -10) == -10); + check(map2.getInt(key, -11) == -11); + } + } + } + + private static void check(boolean condition) { + if (!condition) Kit.codeBug(); + } + + private static Object writeAndRead(Object obj) { + try { + java.io.ByteArrayOutputStream + bos = new java.io.ByteArrayOutputStream(); + java.io.ObjectOutputStream + out = new java.io.ObjectOutputStream(bos); + out.writeObject(obj); + out.close(); + byte[] data = bos.toByteArray(); + java.io.ByteArrayInputStream + bis = new java.io.ByteArrayInputStream(data); + java.io.ObjectInputStream + in = new java.io.ObjectInputStream(bis); + Object result = in.readObject(); + in.close(); + return result; + }catch (Exception ex) { + ex.printStackTrace(); + throw new RuntimeException("Unexpected"); + } + } + +// TEST END */ +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Undefined.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Undefined.java new file mode 100644 index 0000000..472f26c --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Undefined.java @@ -0,0 +1,60 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; + +/** + * This class implements the Undefined value in JavaScript. + */ +public class Undefined implements Serializable +{ + static final long serialVersionUID = 9195680630202616767L; + + public static final Object instance = new Undefined(); + + private Undefined() + { + } + + public Object readResolve() + { + return instance; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/UniqueTag.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/UniqueTag.java new file mode 100644 index 0000000..33f96eb --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/UniqueTag.java @@ -0,0 +1,120 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +import java.io.Serializable; + +/** + * Class instances represent serializable tags to mark special Object values. + * <p> + * Compatibility note: under jdk 1.1 use + * org.mozilla.javascript.serialize.ScriptableInputStream to read serialized + * instances of UniqueTag as under this JDK version the default + * ObjectInputStream would not restore them correctly as it lacks support + * for readResolve method + */ +public final class UniqueTag implements Serializable +{ + static final long serialVersionUID = -4320556826714577259L; + + private static final int ID_NOT_FOUND = 1; + private static final int ID_NULL_VALUE = 2; + private static final int ID_DOUBLE_MARK = 3; + + /** + * Tag to mark non-existing values. + */ + public static final UniqueTag + NOT_FOUND = new UniqueTag(ID_NOT_FOUND); + + /** + * Tag to distinguish between uninitialized and null values. + */ + public static final UniqueTag + NULL_VALUE = new UniqueTag(ID_NULL_VALUE); + + /** + * Tag to indicate that a object represents "double" with the real value + * stored somewhere else. + */ + public static final UniqueTag + DOUBLE_MARK = new UniqueTag(ID_DOUBLE_MARK); + + private final int tagId; + + private UniqueTag(int tagId) + { + this.tagId = tagId; + } + + public Object readResolve() + { + switch (tagId) { + case ID_NOT_FOUND: + return NOT_FOUND; + case ID_NULL_VALUE: + return NULL_VALUE; + case ID_DOUBLE_MARK: + return DOUBLE_MARK; + } + throw new IllegalStateException(String.valueOf(tagId)); + } + +// Overridden for better debug printouts + public String toString() + { + String name; + switch (tagId) { + case ID_NOT_FOUND: + name = "NOT_FOUND"; + break; + case ID_NULL_VALUE: + name = "NULL_VALUE"; + break; + case ID_DOUBLE_MARK: + name = "DOUBLE_MARK"; + break; + default: + throw Kit.codeBug(); + } + return super.toString()+": "+name; + } + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/VMBridge.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/VMBridge.java new file mode 100644 index 0000000..5fba4a5 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/VMBridge.java @@ -0,0 +1,183 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +import java.lang.reflect.Method; +import java.lang.reflect.Member; +import java.util.Iterator; + +public abstract class VMBridge +{ + + static final VMBridge instance = makeInstance(); + + private static VMBridge makeInstance() + { + String[] classNames = { + "org.mozilla.javascript.VMBridge_custom", + "org.mozilla.javascript.jdk15.VMBridge_jdk15", + "org.mozilla.javascript.jdk13.VMBridge_jdk13", + "org.mozilla.javascript.jdk11.VMBridge_jdk11", + }; + for (int i = 0; i != classNames.length; ++i) { + String className = classNames[i]; + Class cl = Kit.classOrNull(className); + if (cl != null) { + VMBridge bridge = (VMBridge)Kit.newInstanceOrNull(cl); + if (bridge != null) { + return bridge; + } + } + } + throw new IllegalStateException("Failed to create VMBridge instance"); + } + + /** + * Return a helper object to optimize {@link Context} access. + * <p> + * The runtime will pass the resulting helper object to the subsequent + * calls to {@link #getContext(Object contextHelper)} and + * {@link #setContext(Object contextHelper, Context cx)} methods. + * In this way the implementation can use the helper to cache + * information about current thread to make {@link Context} access faster. + */ + protected abstract Object getThreadContextHelper(); + + /** + * Get {@link Context} instance associated with the current thread + * or null if none. + * + * @param contextHelper The result of {@link #getThreadContextHelper()} + * called from the current thread. + */ + protected abstract Context getContext(Object contextHelper); + + /** + * Associate {@link Context} instance with the current thread or remove + * the current association if <tt>cx</tt> is null. + * + * @param contextHelper The result of {@link #getThreadContextHelper()} + * called from the current thread. + */ + protected abstract void setContext(Object contextHelper, Context cx); + + /** + * Return the ClassLoader instance associated with the current thread. + */ + protected abstract ClassLoader getCurrentThreadClassLoader(); + + /** + * In many JVMSs, public methods in private + * classes are not accessible by default (Sun Bug #4071593). + * VMBridge instance should try to workaround that via, for example, + * calling method.setAccessible(true) when it is available. + * The implementation is responsible to catch all possible exceptions + * like SecurityException if the workaround is not available. + * + * @return true if it was possible to make method accessible + * or false otherwise. + */ + protected abstract boolean tryToMakeAccessible(Object accessibleObject); + + /** + * Create helper object to create later proxies implementing the specified + * interfaces later. Under JDK 1.3 the implementation can look like: + * <pre> + * return java.lang.reflect.Proxy.getProxyClass(..., interfaces). + * getConstructor(new Class[] { + * java.lang.reflect.InvocationHandler.class }); + * </pre> + * + * @param interfaces Array with one or more interface class objects. + */ + protected Object getInterfaceProxyHelper(ContextFactory cf, + Class[] interfaces) + { + throw Context.reportRuntimeError( + "VMBridge.getInterfaceProxyHelper is not supported"); + } + + /** + * Create proxy object for {@link InterfaceAdapter}. The proxy should call + * {@link InterfaceAdapter#invoke(ContextFactory cf, + * Object target, + * Scriptable topScope, + * Method method, + * Object[] args)} + * as implementation of interface methods associated with + * <tt>proxyHelper</tt>. + * + * @param proxyHelper The result of the previous call to + * {@link #getInterfaceProxyHelper(ContextFactory, Class[])}. + */ + protected Object newInterfaceProxy(Object proxyHelper, + ContextFactory cf, + InterfaceAdapter adapter, + Object target, + Scriptable topScope) + { + throw Context.reportRuntimeError( + "VMBridge.newInterfaceProxy is not supported"); + } + + /** + * Returns whether or not a given member (method or constructor) + * has variable arguments. + * Variable argument methods have only been supported in Java since + * JDK 1.5. + */ + protected abstract boolean isVarArgs(Member member); + + /** + * If "obj" is a java.util.Iterator or a java.lang.Iterable, return a + * wrapping as a JavaScript Iterator. Otherwise, return null. + * This method is in VMBridge since Iterable is a JDK 1.5 addition. + */ + public Iterator getJavaIterator(Context cx, Scriptable scope, Object obj) { + if (obj instanceof Wrapper) { + Object unwrapped = ((Wrapper) obj).unwrap(); + Iterator iterator = null; + if (unwrapped instanceof Iterator) + iterator = (Iterator) unwrapped; + return iterator; + } + return null; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/WrapFactory.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/WrapFactory.java new file mode 100644 index 0000000..3edc203 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/WrapFactory.java @@ -0,0 +1,183 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Embeddings that wish to provide their own custom wrappings for Java + * objects may extend this class and call + * {@link Context#setWrapFactory(WrapFactory)} + * Once an instance of this class or an extension of this class is enabled + * for a given context (by calling setWrapFactory on that context), Rhino + * will call the methods of this class whenever it needs to wrap a value + * resulting from a call to a Java method or an access to a Java field. + * + * @see org.mozilla.javascript.Context#setWrapFactory(WrapFactory) + * @since 1.5 Release 4 + */ +public class WrapFactory +{ + /** + * Wrap the object. + * <p> + * The value returned must be one of + * <UL> + * <LI>java.lang.Boolean</LI> + * <LI>java.lang.String</LI> + * <LI>java.lang.Number</LI> + * <LI>org.mozilla.javascript.Scriptable objects</LI> + * <LI>The value returned by Context.getUndefinedValue()</LI> + * <LI>null</LI> + * </UL> + * @param cx the current Context for this thread + * @param scope the scope of the executing script + * @param obj the object to be wrapped. Note it can be null. + * @param staticType type hint. If security restrictions prevent to wrap + object based on its class, staticType will be used instead. + * @return the wrapped value. + */ + public Object wrap(Context cx, Scriptable scope, + Object obj, Class staticType) + { + if (obj == null || obj == Undefined.instance + || obj instanceof Scriptable) + { + return obj; + } + if (staticType != null && staticType.isPrimitive()) { + if (staticType == Void.TYPE) + return Undefined.instance; + if (staticType == Character.TYPE) + return new Integer(((Character) obj).charValue()); + return obj; + } + if (!isJavaPrimitiveWrap()) { + if (obj instanceof String || obj instanceof Number + || obj instanceof Boolean) + { + return obj; + } else if (obj instanceof Character) { + return String.valueOf(((Character)obj).charValue()); + } + } + Class cls = obj.getClass(); + if (cls.isArray()) { + return NativeJavaArray.wrap(scope, obj); + } + return wrapAsJavaObject(cx, scope, obj, staticType); + } + + /** + * Wrap an object newly created by a constructor call. + * @param cx the current Context for this thread + * @param scope the scope of the executing script + * @param obj the object to be wrapped + * @return the wrapped value. + */ + public Scriptable wrapNewObject(Context cx, Scriptable scope, Object obj) + { + if (obj instanceof Scriptable) { + return (Scriptable)obj; + } + Class cls = obj.getClass(); + if (cls.isArray()) { + return NativeJavaArray.wrap(scope, obj); + } + return wrapAsJavaObject(cx, scope, obj, null); + } + + /** + * Wrap Java object as Scriptable instance to allow full access to its + * methods and fields from JavaScript. + * <p> + * {@link #wrap(Context, Scriptable, Object, Class)} and + * {@link #wrapNewObject(Context, Scriptable, Object)} call this method + * when they can not convert <tt>javaObject</tt> to JavaScript primitive + * value or JavaScript array. + * <p> + * Subclasses can override the method to provide custom wrappers + * for Java objects. + * @param cx the current Context for this thread + * @param scope the scope of the executing script + * @param javaObject the object to be wrapped + * @param staticType type hint. If security restrictions prevent to wrap + object based on its class, staticType will be used instead. + * @return the wrapped value which shall not be null + */ + public Scriptable wrapAsJavaObject(Context cx, Scriptable scope, + Object javaObject, Class staticType) + { + Scriptable wrap; + wrap = new NativeJavaObject(scope, javaObject, staticType); + return wrap; + } + + /** + * Return <code>false</code> if result of Java method, which is instance of + * <code>String</code>, <code>Number</code>, <code>Boolean</code> and + * <code>Character</code>, should be used directly as JavaScript primitive + * type. + * By default the method returns true to indicate that instances of + * <code>String</code>, <code>Number</code>, <code>Boolean</code> and + * <code>Character</code> should be wrapped as any other Java object and + * scripts can access any Java method available in these objects. + * Use {@link #setJavaPrimitiveWrap(boolean)} to change this. + */ + public final boolean isJavaPrimitiveWrap() + { + return javaPrimitiveWrap; + } + + /** + * @see #isJavaPrimitiveWrap() + */ + public final void setJavaPrimitiveWrap(boolean value) + { + Context cx = Context.getCurrentContext(); + if (cx != null && cx.isSealed()) { + Context.onSealedMutation(); + } + javaPrimitiveWrap = value; + } + + private boolean javaPrimitiveWrap = true; + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/WrappedException.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/WrappedException.java new file mode 100644 index 0000000..c749f74 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/WrappedException.java @@ -0,0 +1,93 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript; + +/** + * A wrapper for runtime exceptions. + * + * Used by the JavaScript runtime to wrap and propagate exceptions that occur + * during runtime. + * + * @author Norris Boyd + */ +public class WrappedException extends EvaluatorException +{ + static final long serialVersionUID = -1551979216966520648L; + + /** + * @see Context#throwAsScriptRuntimeEx(Throwable e) + */ + public WrappedException(Throwable exception) + { + super("Wrapped "+exception.toString()); + this.exception = exception; + Kit.initCause(this, exception); + + int[] linep = { 0 }; + String sourceName = Context.getSourcePositionFromStack(linep); + int lineNumber = linep[0]; + if (sourceName != null) { + initSourceName(sourceName); + } + if (lineNumber != 0) { + initLineNumber(lineNumber); + } + } + + /** + * Get the wrapped exception. + * + * @return the exception that was presented as a argument to the + * constructor when this object was created + */ + public Throwable getWrappedException() + { + return exception; + } + + /** + * @deprecated Use {@link #getWrappedException()} instead. + */ + public Object unwrap() + { + return getWrappedException(); + } + + private Throwable exception; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Wrapper.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Wrapper.java new file mode 100644 index 0000000..cb2d2f5 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Wrapper.java @@ -0,0 +1,58 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript; + +/** + * Objects that can wrap other values for reflection in the JS environment + * will implement Wrapper. + * + * Wrapper defines a single method that can be called to unwrap the object. + */ + +public interface Wrapper { + + /** + * Unwrap the object by returning the wrapped value. + * + * @return a wrapped value + */ + public Object unwrap(); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/continuations/Continuation.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/continuations/Continuation.java new file mode 100644 index 0000000..c6d3966 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/continuations/Continuation.java @@ -0,0 +1,136 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.continuations; + +import org.mozilla.javascript.*; + +public final class Continuation extends IdScriptableObject implements Function +{ + static final long serialVersionUID = 1794167133757605367L; + + private static final Object FTAG = new Object(); + + private Object implementation; + + public static void init(Context cx, Scriptable scope, boolean sealed) + { + Continuation obj = new Continuation(); + obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); + } + + public Object getImplementation() + { + return implementation; + } + + public void initImplementation(Object implementation) + { + this.implementation = implementation; + } + + public String getClassName() + { + return "Continuation"; + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + throw Context.reportRuntimeError("Direct call is not supported"); + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return Interpreter.restartContinuation(this, cx, scope, args); + } + + public static boolean isContinuationConstructor(IdFunctionObject f) + { + if (f.hasTag(FTAG) && f.methodId() == Id_constructor) { + return true; + } + return false; + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_constructor: arity=0; s="constructor"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(FTAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(FTAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_constructor: + throw Context.reportRuntimeError("Direct call is not supported"); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + +// #string_id_map# + + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:16:40 EDT + L0: { id = 0; String X = null; + if (s.length()==11) { X="constructor";id=Id_constructor; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_constructor = 1, + MAX_PROTOTYPE_ID = 1; + +// #/string_id_map# +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebugFrame.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebugFrame.java new file mode 100644 index 0000000..ef15710 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebugFrame.java @@ -0,0 +1,91 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript.debug; + +import org.mozilla.javascript.Context; +import org.mozilla.javascript.Scriptable; + +/** +Interface to implement if the application is interested in receiving debug +information during execution of a particular script or function. +*/ +public interface DebugFrame { + +/** +Called when execution is ready to start bytecode interpretation for entered a particular function or script. + +@param cx current Context for this thread +@param activation the activation scope for the function or script. +@param thisObj value of the JavaScript <code>this</code> object +@param args the array of arguments +*/ + public void onEnter(Context cx, Scriptable activation, + Scriptable thisObj, Object[] args); +/** +Called when executed code reaches new line in the source. +@param cx current Context for this thread +@param lineNumber current line number in the script source +*/ + public void onLineChange(Context cx, int lineNumber); + +/** +Called when thrown exception is handled by the function or script. +@param cx current Context for this thread +@param ex exception object +*/ + public void onExceptionThrown(Context cx, Throwable ex); + +/** +Called when the function or script for this frame is about to return. +@param cx current Context for this thread +@param byThrow if true function will leave by throwing exception, otherwise it + will execute normal return +@param resultOrException function result in case of normal return or + exception object if about to throw exception +*/ + public void onExit(Context cx, boolean byThrow, Object resultOrException); + +/** +Called when the function or script executes a 'debugger' statement. +@param cx current Context for this thread +*/ + public void onDebuggerStatement(Context cx); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebuggableObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebuggableObject.java new file mode 100644 index 0000000..23e7421 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebuggableObject.java @@ -0,0 +1,61 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript.debug; + +/** + * This interface exposes debugging information from objects. + */ +public interface DebuggableObject { + + /** + * Returns an array of ids for the properties of the object. + * + * <p>All properties, even those with attribute {DontEnum}, are listed. + * This allows the debugger to display all properties of the object.<p> + * + * @return an array of java.lang.Objects with an entry for every + * listed property. Properties accessed via an integer index will + * have a corresponding + * Integer entry in the returned array. Properties accessed by + * a String will have a String entry in the returned array. + */ + public Object[] getAllIds(); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebuggableScript.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebuggableScript.java new file mode 100644 index 0000000..705e442 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/DebuggableScript.java @@ -0,0 +1,119 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript.debug; + +/** + * This interface exposes debugging information from executable + * code (either functions or top-level scripts). + */ +public interface DebuggableScript +{ + public boolean isTopLevel(); + + /** + * Returns true if this is a function, false if it is a script. + */ + public boolean isFunction(); + + /** + * Get name of the function described by this script. + * Return null or an empty string if this script is not a function. + */ + public String getFunctionName(); + + /** + * Get number of declared parameters in the function. + * Return 0 if this script is not a function. + * + * @see #getParamAndVarCount() + * @see #getParamOrVarName(int index) + */ + public int getParamCount(); + + /** + * Get number of declared parameters and local variables. + * Return number of declared global variables if this script is not a + * function. + * + * @see #getParamCount() + * @see #getParamOrVarName(int index) + */ + public int getParamAndVarCount(); + + /** + * Get name of a declared parameter or local variable. + * <tt>index</tt> should be less then {@link #getParamAndVarCount()}. + * If <tt>index < {@link #getParamCount()}</tt>, return + * the name of the corresponding parameter, otherwise return the name + * of variable. + * If this script is not function, return the name of the declared + * global variable. + */ + public String getParamOrVarName(int index); + + /** + * Get the name of the source (usually filename or URL) + * of the script. + */ + public String getSourceName(); + + /** + * Returns true if this script or function were runtime-generated + * from JavaScript using <tt>eval</tt> function or <tt>Function</tt> + * or <tt>Script</tt> constructors. + */ + public boolean isGeneratedScript(); + + /** + * Get array containing the line numbers that + * that can be passed to <code>DebugFrame.onLineChange()<code>. + * Note that line order in the resulting array is arbitrary + */ + public int[] getLineNumbers(); + + public int getFunctionCount(); + + public DebuggableScript getFunction(int index); + + public DebuggableScript getParent(); + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/Debugger.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/Debugger.java new file mode 100644 index 0000000..bfac153 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/debug/Debugger.java @@ -0,0 +1,69 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript.debug; + +import org.mozilla.javascript.Context; + +/** +Interface to implement if the application is interested in receiving debug +information. +*/ +public interface Debugger { + +/** +Called when compilation of a particular function or script into internal +bytecode is done. + +@param cx current Context for this thread +@param fnOrScript object describing the function or script +@param source the function or script source +*/ + void handleCompilationDone(Context cx, DebuggableScript fnOrScript, + String source); + +/** +Called when execution entered a particular function or script. + +@return implementation of DebugFrame which receives debug information during + the function or script execution or null otherwise +*/ + DebugFrame getFrame(Context cx, DebuggableScript fnOrScript); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk11/VMBridge_jdk11.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk11/VMBridge_jdk11.java new file mode 100644 index 0000000..f5d1522 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk11/VMBridge_jdk11.java @@ -0,0 +1,84 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.jdk11; + +import java.lang.reflect.Member; +import java.util.Hashtable; + +import org.mozilla.javascript.*; + +public class VMBridge_jdk11 extends VMBridge +{ + private Hashtable threadsWithContext = new Hashtable(); + + protected Object getThreadContextHelper() + { + return Thread.currentThread(); + } + + protected Context getContext(Object contextHelper) + { + Thread t = (Thread)contextHelper; + return (Context)threadsWithContext.get(t); + } + + protected void setContext(Object contextHelper, Context cx) + { + Thread t = (Thread)contextHelper; + if (cx == null) { + // Allow to garbage collect thread reference + threadsWithContext.remove(t); + } else { + threadsWithContext.put(t, cx); + } + } + + protected ClassLoader getCurrentThreadClassLoader() + { + return null; + } + + protected boolean tryToMakeAccessible(Object accessibleObject) + { + return false; + } + + protected boolean isVarArgs(Member member) { + return false; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk13/VMBridge_jdk13.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk13/VMBridge_jdk13.java new file mode 100644 index 0000000..c33e9b4 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk13/VMBridge_jdk13.java @@ -0,0 +1,157 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.jdk13; + +import java.lang.reflect.AccessibleObject; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Member; +import java.lang.reflect.Proxy; + +import org.mozilla.javascript.*; + +public class VMBridge_jdk13 extends VMBridge +{ + private ThreadLocal contextLocal = new ThreadLocal(); + + protected Object getThreadContextHelper() + { + // To make subsequent batch calls to getContext/setContext faster + // associate permanently one element array with contextLocal + // so getContext/setContext would need just to read/write the first + // array element. + // Note that it is necessary to use Object[], not Context[] to allow + // garbage collection of Rhino classes. For details see comments + // by Attila Szegedi in + // https://bugzilla.mozilla.org/show_bug.cgi?id=281067#c5 + + Object[] storage = (Object[])contextLocal.get(); + if (storage == null) { + storage = new Object[1]; + contextLocal.set(storage); + } + return storage; + } + + protected Context getContext(Object contextHelper) + { + Object[] storage = (Object[])contextHelper; + return (Context)storage[0]; + } + + protected void setContext(Object contextHelper, Context cx) + { + Object[] storage = (Object[])contextHelper; + storage[0] = cx; + } + + protected ClassLoader getCurrentThreadClassLoader() + { + return Thread.currentThread().getContextClassLoader(); + } + + protected boolean tryToMakeAccessible(Object accessibleObject) + { + if (!(accessibleObject instanceof AccessibleObject)) { + return false; + } + AccessibleObject accessible = (AccessibleObject)accessibleObject; + if (accessible.isAccessible()) { + return true; + } + try { + accessible.setAccessible(true); + } catch (Exception ex) { } + + return accessible.isAccessible(); + } + + protected Object getInterfaceProxyHelper(ContextFactory cf, + Class[] interfaces) + { + // XXX: How to handle interfaces array withclasses from different + // class loaders? Using cf.getApplicationClassLoader() ? + ClassLoader loader = interfaces[0].getClassLoader(); + Class cl = Proxy.getProxyClass(loader, interfaces); + Constructor c; + try { + c = cl.getConstructor(new Class[] { InvocationHandler.class }); + } catch (NoSuchMethodException ex) { + // Should not happen + throw Kit.initCause(new IllegalStateException(), ex); + } + return c; + } + + protected Object newInterfaceProxy(Object proxyHelper, + final ContextFactory cf, + final InterfaceAdapter adapter, + final Object target, + final Scriptable topScope) + { + Constructor c = (Constructor)proxyHelper; + + InvocationHandler handler = new InvocationHandler() { + public Object invoke(Object proxy, + Method method, + Object[] args) + { + return adapter.invoke(cf, target, topScope, method, args); + } + }; + Object proxy; + try { + proxy = c.newInstance(new Object[] { handler }); + } catch (InvocationTargetException ex) { + throw Context.throwAsScriptRuntimeEx(ex); + } catch (IllegalAccessException ex) { + // Shouls not happen + throw Kit.initCause(new IllegalStateException(), ex); + } catch (InstantiationException ex) { + // Shouls not happen + throw Kit.initCause(new IllegalStateException(), ex); + } + return proxy; + } + + protected boolean isVarArgs(Member member) { + return false; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk15/VMBridge_jdk15.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk15/VMBridge_jdk15.java new file mode 100644 index 0000000..0ffaf9d --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/jdk15/VMBridge_jdk15.java @@ -0,0 +1,87 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.jdk15; + +import java.lang.reflect.Member; +import java.lang.reflect.Method; +import java.lang.reflect.Constructor; +import java.util.Iterator; +import org.mozilla.javascript.*; + +public class VMBridge_jdk15 extends org.mozilla.javascript.jdk13.VMBridge_jdk13 +{ + public VMBridge_jdk15() throws SecurityException, InstantiationException { + try { + // Just try and see if we can access the isVarArgs method. + // We want to fail loading if the method does not exist + // so that we can load a bridge to an older JDK instead. + Method.class.getMethod("isVarArgs", (Class[]) null); + } catch (NoSuchMethodException e) { + // Throw a fitting exception that is handled by + // org.mozilla.javascript.Kit.newInstanceOrNull: + throw new InstantiationException(e.getMessage()); + } + } + + public boolean isVarArgs(Member member) { + if (member instanceof Method) + return ((Method) member).isVarArgs(); + else if (member instanceof Constructor) + return ((Constructor) member).isVarArgs(); + else + return false; + } + + /** + * If "obj" is a java.util.Iterator or a java.lang.Iterable, return a + * wrapping as a JavaScript Iterator. Otherwise, return null. + * This method is in VMBridge since Iterable is a JDK 1.5 addition. + */ + public Iterator getJavaIterator(Context cx, Scriptable scope, Object obj) { + if (obj instanceof Wrapper) { + Object unwrapped = ((Wrapper) obj).unwrap(); + Iterator iterator = null; + if (unwrapped instanceof Iterator) + iterator = (Iterator) unwrapped; + if (unwrapped instanceof Iterable) + iterator = ((Iterable)unwrapped).iterator(); + return iterator; + } + return null; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Block.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Block.java new file mode 100644 index 0000000..bd56714 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Block.java @@ -0,0 +1,615 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; + +import java.util.Hashtable; + +import java.io.PrintWriter; +import java.io.StringWriter; + +class Block +{ + + private static class FatBlock + { + + private static Block[] reduceToArray(ObjToIntMap map) + { + Block[] result = null; + if (!map.isEmpty()) { + result = new Block[map.size()]; + int i = 0; + ObjToIntMap.Iterator iter = map.newIterator(); + for (iter.start(); !iter.done(); iter.next()) { + FatBlock fb = (FatBlock)(iter.getKey()); + result[i++] = fb.realBlock; + } + } + return result; + } + + void addSuccessor(FatBlock b) { successors.put(b, 0); } + void addPredecessor(FatBlock b) { predecessors.put(b, 0); } + + Block[] getSuccessors() { return reduceToArray(successors); } + Block[] getPredecessors() { return reduceToArray(predecessors); } + + // all the Blocks that come immediately after this + private ObjToIntMap successors = new ObjToIntMap(); + // all the Blocks that come immediately before this + private ObjToIntMap predecessors = new ObjToIntMap(); + + Block realBlock; + } + + Block(int startNodeIndex, int endNodeIndex) + { + itsStartNodeIndex = startNodeIndex; + itsEndNodeIndex = endNodeIndex; + } + + static void runFlowAnalyzes(OptFunctionNode fn, Node[] statementNodes) + { + int paramCount = fn.fnode.getParamCount(); + int varCount = fn.fnode.getParamAndVarCount(); + int[] varTypes = new int[varCount]; + // If the variable is a parameter, it could have any type. + for (int i = 0; i != paramCount; ++i) { + varTypes[i] = Optimizer.AnyType; + } + // If the variable is from a "var" statement, its typeEvent will be set + // when we see the setVar node. + for (int i = paramCount; i != varCount; ++i) { + varTypes[i] = Optimizer.NoType; + } + + Block[] theBlocks = buildBlocks(statementNodes); + + if (DEBUG) { + ++debug_blockCount; + System.out.println("-------------------"+fn.fnode.getFunctionName()+" "+debug_blockCount+"--------"); + System.out.println(toString(theBlocks, statementNodes)); + } + + reachingDefDataFlow(fn, statementNodes, theBlocks, varTypes); + typeFlow(fn, statementNodes, theBlocks, varTypes); + + if (DEBUG) { + for (int i = 0; i < theBlocks.length; i++) { + System.out.println("For block " + theBlocks[i].itsBlockID); + theBlocks[i].printLiveOnEntrySet(fn); + } + System.out.println("Variable Table, size = " + varCount); + for (int i = 0; i != varCount; i++) { + System.out.println("["+i+"] type: "+varTypes[i]); + } + } + + for (int i = paramCount; i != varCount; i++) { + if (varTypes[i] == Optimizer.NumberType) { + fn.setIsNumberVar(i); + } + } + + } + + private static Block[] buildBlocks(Node[] statementNodes) + { + // a mapping from each target node to the block it begins + Hashtable theTargetBlocks = new Hashtable(); + ObjArray theBlocks = new ObjArray(); + + // there's a block that starts at index 0 + int beginNodeIndex = 0; + + for (int i = 0; i < statementNodes.length; i++) { + switch (statementNodes[i].getType()) { + case Token.TARGET : + { + if (i != beginNodeIndex) { + FatBlock fb = newFatBlock(beginNodeIndex, i - 1); + if (statementNodes[beginNodeIndex].getType() + == Token.TARGET) + theTargetBlocks.put(statementNodes[beginNodeIndex], fb); + theBlocks.add(fb); + // start the next block at this node + beginNodeIndex = i; + } + } + break; + case Token.IFNE : + case Token.IFEQ : + case Token.GOTO : + { + FatBlock fb = newFatBlock(beginNodeIndex, i); + if (statementNodes[beginNodeIndex].getType() + == Token.TARGET) + theTargetBlocks.put(statementNodes[beginNodeIndex], fb); + theBlocks.add(fb); + // start the next block at the next node + beginNodeIndex = i + 1; + } + break; + } + } + + if (beginNodeIndex != statementNodes.length) { + FatBlock fb = newFatBlock(beginNodeIndex, statementNodes.length - 1); + if (statementNodes[beginNodeIndex].getType() == Token.TARGET) + theTargetBlocks.put(statementNodes[beginNodeIndex], fb); + theBlocks.add(fb); + } + + // build successor and predecessor links + + for (int i = 0; i < theBlocks.size(); i++) { + FatBlock fb = (FatBlock)(theBlocks.get(i)); + + Node blockEndNode = statementNodes[fb.realBlock.itsEndNodeIndex]; + int blockEndNodeType = blockEndNode.getType(); + + if ((blockEndNodeType != Token.GOTO) + && (i < (theBlocks.size() - 1))) { + FatBlock fallThruTarget = (FatBlock)(theBlocks.get(i + 1)); + fb.addSuccessor(fallThruTarget); + fallThruTarget.addPredecessor(fb); + } + + + if ( (blockEndNodeType == Token.IFNE) + || (blockEndNodeType == Token.IFEQ) + || (blockEndNodeType == Token.GOTO) ) { + Node target = ((Node.Jump)blockEndNode).target; + FatBlock branchTargetBlock + = (FatBlock)(theTargetBlocks.get(target)); + target.putProp(Node.TARGETBLOCK_PROP, + branchTargetBlock.realBlock); + fb.addSuccessor(branchTargetBlock); + branchTargetBlock.addPredecessor(fb); + } + } + + Block[] result = new Block[theBlocks.size()]; + + for (int i = 0; i < theBlocks.size(); i++) { + FatBlock fb = (FatBlock)(theBlocks.get(i)); + Block b = fb.realBlock; + b.itsSuccessors = fb.getSuccessors(); + b.itsPredecessors = fb.getPredecessors(); + b.itsBlockID = i; + result[i] = b; + } + + return result; + } + + private static FatBlock newFatBlock(int startNodeIndex, int endNodeIndex) + { + FatBlock fb = new FatBlock(); + fb.realBlock = new Block(startNodeIndex, endNodeIndex); + return fb; + } + + private static String toString(Block[] blockList, Node[] statementNodes) + { + if (!DEBUG) return null; + + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + + pw.println(blockList.length + " Blocks"); + for (int i = 0; i < blockList.length; i++) { + Block b = blockList[i]; + pw.println("#" + b.itsBlockID); + pw.println("from " + b.itsStartNodeIndex + + " " + + statementNodes[b.itsStartNodeIndex].toString()); + pw.println("thru " + b.itsEndNodeIndex + + " " + + statementNodes[b.itsEndNodeIndex].toString()); + pw.print("Predecessors "); + if (b.itsPredecessors != null) { + for (int j = 0; j < b.itsPredecessors.length; j++) + pw.print(b.itsPredecessors[j].itsBlockID + " "); + pw.println(); + } + else + pw.println("none"); + pw.print("Successors "); + if (b.itsSuccessors != null) { + for (int j = 0; j < b.itsSuccessors.length; j++) + pw.print(b.itsSuccessors[j].itsBlockID + " "); + pw.println(); + } + else + pw.println("none"); + } + return sw.toString(); + } + + private static void reachingDefDataFlow(OptFunctionNode fn, Node[] statementNodes, Block theBlocks[], int[] varTypes) + { +/* + initialize the liveOnEntry and liveOnExit sets, then discover the variables + that are def'd by each function, and those that are used before being def'd + (hence liveOnEntry) +*/ + for (int i = 0; i < theBlocks.length; i++) { + theBlocks[i].initLiveOnEntrySets(fn, statementNodes); + } +/* + this visits every block starting at the last, re-adding the predecessors of + any block whose inputs change as a result of the dataflow. + REMIND, better would be to visit in CFG postorder +*/ + boolean visit[] = new boolean[theBlocks.length]; + boolean doneOnce[] = new boolean[theBlocks.length]; + int vIndex = theBlocks.length - 1; + boolean needRescan = false; + visit[vIndex] = true; + while (true) { + if (visit[vIndex] || !doneOnce[vIndex]) { + doneOnce[vIndex] = true; + visit[vIndex] = false; + if (theBlocks[vIndex].doReachedUseDataFlow()) { + Block pred[] = theBlocks[vIndex].itsPredecessors; + if (pred != null) { + for (int i = 0; i < pred.length; i++) { + int index = pred[i].itsBlockID; + visit[index] = true; + needRescan |= (index > vIndex); + } + } + } + } + if (vIndex == 0) { + if (needRescan) { + vIndex = theBlocks.length - 1; + needRescan = false; + } + else + break; + } + else + vIndex--; + } +/* + if any variable is live on entry to block 0, we have to mark it as + not jRegable - since it means that someone is trying to access the + 'undefined'-ness of that variable. +*/ + + theBlocks[0].markAnyTypeVariables(varTypes); + } + + private static void typeFlow(OptFunctionNode fn, Node[] statementNodes, Block theBlocks[], int[] varTypes) + { + boolean visit[] = new boolean[theBlocks.length]; + boolean doneOnce[] = new boolean[theBlocks.length]; + int vIndex = 0; + boolean needRescan = false; + visit[vIndex] = true; + while (true) { + if (visit[vIndex] || !doneOnce[vIndex]) { + doneOnce[vIndex] = true; + visit[vIndex] = false; + if (theBlocks[vIndex].doTypeFlow(fn, statementNodes, varTypes)) + { + Block succ[] = theBlocks[vIndex].itsSuccessors; + if (succ != null) { + for (int i = 0; i < succ.length; i++) { + int index = succ[i].itsBlockID; + visit[index] = true; + needRescan |= (index < vIndex); + } + } + } + } + if (vIndex == (theBlocks.length - 1)) { + if (needRescan) { + vIndex = 0; + needRescan = false; + } + else + break; + } + else + vIndex++; + } + } + + private static boolean assignType(int[] varTypes, int index, int type) + { + return type != (varTypes[index] |= type); + } + + private void markAnyTypeVariables(int[] varTypes) + { + for (int i = 0; i != varTypes.length; i++) { + if (itsLiveOnEntrySet.test(i)) { + assignType(varTypes, i, Optimizer.AnyType); + } + } + + } + + /* + We're tracking uses and defs - in order to + build the def set and to identify the last use + nodes. + + The itsNotDefSet is built reversed then flipped later. + + */ + private void lookForVariableAccess(OptFunctionNode fn, Node n) + { + switch (n.getType()) { + case Token.DEC : + case Token.INC : + { + Node child = n.getFirstChild(); + if (child.getType() == Token.GETVAR) { + int varIndex = fn.getVarIndex(child); + if (!itsNotDefSet.test(varIndex)) + itsUseBeforeDefSet.set(varIndex); + itsNotDefSet.set(varIndex); + } + } + break; + case Token.SETVAR : + { + Node lhs = n.getFirstChild(); + Node rhs = lhs.getNext(); + lookForVariableAccess(fn, rhs); + itsNotDefSet.set(fn.getVarIndex(n)); + } + break; + case Token.GETVAR : + { + int varIndex = fn.getVarIndex(n); + if (!itsNotDefSet.test(varIndex)) + itsUseBeforeDefSet.set(varIndex); + } + break; + default : + Node child = n.getFirstChild(); + while (child != null) { + lookForVariableAccess(fn, child); + child = child.getNext(); + } + break; + } + } + + /* + build the live on entry/exit sets. + Then walk the trees looking for defs/uses of variables + and build the def and useBeforeDef sets. + */ + private void initLiveOnEntrySets(OptFunctionNode fn, Node[] statementNodes) + { + int listLength = fn.getVarCount(); + itsUseBeforeDefSet = new DataFlowBitSet(listLength); + itsNotDefSet = new DataFlowBitSet(listLength); + itsLiveOnEntrySet = new DataFlowBitSet(listLength); + itsLiveOnExitSet = new DataFlowBitSet(listLength); + for (int i = itsStartNodeIndex; i <= itsEndNodeIndex; i++) { + Node n = statementNodes[i]; + lookForVariableAccess(fn, n); + } + itsNotDefSet.not(); // truth in advertising + } + + /* + the liveOnEntry of each successor is the liveOnExit for this block. + The liveOnEntry for this block is - + liveOnEntry = liveOnExit - defsInThisBlock + useBeforeDefsInThisBlock + + */ + private boolean doReachedUseDataFlow() + { + itsLiveOnExitSet.clear(); + if (itsSuccessors != null) + for (int i = 0; i < itsSuccessors.length; i++) + itsLiveOnExitSet.or(itsSuccessors[i].itsLiveOnEntrySet); + return itsLiveOnEntrySet.df2(itsLiveOnExitSet, + itsUseBeforeDefSet, itsNotDefSet); + } + + /* + the type of an expression is relatively unknown. Cases we can be sure + about are - + Literals, + Arithmetic operations - always return a Number + */ + private static int findExpressionType(OptFunctionNode fn, Node n, + int[] varTypes) + { + switch (n.getType()) { + case Token.NUMBER : + return Optimizer.NumberType; + + case Token.CALL : + case Token.NEW : + case Token.REF_CALL : + return Optimizer.AnyType; + + case Token.GETELEM : + return Optimizer.AnyType; + + case Token.GETVAR : + return varTypes[fn.getVarIndex(n)]; + + case Token.INC : + case Token.DEC : + case Token.DIV: + case Token.MOD: + case Token.BITOR: + case Token.BITXOR: + case Token.BITAND: + case Token.LSH: + case Token.RSH: + case Token.URSH: + case Token.SUB : + return Optimizer.NumberType; + + case Token.ARRAYLIT: + case Token.OBJECTLIT: + return Optimizer.AnyType; // XXX: actually, we know it's not + // number, but no type yet for that + + case Token.ADD : { + // if the lhs & rhs are known to be numbers, we can be sure that's + // the result, otherwise it could be a string. + Node child = n.getFirstChild(); + int lType = findExpressionType(fn, child, varTypes); + int rType = findExpressionType(fn, child.getNext(), varTypes); + return lType | rType; // we're not distinguishing strings yet + } + } + + Node child = n.getFirstChild(); + if (child == null) { + return Optimizer.AnyType; + } else { + int result = Optimizer.NoType; + while (child != null) { + result |= findExpressionType(fn, child, varTypes); + child = child.getNext(); + } + return result; + } + } + + private static boolean findDefPoints(OptFunctionNode fn, Node n, + int[] varTypes) + { + boolean result = false; + Node child = n.getFirstChild(); + switch (n.getType()) { + default : + while (child != null) { + result |= findDefPoints(fn, child, varTypes); + child = child.getNext(); + } + break; + case Token.DEC : + case Token.INC : + if (child.getType() == Token.GETVAR) { + // theVar is a Number now + int i = fn.getVarIndex(child); + result |= assignType(varTypes, i, Optimizer.NumberType); + } + break; + case Token.SETPROP : + case Token.SETPROP_OP : + if (child.getType() == Token.GETVAR) { + int i = fn.getVarIndex(child); + assignType(varTypes, i, Optimizer.AnyType); + } + while (child != null) { + result |= findDefPoints(fn, child, varTypes); + child = child.getNext(); + } + break; + case Token.SETVAR : { + Node rValue = child.getNext(); + int theType = findExpressionType(fn, rValue, varTypes); + int i = fn.getVarIndex(n); + result |= assignType(varTypes, i, theType); + break; + } + } + return result; + } + + private boolean doTypeFlow(OptFunctionNode fn, Node[] statementNodes, + int[] varTypes) + { + boolean changed = false; + + for (int i = itsStartNodeIndex; i <= itsEndNodeIndex; i++) { + Node n = statementNodes[i]; + if (n != null) + changed |= findDefPoints(fn, n, varTypes); + } + + return changed; + } + + private void printLiveOnEntrySet(OptFunctionNode fn) + { + if (DEBUG) { + for (int i = 0; i < fn.getVarCount(); i++) { + String name = fn.fnode.getParamOrVarName(i); + if (itsUseBeforeDefSet.test(i)) + System.out.println(name + " is used before def'd"); + if (itsNotDefSet.test(i)) + System.out.println(name + " is not def'd"); + if (itsLiveOnEntrySet.test(i)) + System.out.println(name + " is live on entry"); + if (itsLiveOnExitSet.test(i)) + System.out.println(name + " is live on exit"); + } + } + } + + // all the Blocks that come immediately after this + private Block[] itsSuccessors; + // all the Blocks that come immediately before this + private Block[] itsPredecessors; + + private int itsStartNodeIndex; // the Node at the start of the block + private int itsEndNodeIndex; // the Node at the end of the block + + private int itsBlockID; // a unique index for each block + +// reaching def bit sets - + private DataFlowBitSet itsLiveOnEntrySet; + private DataFlowBitSet itsLiveOnExitSet; + private DataFlowBitSet itsUseBeforeDefSet; + private DataFlowBitSet itsNotDefSet; + + static final boolean DEBUG = false; + private static int debug_blockCount; + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/ClassCompiler.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/ClassCompiler.java new file mode 100644 index 0000000..4a69c6a --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/ClassCompiler.java @@ -0,0 +1,214 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; + +/** + * Generates class files from script sources. + * + * since 1.5 Release 5 + * @author Igor Bukanov + */ + +public class ClassCompiler +{ + /** + * Construct ClassCompiler that uses the specified compiler environment + * when generating classes. + */ + public ClassCompiler(CompilerEnvirons compilerEnv) + { + if (compilerEnv == null) throw new IllegalArgumentException(); + this.compilerEnv = compilerEnv; + this.mainMethodClassName = Codegen.DEFAULT_MAIN_METHOD_CLASS; + } + + /** + * Set the class name to use for main method implementation. + * The class must have a method matching + * <tt>public static void main(Script sc, String[] args)</tt>, it will be + * called when <tt>main(String[] args)</tt> is called in the generated + * class. The class name should be fully qulified name and include the + * package name like in <tt>org.foo.Bar<tt>. + */ + public void setMainMethodClass(String className) + { + // XXX Should this check for a valid class name? + mainMethodClassName = className; + } + + /** + * Get the name of the class for main method implementation. + * @see #setMainMethodClass(String) + */ + public String getMainMethodClass() + { + return mainMethodClassName; + } + + /** + * Get the compiler environment the compiler uses. + */ + public CompilerEnvirons getCompilerEnv() + { + return compilerEnv; + } + + /** + * Get the class that the generated target will extend. + */ + public Class getTargetExtends() + { + return targetExtends; + } + + /** + * Set the class that the generated target will extend. + * + * @param extendsClass the class it extends + */ + public void setTargetExtends(Class extendsClass) + { + targetExtends = extendsClass; + } + + /** + * Get the interfaces that the generated target will implement. + */ + public Class[] getTargetImplements() + { + return targetImplements == null ? null : (Class[])targetImplements.clone(); + } + + /** + * Set the interfaces that the generated target will implement. + * + * @param implementsClasses an array of Class objects, one for each + * interface the target will extend + */ + public void setTargetImplements(Class[] implementsClasses) + { + targetImplements = implementsClasses == null ? null : (Class[])implementsClasses.clone(); + } + + /** + * Build class name for a auxiliary class generated by compiler. + * If the compiler needs to generate extra classes beyond the main class, + * it will call this function to build the auxiliary class name. + * The default implementation simply appends auxMarker to mainClassName + * but this can be overridden. + */ + protected String makeAuxiliaryClassName(String mainClassName, + String auxMarker) + { + return mainClassName+auxMarker; + } + + /** + * Compile JavaScript source into one or more Java class files. + * The first compiled class will have name mainClassName. + * If the results of {@link #getTargetExtends()} or + * {@link #getTargetImplements()} are not null, then the first compiled + * class will extend the specified super class and implement + * specified interfaces. + * + * @return array where elements with even indexes specifies class name + * and the following odd index gives class file body as byte[] + * array. The initial element of the array always holds + * mainClassName and array[1] holds its byte code. + */ + public Object[] compileToClassFiles(String source, + String sourceLocation, + int lineno, + String mainClassName) + { + /*APPJET*/ + Parser p = + InformativeParser.makeParser(compilerEnv, + compilerEnv.getErrorReporter()); + ScriptOrFnNode tree = p.parse(source, sourceLocation, lineno); + String encodedSource = p.getEncodedSource(); + + Class superClass = getTargetExtends(); + Class[] interfaces = getTargetImplements(); + String scriptClassName; + boolean isPrimary = (interfaces == null && superClass == null); + if (isPrimary) { + scriptClassName = mainClassName; + } else { + scriptClassName = makeAuxiliaryClassName(mainClassName, "1"); + } + + Codegen codegen = new Codegen(); + codegen.setMainMethodClass(mainMethodClassName); + byte[] scriptClassBytes + = codegen.compileToClassFile(compilerEnv, scriptClassName, + tree, encodedSource, + false); + + if (isPrimary) { + return new Object[] { scriptClassName, scriptClassBytes }; + } + int functionCount = tree.getFunctionCount(); + ObjToIntMap functionNames = new ObjToIntMap(functionCount); + for (int i = 0; i != functionCount; ++i) { + FunctionNode ofn = tree.getFunctionNode(i); + String name = ofn.getFunctionName(); + if (name != null && name.length() != 0) { + functionNames.put(name, ofn.getParamCount()); + } + } + if (superClass == null) { + superClass = ScriptRuntime.ObjectClass; + } + byte[] mainClassBytes + = JavaAdapter.createAdapterCode( + functionNames, mainClassName, + superClass, interfaces, scriptClassName); + + return new Object[] { mainClassName, mainClassBytes, + scriptClassName, scriptClassBytes }; + } + + private String mainMethodClassName; + private CompilerEnvirons compilerEnv; + private Class targetExtends; + private Class[] targetImplements; + +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Codegen.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Codegen.java new file mode 100644 index 0000000..64952bf --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Codegen.java @@ -0,0 +1,5031 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Kemal Bayram + * Igor Bukanov + * Bob Jervis + * Roger Lawrence + * Andi Vajda + * Hannes Wallnoefer + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; +import org.mozilla.classfile.*; +import java.util.*; +import java.lang.reflect.Constructor; +import java.util.Hashtable; + +/** + * This class generates code for a given IR tree. + * + * @author Norris Boyd + * @author Roger Lawrence + */ + +public class Codegen implements Evaluator +{ + public void captureStackInfo(RhinoException ex) { + throw new UnsupportedOperationException(); + } + + public String getSourcePositionFromStack(Context cx, int[] linep) { + throw new UnsupportedOperationException(); + } + + public String getPatchedStack(RhinoException ex, String nativeStackTrace) { + throw new UnsupportedOperationException(); + } + + public List getScriptStack(RhinoException ex) { + throw new UnsupportedOperationException(); + } + + public void setEvalScriptFlag(Script script) { + throw new UnsupportedOperationException(); + } + + public Object compile(CompilerEnvirons compilerEnv, + ScriptOrFnNode tree, + String encodedSource, + boolean returnFunction) + { + int serial; + synchronized (globalLock) { + serial = ++globalSerialClassCounter; + } + String mainClassName = "org.mozilla.javascript.gen.c"+serial; + + byte[] mainClassBytes = compileToClassFile(compilerEnv, mainClassName, + tree, encodedSource, + returnFunction); + + return new Object[] { mainClassName, mainClassBytes }; + } + + public Script createScriptObject(Object bytecode, + Object staticSecurityDomain) + { + Class cl = defineClass(bytecode, staticSecurityDomain); + + Script script; + try { + script = (Script)cl.newInstance(); + } catch (Exception ex) { + throw new RuntimeException + ("Unable to instantiate compiled class:"+ex.toString()); + } + return script; + } + + public Function createFunctionObject(Context cx, Scriptable scope, + Object bytecode, + Object staticSecurityDomain) + { + Class cl = defineClass(bytecode, staticSecurityDomain); + + NativeFunction f; + try { + Constructor ctor = cl.getConstructors()[0]; + Object[] initArgs = { scope, cx, new Integer(0) }; + f = (NativeFunction)ctor.newInstance(initArgs); + } catch (Exception ex) { + throw new RuntimeException + ("Unable to instantiate compiled class:"+ex.toString()); + } + return f; + } + + private Class defineClass(Object bytecode, + Object staticSecurityDomain) + { + Object[] nameBytesPair = (Object[])bytecode; + String className = (String)nameBytesPair[0]; + byte[] classBytes = (byte[])nameBytesPair[1]; + + // The generated classes in this case refer only to Rhino classes + // which must be accessible through this class loader + ClassLoader rhinoLoader = getClass().getClassLoader(); + GeneratedClassLoader loader; + loader = SecurityController.createLoader(rhinoLoader, + staticSecurityDomain); + Exception e; + try { + Class cl = loader.defineClass(className, classBytes); + loader.linkClass(cl); + return cl; + } catch (SecurityException x) { + e = x; + } catch (IllegalArgumentException x) { + e = x; + } + throw new RuntimeException("Malformed optimizer package " + e); + } + + byte[] compileToClassFile(CompilerEnvirons compilerEnv, + String mainClassName, + ScriptOrFnNode scriptOrFn, + String encodedSource, + boolean returnFunction) + { + this.compilerEnv = compilerEnv; + + transform(scriptOrFn); + + if (Token.printTrees) { + /*APPJET*///System.out.println(scriptOrFn.toStringTree(scriptOrFn)); + } + + if (returnFunction) { + scriptOrFn = scriptOrFn.getFunctionNode(0); + } + + initScriptOrFnNodesData(scriptOrFn); + + this.mainClassName = mainClassName; + this.mainClassSignature + = ClassFileWriter.classNameToSignature(mainClassName); + + try { + return generateCode(encodedSource); + } catch (ClassFileWriter.ClassFileFormatException e) { + throw reportClassFileFormatException(scriptOrFn, e.getMessage()); + } + } + + private RuntimeException reportClassFileFormatException( + ScriptOrFnNode scriptOrFn, + String message) + { + String msg = scriptOrFn instanceof FunctionNode + ? ScriptRuntime.getMessage2("msg.while.compiling.fn", + ((FunctionNode)scriptOrFn).getFunctionName(), message) + : ScriptRuntime.getMessage1("msg.while.compiling.script", message); + return Context.reportRuntimeError(msg, scriptOrFn.getSourceName(), + scriptOrFn.getLineno(), null, 0); + } + + private void transform(ScriptOrFnNode tree) + { + initOptFunctions_r(tree); + + int optLevel = compilerEnv.getOptimizationLevel(); + + Hashtable possibleDirectCalls = null; + if (optLevel > 0) { + /* + * Collect all of the contained functions into a hashtable + * so that the call optimizer can access the class name & parameter + * count for any call it encounters + */ + if (tree.getType() == Token.SCRIPT) { + int functionCount = tree.getFunctionCount(); + for (int i = 0; i != functionCount; ++i) { + OptFunctionNode ofn = OptFunctionNode.get(tree, i); + if (ofn.fnode.getFunctionType() + == FunctionNode.FUNCTION_STATEMENT) + { + String name = ofn.fnode.getFunctionName(); + if (name.length() != 0) { + if (possibleDirectCalls == null) { + possibleDirectCalls = new Hashtable(); + } + possibleDirectCalls.put(name, ofn); + } + } + } + } + } + + if (possibleDirectCalls != null) { + directCallTargets = new ObjArray(); + } + + OptTransformer ot = new OptTransformer(possibleDirectCalls, + directCallTargets); + ot.transform(tree); + + if (optLevel > 0) { + (new Optimizer()).optimize(tree); + } + } + + private static void initOptFunctions_r(ScriptOrFnNode scriptOrFn) + { + for (int i = 0, N = scriptOrFn.getFunctionCount(); i != N; ++i) { + FunctionNode fn = scriptOrFn.getFunctionNode(i); + new OptFunctionNode(fn); + initOptFunctions_r(fn); + } + } + + private void initScriptOrFnNodesData(ScriptOrFnNode scriptOrFn) + { + ObjArray x = new ObjArray(); + collectScriptOrFnNodes_r(scriptOrFn, x); + + int count = x.size(); + scriptOrFnNodes = new ScriptOrFnNode[count]; + x.toArray(scriptOrFnNodes); + + scriptOrFnIndexes = new ObjToIntMap(count); + for (int i = 0; i != count; ++i) { + scriptOrFnIndexes.put(scriptOrFnNodes[i], i); + } + } + + private static void collectScriptOrFnNodes_r(ScriptOrFnNode n, + ObjArray x) + { + x.add(n); + int nestedCount = n.getFunctionCount(); + for (int i = 0; i != nestedCount; ++i) { + collectScriptOrFnNodes_r(n.getFunctionNode(i), x); + } + } + + private byte[] generateCode(String encodedSource) + { + boolean hasScript = (scriptOrFnNodes[0].getType() == Token.SCRIPT); + boolean hasFunctions = (scriptOrFnNodes.length > 1 || !hasScript); + + String sourceFile = null; + if (compilerEnv.isGenerateDebugInfo()) { + sourceFile = scriptOrFnNodes[0].getSourceName(); + } + + ClassFileWriter cfw = new ClassFileWriter(mainClassName, + SUPER_CLASS_NAME, + sourceFile); + cfw.addField(ID_FIELD_NAME, "I", + ClassFileWriter.ACC_PRIVATE); + cfw.addField(DIRECT_CALL_PARENT_FIELD, mainClassSignature, + ClassFileWriter.ACC_PRIVATE); + cfw.addField(REGEXP_ARRAY_FIELD_NAME, REGEXP_ARRAY_FIELD_TYPE, + ClassFileWriter.ACC_PRIVATE); + + if (hasFunctions) { + generateFunctionConstructor(cfw); + } + + if (hasScript) { + cfw.addInterface("org/mozilla/javascript/Script"); + generateScriptCtor(cfw); + generateMain(cfw); + generateExecute(cfw); + } + + generateCallMethod(cfw); + generateResumeGenerator(cfw); + + generateNativeFunctionOverrides(cfw, encodedSource); + + int count = scriptOrFnNodes.length; + for (int i = 0; i != count; ++i) { + ScriptOrFnNode n = scriptOrFnNodes[i]; + + BodyCodegen bodygen = new BodyCodegen(); + bodygen.cfw = cfw; + bodygen.codegen = this; + bodygen.compilerEnv = compilerEnv; + bodygen.scriptOrFn = n; + bodygen.scriptOrFnIndex = i; + + try { + bodygen.generateBodyCode(); + } catch (ClassFileWriter.ClassFileFormatException e) { + throw reportClassFileFormatException(n, e.getMessage()); + } + + if (n.getType() == Token.FUNCTION) { + OptFunctionNode ofn = OptFunctionNode.get(n); + generateFunctionInit(cfw, ofn); + if (ofn.isTargetOfDirectCall()) { + emitDirectConstructor(cfw, ofn); + } + } + } + + if (directCallTargets != null) { + int N = directCallTargets.size(); + for (int j = 0; j != N; ++j) { + cfw.addField(getDirectTargetFieldName(j), + mainClassSignature, + ClassFileWriter.ACC_PRIVATE); + } + } + + emitRegExpInit(cfw); + emitConstantDudeInitializers(cfw); + + return cfw.toByteArray(); + } + + private void emitDirectConstructor(ClassFileWriter cfw, + OptFunctionNode ofn) + { +/* + we generate .. + Scriptable directConstruct(<directCallArgs>) { + Scriptable newInstance = createObject(cx, scope); + Object val = <body-name>(cx, scope, newInstance, <directCallArgs>); + if (val instanceof Scriptable) { + return (Scriptable) val; + } + return newInstance; + } +*/ + cfw.startMethod(getDirectCtorName(ofn.fnode), + getBodyMethodSignature(ofn.fnode), + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + + int argCount = ofn.fnode.getParamCount(); + int firstLocal = (4 + argCount * 3) + 1; + + cfw.addALoad(0); // this + cfw.addALoad(1); // cx + cfw.addALoad(2); // scope + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, + "org/mozilla/javascript/BaseFunction", + "createObject", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(firstLocal); + + cfw.addALoad(0); + cfw.addALoad(1); + cfw.addALoad(2); + cfw.addALoad(firstLocal); + for (int i = 0; i < argCount; i++) { + cfw.addALoad(4 + (i * 3)); + cfw.addDLoad(5 + (i * 3)); + } + cfw.addALoad(4 + argCount * 3); + cfw.addInvoke(ByteCode.INVOKESTATIC, + mainClassName, + getBodyMethodName(ofn.fnode), + getBodyMethodSignature(ofn.fnode)); + int exitLabel = cfw.acquireLabel(); + cfw.add(ByteCode.DUP); // make a copy of direct call result + cfw.add(ByteCode.INSTANCEOF, "org/mozilla/javascript/Scriptable"); + cfw.add(ByteCode.IFEQ, exitLabel); + // cast direct call result + cfw.add(ByteCode.CHECKCAST, "org/mozilla/javascript/Scriptable"); + cfw.add(ByteCode.ARETURN); + cfw.markLabel(exitLabel); + + cfw.addALoad(firstLocal); + cfw.add(ByteCode.ARETURN); + + cfw.stopMethod((short)(firstLocal + 1)); + } + + static boolean isGenerator(ScriptOrFnNode node) + { + return (node.getType() == Token.FUNCTION ) && + ((FunctionNode)node).isGenerator(); + } + + // How dispatch to generators works: + // Two methods are generated corresponding to a user-written generator. + // One of these creates a generator object (NativeGenerator), which is + // returned to the user. The other method contains all of the body code + // of the generator. + // When a user calls a generator, the call() method dispatches control to + // to the method that creates the NativeGenerator object. Subsequently when + // the user invokes .next(), .send() or any such method on the generator + // object, the resumeGenerator() below dispatches the call to the + // method corresponding to the generator body. As a matter of convention + // the generator body is given the name of the generator activation function + // appended by "_gen". + private void generateResumeGenerator(ClassFileWriter cfw) + { + boolean hasGenerators = false; + for (int i=0; i < scriptOrFnNodes.length; i++) { + if (isGenerator(scriptOrFnNodes[i])) + hasGenerators = true; + } + + // if there are no generators defined, we don't implement a + // resumeGenerator(). The base class provides a default implementation. + if (!hasGenerators) + return; + + cfw.startMethod("resumeGenerator", + "(Lorg/mozilla/javascript/Context;" + + "Lorg/mozilla/javascript/Scriptable;" + + "ILjava/lang/Object;" + + "Ljava/lang/Object;)Ljava/lang/Object;", + (short)(ClassFileWriter.ACC_PUBLIC + | ClassFileWriter.ACC_FINAL)); + + // load arguments for dispatch to the corresponding *_gen method + cfw.addALoad(0); + cfw.addALoad(1); + cfw.addALoad(2); + cfw.addALoad(4); + cfw.addALoad(5); + cfw.addILoad(3); + + cfw.addLoadThis(); + cfw.add(ByteCode.GETFIELD, cfw.getClassName(), ID_FIELD_NAME, "I"); + + int startSwitch = cfw.addTableSwitch(0, scriptOrFnNodes.length - 1); + cfw.markTableSwitchDefault(startSwitch); + int endlabel = cfw.acquireLabel(); + + for (int i = 0; i < scriptOrFnNodes.length; i++) { + ScriptOrFnNode n = scriptOrFnNodes[i]; + cfw.markTableSwitchCase(startSwitch, i, (short)6); + if (isGenerator(n)) { + String type = "(" + + mainClassSignature + + "Lorg/mozilla/javascript/Context;" + + "Lorg/mozilla/javascript/Scriptable;" + + "Ljava/lang/Object;" + + "Ljava/lang/Object;I)Ljava/lang/Object;"; + cfw.addInvoke(ByteCode.INVOKESTATIC, + mainClassName, + getBodyMethodName(n) + "_gen", + type); + cfw.add(ByteCode.ARETURN); + } else { + cfw.add(ByteCode.GOTO, endlabel); + } + } + + cfw.markLabel(endlabel); + pushUndefined(cfw); + cfw.add(ByteCode.ARETURN); + + + // this method uses as many locals as there are arguments (hence 6) + cfw.stopMethod((short)6); + } + + private void generateCallMethod(ClassFileWriter cfw) + { + cfw.startMethod("call", + "(Lorg/mozilla/javascript/Context;" + + "Lorg/mozilla/javascript/Scriptable;" + + "Lorg/mozilla/javascript/Scriptable;" + + "[Ljava/lang/Object;)Ljava/lang/Object;", + (short)(ClassFileWriter.ACC_PUBLIC + | ClassFileWriter.ACC_FINAL)); + + // Generate code for: + // if (!ScriptRuntime.hasTopCall(cx)) { + // return ScriptRuntime.doTopCall(this, cx, scope, thisObj, args); + // } + + int nonTopCallLabel = cfw.acquireLabel(); + cfw.addALoad(1); //cx + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/ScriptRuntime", + "hasTopCall", + "(Lorg/mozilla/javascript/Context;" + +")Z"); + cfw.add(ByteCode.IFNE, nonTopCallLabel); + cfw.addALoad(0); + cfw.addALoad(1); + cfw.addALoad(2); + cfw.addALoad(3); + cfw.addALoad(4); + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/ScriptRuntime", + "doTopCall", + "(Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Ljava/lang/Object;"); + cfw.add(ByteCode.ARETURN); + cfw.markLabel(nonTopCallLabel); + + // Now generate switch to call the real methods + cfw.addALoad(0); + cfw.addALoad(1); + cfw.addALoad(2); + cfw.addALoad(3); + cfw.addALoad(4); + + int end = scriptOrFnNodes.length; + boolean generateSwitch = (2 <= end); + + int switchStart = 0; + int switchStackTop = 0; + if (generateSwitch) { + cfw.addLoadThis(); + cfw.add(ByteCode.GETFIELD, cfw.getClassName(), ID_FIELD_NAME, "I"); + // do switch from (1, end - 1) mapping 0 to + // the default case + switchStart = cfw.addTableSwitch(1, end - 1); + } + + for (int i = 0; i != end; ++i) { + ScriptOrFnNode n = scriptOrFnNodes[i]; + if (generateSwitch) { + if (i == 0) { + cfw.markTableSwitchDefault(switchStart); + switchStackTop = cfw.getStackTop(); + } else { + cfw.markTableSwitchCase(switchStart, i - 1, + switchStackTop); + } + } + if (n.getType() == Token.FUNCTION) { + OptFunctionNode ofn = OptFunctionNode.get(n); + if (ofn.isTargetOfDirectCall()) { + int pcount = ofn.fnode.getParamCount(); + if (pcount != 0) { + // loop invariant: + // stack top == arguments array from addALoad4() + for (int p = 0; p != pcount; ++p) { + cfw.add(ByteCode.ARRAYLENGTH); + cfw.addPush(p); + int undefArg = cfw.acquireLabel(); + int beyond = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ICMPLE, undefArg); + // get array[p] + cfw.addALoad(4); + cfw.addPush(p); + cfw.add(ByteCode.AALOAD); + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(undefArg); + pushUndefined(cfw); + cfw.markLabel(beyond); + // Only one push + cfw.adjustStackTop(-1); + cfw.addPush(0.0); + // restore invariant + cfw.addALoad(4); + } + } + } + } + cfw.addInvoke(ByteCode.INVOKESTATIC, + mainClassName, + getBodyMethodName(n), + getBodyMethodSignature(n)); + cfw.add(ByteCode.ARETURN); + } + cfw.stopMethod((short)5); + // 5: this, cx, scope, js this, args[] + } + + private void generateMain(ClassFileWriter cfw) + { + cfw.startMethod("main", "([Ljava/lang/String;)V", + (short)(ClassFileWriter.ACC_PUBLIC + | ClassFileWriter.ACC_STATIC)); + + // load new ScriptImpl() + cfw.add(ByteCode.NEW, cfw.getClassName()); + cfw.add(ByteCode.DUP); + cfw.addInvoke(ByteCode.INVOKESPECIAL, cfw.getClassName(), + "<init>", "()V"); + // load 'args' + cfw.add(ByteCode.ALOAD_0); + // Call mainMethodClass.main(Script script, String[] args) + cfw.addInvoke(ByteCode.INVOKESTATIC, + mainMethodClass, + "main", + "(Lorg/mozilla/javascript/Script;[Ljava/lang/String;)V"); + cfw.add(ByteCode.RETURN); + // 1 = String[] args + cfw.stopMethod((short)1); + } + + private void generateExecute(ClassFileWriter cfw) + { + cfw.startMethod("exec", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;", + (short)(ClassFileWriter.ACC_PUBLIC + | ClassFileWriter.ACC_FINAL)); + + final int CONTEXT_ARG = 1; + final int SCOPE_ARG = 2; + + cfw.addLoadThis(); + cfw.addALoad(CONTEXT_ARG); + cfw.addALoad(SCOPE_ARG); + cfw.add(ByteCode.DUP); + cfw.add(ByteCode.ACONST_NULL); + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, + cfw.getClassName(), + "call", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Ljava/lang/Object;"); + + cfw.add(ByteCode.ARETURN); + // 3 = this + context + scope + cfw.stopMethod((short)3); + } + + private void generateScriptCtor(ClassFileWriter cfw) + { + cfw.startMethod("<init>", "()V", ClassFileWriter.ACC_PUBLIC); + + cfw.addLoadThis(); + cfw.addInvoke(ByteCode.INVOKESPECIAL, SUPER_CLASS_NAME, + "<init>", "()V"); + // set id to 0 + cfw.addLoadThis(); + cfw.addPush(0); + cfw.add(ByteCode.PUTFIELD, cfw.getClassName(), ID_FIELD_NAME, "I"); + + cfw.add(ByteCode.RETURN); + // 1 parameter = this + cfw.stopMethod((short)1); + } + + private void generateFunctionConstructor(ClassFileWriter cfw) + { + final int SCOPE_ARG = 1; + final int CONTEXT_ARG = 2; + final int ID_ARG = 3; + + cfw.startMethod("<init>", FUNCTION_CONSTRUCTOR_SIGNATURE, + ClassFileWriter.ACC_PUBLIC); + cfw.addALoad(0); + cfw.addInvoke(ByteCode.INVOKESPECIAL, SUPER_CLASS_NAME, + "<init>", "()V"); + + cfw.addLoadThis(); + cfw.addILoad(ID_ARG); + cfw.add(ByteCode.PUTFIELD, cfw.getClassName(), ID_FIELD_NAME, "I"); + + cfw.addLoadThis(); + cfw.addALoad(CONTEXT_ARG); + cfw.addALoad(SCOPE_ARG); + + int start = (scriptOrFnNodes[0].getType() == Token.SCRIPT) ? 1 : 0; + int end = scriptOrFnNodes.length; + if (start == end) throw badTree(); + boolean generateSwitch = (2 <= end - start); + + int switchStart = 0; + int switchStackTop = 0; + if (generateSwitch) { + cfw.addILoad(ID_ARG); + // do switch from (start + 1, end - 1) mapping start to + // the default case + switchStart = cfw.addTableSwitch(start + 1, end - 1); + } + + for (int i = start; i != end; ++i) { + if (generateSwitch) { + if (i == start) { + cfw.markTableSwitchDefault(switchStart); + switchStackTop = cfw.getStackTop(); + } else { + cfw.markTableSwitchCase(switchStart, i - 1 - start, + switchStackTop); + } + } + OptFunctionNode ofn = OptFunctionNode.get(scriptOrFnNodes[i]); + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, + mainClassName, + getFunctionInitMethodName(ofn), + FUNCTION_INIT_SIGNATURE); + cfw.add(ByteCode.RETURN); + } + + // 4 = this + scope + context + id + cfw.stopMethod((short)4); + } + + private void generateFunctionInit(ClassFileWriter cfw, + OptFunctionNode ofn) + { + final int CONTEXT_ARG = 1; + final int SCOPE_ARG = 2; + cfw.startMethod(getFunctionInitMethodName(ofn), + FUNCTION_INIT_SIGNATURE, + (short)(ClassFileWriter.ACC_PRIVATE + | ClassFileWriter.ACC_FINAL)); + + // Call NativeFunction.initScriptFunction + cfw.addLoadThis(); + cfw.addALoad(CONTEXT_ARG); + cfw.addALoad(SCOPE_ARG); + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, + "org/mozilla/javascript/NativeFunction", + "initScriptFunction", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")V"); + + // precompile all regexp literals + int regexpCount = ofn.fnode.getRegexpCount(); + if (regexpCount != 0) { + cfw.addLoadThis(); + pushRegExpArray(cfw, ofn.fnode, CONTEXT_ARG, SCOPE_ARG); + cfw.add(ByteCode.PUTFIELD, mainClassName, + REGEXP_ARRAY_FIELD_NAME, REGEXP_ARRAY_FIELD_TYPE); + } + + cfw.add(ByteCode.RETURN); + // 3 = (scriptThis/functionRef) + scope + context + cfw.stopMethod((short)3); + } + + private void generateNativeFunctionOverrides(ClassFileWriter cfw, + String encodedSource) + { + // Override NativeFunction.getLanguageVersion() with + // public int getLanguageVersion() { return <version-constant>; } + + cfw.startMethod("getLanguageVersion", "()I", + ClassFileWriter.ACC_PUBLIC); + + cfw.addPush(compilerEnv.getLanguageVersion()); + cfw.add(ByteCode.IRETURN); + + // 1: this and no argument or locals + cfw.stopMethod((short)1); + + // The rest of NativeFunction overrides require specific code for each + // script/function id + + final int Do_getFunctionName = 0; + final int Do_getParamCount = 1; + final int Do_getParamAndVarCount = 2; + final int Do_getParamOrVarName = 3; + final int Do_getEncodedSource = 4; + final int Do_getParamOrVarConst = 5; + final int SWITCH_COUNT = 6; + + for (int methodIndex = 0; methodIndex != SWITCH_COUNT; ++methodIndex) { + if (methodIndex == Do_getEncodedSource && encodedSource == null) { + continue; + } + + // Generate: + // prologue; + // switch over function id to implement function-specific action + // epilogue + + short methodLocals; + switch (methodIndex) { + case Do_getFunctionName: + methodLocals = 1; // Only this + cfw.startMethod("getFunctionName", "()Ljava/lang/String;", + ClassFileWriter.ACC_PUBLIC); + break; + case Do_getParamCount: + methodLocals = 1; // Only this + cfw.startMethod("getParamCount", "()I", + ClassFileWriter.ACC_PUBLIC); + break; + case Do_getParamAndVarCount: + methodLocals = 1; // Only this + cfw.startMethod("getParamAndVarCount", "()I", + ClassFileWriter.ACC_PUBLIC); + break; + case Do_getParamOrVarName: + methodLocals = 1 + 1; // this + paramOrVarIndex + cfw.startMethod("getParamOrVarName", "(I)Ljava/lang/String;", + ClassFileWriter.ACC_PUBLIC); + break; + case Do_getParamOrVarConst: + methodLocals = 1 + 1 + 1; // this + paramOrVarName + cfw.startMethod("getParamOrVarConst", "(I)Z", + ClassFileWriter.ACC_PUBLIC); + break; + case Do_getEncodedSource: + methodLocals = 1; // Only this + cfw.startMethod("getEncodedSource", "()Ljava/lang/String;", + ClassFileWriter.ACC_PUBLIC); + cfw.addPush(encodedSource); + break; + default: + throw Kit.codeBug(); + } + + int count = scriptOrFnNodes.length; + + int switchStart = 0; + int switchStackTop = 0; + if (count > 1) { + // Generate switch but only if there is more then one + // script/function + cfw.addLoadThis(); + cfw.add(ByteCode.GETFIELD, cfw.getClassName(), + ID_FIELD_NAME, "I"); + + // do switch from 1 .. count - 1 mapping 0 to the default case + switchStart = cfw.addTableSwitch(1, count - 1); + } + + for (int i = 0; i != count; ++i) { + ScriptOrFnNode n = scriptOrFnNodes[i]; + if (i == 0) { + if (count > 1) { + cfw.markTableSwitchDefault(switchStart); + switchStackTop = cfw.getStackTop(); + } + } else { + cfw.markTableSwitchCase(switchStart, i - 1, + switchStackTop); + } + + // Impelemnet method-specific switch code + switch (methodIndex) { + case Do_getFunctionName: + // Push function name + if (n.getType() == Token.SCRIPT) { + cfw.addPush(""); + } else { + String name = ((FunctionNode)n).getFunctionName(); + cfw.addPush(name); + } + cfw.add(ByteCode.ARETURN); + break; + + case Do_getParamCount: + // Push number of defined parameters + cfw.addPush(n.getParamCount()); + cfw.add(ByteCode.IRETURN); + break; + + case Do_getParamAndVarCount: + // Push number of defined parameters and declared variables + cfw.addPush(n.getParamAndVarCount()); + cfw.add(ByteCode.IRETURN); + break; + + case Do_getParamOrVarName: + // Push name of parameter using another switch + // over paramAndVarCount + int paramAndVarCount = n.getParamAndVarCount(); + if (paramAndVarCount == 0) { + // The runtime should never call the method in this + // case but to make bytecode verifier happy return null + // as throwing execption takes more code + cfw.add(ByteCode.ACONST_NULL); + cfw.add(ByteCode.ARETURN); + } else if (paramAndVarCount == 1) { + // As above do not check for valid index but always + // return the name of the first param + cfw.addPush(n.getParamOrVarName(0)); + cfw.add(ByteCode.ARETURN); + } else { + // Do switch over getParamOrVarName + cfw.addILoad(1); // param or var index + // do switch from 1 .. paramAndVarCount - 1 mapping 0 + // to the default case + int paramSwitchStart = cfw.addTableSwitch( + 1, paramAndVarCount - 1); + for (int j = 0; j != paramAndVarCount; ++j) { + if (cfw.getStackTop() != 0) Kit.codeBug(); + String s = n.getParamOrVarName(j); + if (j == 0) { + cfw.markTableSwitchDefault(paramSwitchStart); + } else { + cfw.markTableSwitchCase(paramSwitchStart, j - 1, + 0); + } + cfw.addPush(s); + cfw.add(ByteCode.ARETURN); + } + } + break; + + case Do_getParamOrVarConst: + // Push name of parameter using another switch + // over paramAndVarCount + paramAndVarCount = n.getParamAndVarCount(); + boolean [] constness = n.getParamAndVarConst(); + if (paramAndVarCount == 0) { + // The runtime should never call the method in this + // case but to make bytecode verifier happy return null + // as throwing execption takes more code + cfw.add(ByteCode.ICONST_0); + cfw.add(ByteCode.IRETURN); + } else if (paramAndVarCount == 1) { + // As above do not check for valid index but always + // return the name of the first param + cfw.addPush(constness[0]); + cfw.add(ByteCode.IRETURN); + } else { + // Do switch over getParamOrVarName + cfw.addILoad(1); // param or var index + // do switch from 1 .. paramAndVarCount - 1 mapping 0 + // to the default case + int paramSwitchStart = cfw.addTableSwitch( + 1, paramAndVarCount - 1); + for (int j = 0; j != paramAndVarCount; ++j) { + if (cfw.getStackTop() != 0) Kit.codeBug(); + if (j == 0) { + cfw.markTableSwitchDefault(paramSwitchStart); + } else { + cfw.markTableSwitchCase(paramSwitchStart, j - 1, + 0); + } + cfw.addPush(constness[j]); + cfw.add(ByteCode.IRETURN); + } + } + break; + + case Do_getEncodedSource: + // Push number encoded source start and end + // to prepare for encodedSource.substring(start, end) + cfw.addPush(n.getEncodedSourceStart()); + cfw.addPush(n.getEncodedSourceEnd()); + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, + "java/lang/String", + "substring", + "(II)Ljava/lang/String;"); + cfw.add(ByteCode.ARETURN); + break; + + default: + throw Kit.codeBug(); + } + } + + cfw.stopMethod(methodLocals); + } + } + + private void emitRegExpInit(ClassFileWriter cfw) + { + // precompile all regexp literals + + int totalRegCount = 0; + for (int i = 0; i != scriptOrFnNodes.length; ++i) { + totalRegCount += scriptOrFnNodes[i].getRegexpCount(); + } + if (totalRegCount == 0) { + return; + } + + cfw.startMethod(REGEXP_INIT_METHOD_NAME, REGEXP_INIT_METHOD_SIGNATURE, + (short)(ClassFileWriter.ACC_STATIC | ClassFileWriter.ACC_PRIVATE + | ClassFileWriter.ACC_SYNCHRONIZED)); + cfw.addField("_reInitDone", "Z", + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + cfw.add(ByteCode.GETSTATIC, mainClassName, "_reInitDone", "Z"); + int doInit = cfw.acquireLabel(); + cfw.add(ByteCode.IFEQ, doInit); + cfw.add(ByteCode.RETURN); + cfw.markLabel(doInit); + + for (int i = 0; i != scriptOrFnNodes.length; ++i) { + ScriptOrFnNode n = scriptOrFnNodes[i]; + int regCount = n.getRegexpCount(); + for (int j = 0; j != regCount; ++j) { + String reFieldName = getCompiledRegexpName(n, j); + String reFieldType = "Ljava/lang/Object;"; + String reString = n.getRegexpString(j); + String reFlags = n.getRegexpFlags(j); + cfw.addField(reFieldName, reFieldType, + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + cfw.addALoad(0); // proxy + cfw.addALoad(1); // context + cfw.addPush(reString); + if (reFlags == null) { + cfw.add(ByteCode.ACONST_NULL); + } else { + cfw.addPush(reFlags); + } + /*APPJET*/cfw.addLineNumberEntry((short)n.getRegexpLineno(j)); + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/RegExpProxy", + "compileRegExp", + "(Lorg/mozilla/javascript/Context;" + +"Ljava/lang/String;Ljava/lang/String;" + +")Ljava/lang/Object;"); + cfw.add(ByteCode.PUTSTATIC, mainClassName, + reFieldName, reFieldType); + } + } + + cfw.addPush(1); + cfw.add(ByteCode.PUTSTATIC, mainClassName, "_reInitDone", "Z"); + cfw.add(ByteCode.RETURN); + cfw.stopMethod((short)2); + } + + private void emitConstantDudeInitializers(ClassFileWriter cfw) + { + int N = itsConstantListSize; + if (N == 0) + return; + + cfw.startMethod("<clinit>", "()V", + (short)(ClassFileWriter.ACC_STATIC | ClassFileWriter.ACC_FINAL)); + + double[] array = itsConstantList; + for (int i = 0; i != N; ++i) { + double num = array[i]; + String constantName = "_k" + i; + String constantType = getStaticConstantWrapperType(num); + cfw.addField(constantName, constantType, + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + int inum = (int)num; + if (inum == num) { + cfw.add(ByteCode.NEW, "java/lang/Integer"); + cfw.add(ByteCode.DUP); + cfw.addPush(inum); + cfw.addInvoke(ByteCode.INVOKESPECIAL, "java/lang/Integer", + "<init>", "(I)V"); + } else { + cfw.addPush(num); + addDoubleWrap(cfw); + } + cfw.add(ByteCode.PUTSTATIC, mainClassName, + constantName, constantType); + } + + cfw.add(ByteCode.RETURN); + cfw.stopMethod((short)0); + } + + void pushRegExpArray(ClassFileWriter cfw, ScriptOrFnNode n, + int contextArg, int scopeArg) + { + int regexpCount = n.getRegexpCount(); + if (regexpCount == 0) throw badTree(); + + cfw.addPush(regexpCount); + cfw.add(ByteCode.ANEWARRAY, "java/lang/Object"); + + cfw.addALoad(contextArg); + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/ScriptRuntime", + "checkRegExpProxy", + "(Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/RegExpProxy;"); + // Stack: proxy, array + cfw.add(ByteCode.DUP); + cfw.addALoad(contextArg); + cfw.addInvoke(ByteCode.INVOKESTATIC, mainClassName, + REGEXP_INIT_METHOD_NAME, REGEXP_INIT_METHOD_SIGNATURE); + for (int i = 0; i != regexpCount; ++i) { + // Stack: proxy, array + cfw.add(ByteCode.DUP2); + cfw.addALoad(contextArg); + cfw.addALoad(scopeArg); + cfw.add(ByteCode.GETSTATIC, mainClassName, + getCompiledRegexpName(n, i), "Ljava/lang/Object;"); + // Stack: compiledRegExp, scope, cx, proxy, array, proxy, array + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/RegExpProxy", + "wrapRegExp", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + // Stack: wrappedRegExp, array, proxy, array + cfw.addPush(i); + cfw.add(ByteCode.SWAP); + cfw.add(ByteCode.AASTORE); + // Stack: proxy, array + } + // remove proxy + cfw.add(ByteCode.POP); + } + + void pushNumberAsObject(ClassFileWriter cfw, double num) + { + if (num == 0.0) { + if (1 / num > 0) { + // +0.0 + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/optimizer/OptRuntime", + "zeroObj", "Ljava/lang/Double;"); + } else { + cfw.addPush(num); + addDoubleWrap(cfw); + } + + } else if (num == 1.0) { + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/optimizer/OptRuntime", + "oneObj", "Ljava/lang/Double;"); + return; + + } else if (num == -1.0) { + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/optimizer/OptRuntime", + "minusOneObj", "Ljava/lang/Double;"); + + } else if (num != num) { + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/ScriptRuntime", + "NaNobj", "Ljava/lang/Double;"); + + } else if (itsConstantListSize >= 2000) { + // There appears to be a limit in the JVM on either the number + // of static fields in a class or the size of the class + // initializer. Either way, we can't have any more than 2000 + // statically init'd constants. + cfw.addPush(num); + addDoubleWrap(cfw); + + } else { + int N = itsConstantListSize; + int index = 0; + if (N == 0) { + itsConstantList = new double[64]; + } else { + double[] array = itsConstantList; + while (index != N && array[index] != num) { + ++index; + } + if (N == array.length) { + array = new double[N * 2]; + System.arraycopy(itsConstantList, 0, array, 0, N); + itsConstantList = array; + } + } + if (index == N) { + itsConstantList[N] = num; + itsConstantListSize = N + 1; + } + String constantName = "_k" + index; + String constantType = getStaticConstantWrapperType(num); + cfw.add(ByteCode.GETSTATIC, mainClassName, + constantName, constantType); + } + } + + private static void addDoubleWrap(ClassFileWriter cfw) + { + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/optimizer/OptRuntime", + "wrapDouble", "(D)Ljava/lang/Double;"); + } + + private static String getStaticConstantWrapperType(double num) + { + int inum = (int)num; + if (inum == num) { + return "Ljava/lang/Integer;"; + } else { + return "Ljava/lang/Double;"; + } + } + static void pushUndefined(ClassFileWriter cfw) + { + cfw.add(ByteCode.GETSTATIC, "org/mozilla/javascript/Undefined", + "instance", "Ljava/lang/Object;"); + } + + int getIndex(ScriptOrFnNode n) + { + return scriptOrFnIndexes.getExisting(n); + } + + static String getDirectTargetFieldName(int i) + { + return "_dt" + i; + } + + String getDirectCtorName(ScriptOrFnNode n) + { + return "_n"+getIndex(n); + } + + String getBodyMethodName(ScriptOrFnNode n) + { + return "_c"+getIndex(n); + } + + String getBodyMethodSignature(ScriptOrFnNode n) + { + StringBuffer sb = new StringBuffer(); + sb.append('('); + sb.append(mainClassSignature); + sb.append("Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;"); + if (n.getType() == Token.FUNCTION) { + OptFunctionNode ofn = OptFunctionNode.get(n); + if (ofn.isTargetOfDirectCall()) { + int pCount = ofn.fnode.getParamCount(); + for (int i = 0; i != pCount; i++) { + sb.append("Ljava/lang/Object;D"); + } + } + } + sb.append("[Ljava/lang/Object;)Ljava/lang/Object;"); + return sb.toString(); + } + + String getFunctionInitMethodName(OptFunctionNode ofn) + { + return "_i"+getIndex(ofn.fnode); + } + + String getCompiledRegexpName(ScriptOrFnNode n, int regexpIndex) + { + return "_re"+getIndex(n)+"_"+regexpIndex; + } + + static RuntimeException badTree() + { + throw new RuntimeException("Bad tree in codegen"); + } + + void setMainMethodClass(String className) + { + mainMethodClass = className; + } + + static final String DEFAULT_MAIN_METHOD_CLASS + = "org.mozilla.javascript.optimizer.OptRuntime"; + + private static final String SUPER_CLASS_NAME + = "org.mozilla.javascript.NativeFunction"; + + static final String DIRECT_CALL_PARENT_FIELD = "_dcp"; + private static final String ID_FIELD_NAME = "_id"; + + private static final String REGEXP_INIT_METHOD_NAME = "_reInit"; + private static final String REGEXP_INIT_METHOD_SIGNATURE + = "(Lorg/mozilla/javascript/RegExpProxy;" + +"Lorg/mozilla/javascript/Context;" + +")V"; + static final String REGEXP_ARRAY_FIELD_NAME = "_re"; + static final String REGEXP_ARRAY_FIELD_TYPE = "[Ljava/lang/Object;"; + + static final String FUNCTION_INIT_SIGNATURE + = "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")V"; + + static final String FUNCTION_CONSTRUCTOR_SIGNATURE + = "(Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Context;I)V"; + + private static final Object globalLock = new Object(); + private static int globalSerialClassCounter; + + private CompilerEnvirons compilerEnv; + + private ObjArray directCallTargets; + ScriptOrFnNode[] scriptOrFnNodes; + private ObjToIntMap scriptOrFnIndexes; + + private String mainMethodClass = DEFAULT_MAIN_METHOD_CLASS; + + String mainClassName; + String mainClassSignature; + + private double[] itsConstantList; + private int itsConstantListSize; +} + + +class BodyCodegen +{ + void generateBodyCode() + { + isGenerator = Codegen.isGenerator(scriptOrFn); + + // generate the body of the current function or script object + initBodyGeneration(); + + if (isGenerator) { + + // All functions in the generated bytecode have a unique name. Every + // generator has a unique prefix followed by _gen + String type = "(" + + codegen.mainClassSignature + + "Lorg/mozilla/javascript/Context;" + + "Lorg/mozilla/javascript/Scriptable;" + + "Ljava/lang/Object;" + + "Ljava/lang/Object;I)Ljava/lang/Object;"; + cfw.startMethod(codegen.getBodyMethodName(scriptOrFn) + "_gen", + type, + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + } else { + cfw.startMethod(codegen.getBodyMethodName(scriptOrFn), + codegen.getBodyMethodSignature(scriptOrFn), + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + } + + generatePrologue(); + Node treeTop; + if (fnCurrent != null) { + treeTop = scriptOrFn.getLastChild(); + } else { + treeTop = scriptOrFn; + } + generateStatement(treeTop); + generateEpilogue(); + + cfw.stopMethod((short)(localsMax + 1)); + + if (isGenerator) { + // generate the user visible method which when invoked will + // return a generator object + generateGenerator(); + } + } + + // This creates a the user-facing function that returns a NativeGenerator + // object. + private void generateGenerator() + { + cfw.startMethod(codegen.getBodyMethodName(scriptOrFn), + codegen.getBodyMethodSignature(scriptOrFn), + (short)(ClassFileWriter.ACC_STATIC + | ClassFileWriter.ACC_PRIVATE)); + + initBodyGeneration(); + argsLocal = firstFreeLocal++; + localsMax = firstFreeLocal; + + // get top level scope + if (fnCurrent != null && !inDirectCallFunction + && (!compilerEnv.isUseDynamicScope() + || fnCurrent.fnode.getIgnoreDynamicScope())) + { + // Unless we're either in a direct call or using dynamic scope, + // use the enclosing scope of the function as our variable object. + cfw.addALoad(funObjLocal); + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/Scriptable", + "getParentScope", + "()Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + } + + // generators are forced to have an activation record + cfw.addALoad(funObjLocal); + cfw.addALoad(variableObjectLocal); + cfw.addALoad(argsLocal); + addScriptRuntimeInvoke("createFunctionActivation", + "(Lorg/mozilla/javascript/NativeFunction;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + + // create a function object + cfw.add(ByteCode.NEW, codegen.mainClassName); + // Call function constructor + cfw.add(ByteCode.DUP); + cfw.addALoad(variableObjectLocal); + cfw.addALoad(contextLocal); // load 'cx' + cfw.addPush(scriptOrFnIndex); + cfw.addInvoke(ByteCode.INVOKESPECIAL, codegen.mainClassName, + "<init>", Codegen.FUNCTION_CONSTRUCTOR_SIGNATURE); + + // Init mainScript field + cfw.add(ByteCode.DUP); + if (isTopLevel) Kit.codeBug(); // Only functions can be generators + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, + codegen.mainClassName, + Codegen.DIRECT_CALL_PARENT_FIELD, + codegen.mainClassSignature); + cfw.add(ByteCode.PUTFIELD, + codegen.mainClassName, + Codegen.DIRECT_CALL_PARENT_FIELD, + codegen.mainClassSignature); + + generateNestedFunctionInits(); + + // create the NativeGenerator object that we return + cfw.addALoad(variableObjectLocal); + cfw.addALoad(thisObjLocal); + cfw.addLoadConstant(maxLocals); + cfw.addLoadConstant(maxStack); + addOptRuntimeInvoke("createNativeGenerator", + "(Lorg/mozilla/javascript/NativeFunction;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;II" + +")Lorg/mozilla/javascript/Scriptable;"); + + cfw.add(ByteCode.ARETURN); + cfw.stopMethod((short)(localsMax + 1)); + } + + private void generateNestedFunctionInits() + { + int functionCount = scriptOrFn.getFunctionCount(); + for (int i = 0; i != functionCount; i++) { + OptFunctionNode ofn = OptFunctionNode.get(scriptOrFn, i); + if (ofn.fnode.getFunctionType() + == FunctionNode.FUNCTION_STATEMENT) + { + visitFunction(ofn, FunctionNode.FUNCTION_STATEMENT); + } + } + } + + private void initBodyGeneration() + { + isTopLevel = (scriptOrFn == codegen.scriptOrFnNodes[0]); + + varRegisters = null; + if (scriptOrFn.getType() == Token.FUNCTION) { + fnCurrent = OptFunctionNode.get(scriptOrFn); + hasVarsInRegs = !fnCurrent.fnode.requiresActivation(); + if (hasVarsInRegs) { + int n = fnCurrent.fnode.getParamAndVarCount(); + if (n != 0) { + varRegisters = new short[n]; + } + } + inDirectCallFunction = fnCurrent.isTargetOfDirectCall(); + if (inDirectCallFunction && !hasVarsInRegs) Codegen.badTree(); + } else { + fnCurrent = null; + hasVarsInRegs = false; + inDirectCallFunction = false; + } + + locals = new int[MAX_LOCALS]; + + funObjLocal = 0; + contextLocal = 1; + variableObjectLocal = 2; + thisObjLocal = 3; + localsMax = (short) 4; // number of parms + "this" + firstFreeLocal = 4; + + popvLocal = -1; + argsLocal = -1; + itsZeroArgArray = -1; + itsOneArgArray = -1; + scriptRegexpLocal = -1; + epilogueLabel = -1; + enterAreaStartLabel = -1; + generatorStateLocal = -1; + } + + /** + * Generate the prologue for a function or script. + */ + private void generatePrologue() + { + if (inDirectCallFunction) { + int directParameterCount = scriptOrFn.getParamCount(); + // 0 is reserved for function Object 'this' + // 1 is reserved for context + // 2 is reserved for parentScope + // 3 is reserved for script 'this' + if (firstFreeLocal != 4) Kit.codeBug(); + for (int i = 0; i != directParameterCount; ++i) { + varRegisters[i] = firstFreeLocal; + // 3 is 1 for Object parm and 2 for double parm + firstFreeLocal += 3; + } + if (!fnCurrent.getParameterNumberContext()) { + // make sure that all parameters are objects + itsForcedObjectParameters = true; + for (int i = 0; i != directParameterCount; ++i) { + short reg = varRegisters[i]; + cfw.addALoad(reg); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + int isObjectLabel = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPNE, isObjectLabel); + cfw.addDLoad(reg + 1); + addDoubleWrap(); + cfw.addAStore(reg); + cfw.markLabel(isObjectLabel); + } + } + } + + if (fnCurrent != null && !inDirectCallFunction + && (!compilerEnv.isUseDynamicScope() + || fnCurrent.fnode.getIgnoreDynamicScope())) + { + // Unless we're either in a direct call or using dynamic scope, + // use the enclosing scope of the function as our variable object. + cfw.addALoad(funObjLocal); + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/Scriptable", + "getParentScope", + "()Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + } + + // reserve 'args[]' + argsLocal = firstFreeLocal++; + localsMax = firstFreeLocal; + + // Generate Generator specific prelude + if (isGenerator) { + + // reserve 'args[]' + operationLocal = firstFreeLocal++; + localsMax = firstFreeLocal; + + // Local 3 is a reference to a GeneratorState object. The rest + // of codegen expects local 3 to be a reference to the thisObj. + // So move the value in local 3 to generatorStateLocal, and load + // the saved thisObj from the GeneratorState object. + cfw.addALoad(thisObjLocal); + generatorStateLocal = firstFreeLocal++; + localsMax = firstFreeLocal; + cfw.add(ByteCode.CHECKCAST, OptRuntime.GeneratorState.CLASS_NAME); + cfw.add(ByteCode.DUP); + cfw.addAStore(generatorStateLocal); + cfw.add(ByteCode.GETFIELD, + OptRuntime.GeneratorState.CLASS_NAME, + OptRuntime.GeneratorState.thisObj_NAME, + OptRuntime.GeneratorState.thisObj_TYPE); + cfw.addAStore(thisObjLocal); + + if (epilogueLabel == -1) { + epilogueLabel = cfw.acquireLabel(); + } + + ArrayList targets = ((FunctionNode)scriptOrFn).getResumptionPoints(); + if (targets != null) { + // get resumption point + generateGetGeneratorResumptionPoint(); + + // generate dispatch table + generatorSwitch = cfw.addTableSwitch(0, + targets.size() + GENERATOR_START); + generateCheckForThrowOrClose(-1, false, GENERATOR_START); + } + } + + if (fnCurrent == null) { + // See comments in case Token.REGEXP + if (scriptOrFn.getRegexpCount() != 0) { + scriptRegexpLocal = getNewWordLocal(); + codegen.pushRegExpArray(cfw, scriptOrFn, contextLocal, + variableObjectLocal); + cfw.addAStore(scriptRegexpLocal); + } + } + + if (compilerEnv.isGenerateObserverCount()) + saveCurrentCodeOffset(); + + if (hasVarsInRegs) { + // No need to create activation. Pad arguments if need be. + int parmCount = scriptOrFn.getParamCount(); + if (parmCount > 0 && !inDirectCallFunction) { + // Set up args array + // check length of arguments, pad if need be + cfw.addALoad(argsLocal); + cfw.add(ByteCode.ARRAYLENGTH); + cfw.addPush(parmCount); + int label = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ICMPGE, label); + cfw.addALoad(argsLocal); + cfw.addPush(parmCount); + addScriptRuntimeInvoke("padArguments", + "([Ljava/lang/Object;I" + +")[Ljava/lang/Object;"); + cfw.addAStore(argsLocal); + cfw.markLabel(label); + } + + int paramCount = fnCurrent.fnode.getParamCount(); + int varCount = fnCurrent.fnode.getParamAndVarCount(); + boolean [] constDeclarations = fnCurrent.fnode.getParamAndVarConst(); + + // REMIND - only need to initialize the vars that don't get a value + // before the next call and are used in the function + short firstUndefVar = -1; + for (int i = 0; i != varCount; ++i) { + short reg = -1; + if (i < paramCount) { + if (!inDirectCallFunction) { + reg = getNewWordLocal(); + cfw.addALoad(argsLocal); + cfw.addPush(i); + cfw.add(ByteCode.AALOAD); + cfw.addAStore(reg); + } + } else if (fnCurrent.isNumberVar(i)) { + reg = getNewWordPairLocal(constDeclarations[i]); + cfw.addPush(0.0); + cfw.addDStore(reg); + } else { + reg = getNewWordLocal(constDeclarations[i]); + if (firstUndefVar == -1) { + Codegen.pushUndefined(cfw); + firstUndefVar = reg; + } else { + cfw.addALoad(firstUndefVar); + } + cfw.addAStore(reg); + } + if (reg >= 0) { + if (constDeclarations[i]) { + cfw.addPush(0); + cfw.addIStore(reg + (fnCurrent.isNumberVar(i) ? 2 : 1)); + } + varRegisters[i] = reg; + } + + // Add debug table entry if we're generating debug info + if (compilerEnv.isGenerateDebugInfo()) { + String name = fnCurrent.fnode.getParamOrVarName(i); + String type = fnCurrent.isNumberVar(i) + ? "D" : "Ljava/lang/Object;"; + int startPC = cfw.getCurrentCodeOffset(); + if (reg < 0) { + reg = varRegisters[i]; + } + cfw.addVariableDescriptor(name, type, startPC, reg); + } + } + + // Skip creating activation object. + return; + } + + // skip creating activation object for the body of a generator. The + // activation record required by a generator has already been created + // in generateGenerator(). + if (isGenerator) + return; + + + String debugVariableName; + if (fnCurrent != null) { + debugVariableName = "activation"; + cfw.addALoad(funObjLocal); + cfw.addALoad(variableObjectLocal); + cfw.addALoad(argsLocal); + addScriptRuntimeInvoke("createFunctionActivation", + "(Lorg/mozilla/javascript/NativeFunction;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke("enterActivationFunction", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")V"); + } else { + debugVariableName = "global"; + cfw.addALoad(funObjLocal); + cfw.addALoad(thisObjLocal); + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + cfw.addPush(0); // false to indicate it is not eval script + addScriptRuntimeInvoke("initScript", + "(Lorg/mozilla/javascript/NativeFunction;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Z" + +")V"); + } + + enterAreaStartLabel = cfw.acquireLabel(); + epilogueLabel = cfw.acquireLabel(); + cfw.markLabel(enterAreaStartLabel); + + generateNestedFunctionInits(); + + // default is to generate debug info + if (compilerEnv.isGenerateDebugInfo()) { + cfw.addVariableDescriptor(debugVariableName, + "Lorg/mozilla/javascript/Scriptable;", + cfw.getCurrentCodeOffset(), variableObjectLocal); + } + + if (fnCurrent == null) { + // OPT: use dataflow to prove that this assignment is dead + popvLocal = getNewWordLocal(); + Codegen.pushUndefined(cfw); + cfw.addAStore(popvLocal); + + int linenum = scriptOrFn.getEndLineno(); + if (linenum != -1) + cfw.addLineNumberEntry((short)linenum); + + } else { + if (fnCurrent.itsContainsCalls0) { + itsZeroArgArray = getNewWordLocal(); + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/ScriptRuntime", + "emptyArgs", "[Ljava/lang/Object;"); + cfw.addAStore(itsZeroArgArray); + } + if (fnCurrent.itsContainsCalls1) { + itsOneArgArray = getNewWordLocal(); + cfw.addPush(1); + cfw.add(ByteCode.ANEWARRAY, "java/lang/Object"); + cfw.addAStore(itsOneArgArray); + } + } + } + + private void generateGetGeneratorResumptionPoint() + { + cfw.addALoad(generatorStateLocal); + cfw.add(ByteCode.GETFIELD, + OptRuntime.GeneratorState.CLASS_NAME, + OptRuntime.GeneratorState.resumptionPoint_NAME, + OptRuntime.GeneratorState.resumptionPoint_TYPE); + } + + private void generateSetGeneratorResumptionPoint(int nextState) + { + cfw.addALoad(generatorStateLocal); + cfw.addLoadConstant(nextState); + cfw.add(ByteCode.PUTFIELD, + OptRuntime.GeneratorState.CLASS_NAME, + OptRuntime.GeneratorState.resumptionPoint_NAME, + OptRuntime.GeneratorState.resumptionPoint_TYPE); + } + + private void generateGetGeneratorStackState() + { + cfw.addALoad(generatorStateLocal); + addOptRuntimeInvoke("getGeneratorStackState", + "(Ljava/lang/Object;)[Ljava/lang/Object;"); + } + + private void generateEpilogue() + { + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + if (isGenerator) { + // generate locals initialization + HashMap liveLocals = ((FunctionNode)scriptOrFn).getLiveLocals(); + if (liveLocals != null) { + ArrayList nodes = ((FunctionNode)scriptOrFn).getResumptionPoints(); + for (int i = 0; i < nodes.size(); i++) { + Node node = (Node) nodes.get(i); + int[] live = (int [])liveLocals.get(node); + if (live != null) { + cfw.markTableSwitchCase(generatorSwitch, + getNextGeneratorState(node)); + generateGetGeneratorLocalsState(); + for (int j = 0; j < live.length; j++) { + cfw.add(ByteCode.DUP); + cfw.addLoadConstant(j); + cfw.add(ByteCode.AALOAD); + cfw.addAStore(live[j]); + } + cfw.add(ByteCode.POP); + cfw.add(ByteCode.GOTO, getTargetLabel(node)); + } + } + } + + // generate dispatch tables for finally + if (finallys != null) { + Enumeration en = finallys.keys(); + while(en.hasMoreElements()) { + Node n = (Node) en.nextElement(); + if (n.getType() == Token.FINALLY) { + FinallyReturnPoint ret = + (FinallyReturnPoint)finallys.get(n); + // the finally will jump here + cfw.markLabel(ret.tableLabel, (short)1); + + // start generating a dispatch table + int startSwitch = cfw.addTableSwitch(0, + ret.jsrPoints.size() - 1); + int c = 0; + cfw.markTableSwitchDefault(startSwitch); + for (int i = 0; i < ret.jsrPoints.size(); i++) { + // generate gotos back to the JSR location + cfw.markTableSwitchCase(startSwitch, c); + cfw.add(ByteCode.GOTO, + ((Integer)ret.jsrPoints.get(i)).intValue()); + c++; + } + } + } + } + } + + if (epilogueLabel != -1) { + cfw.markLabel(epilogueLabel); + } + + if (hasVarsInRegs) { + cfw.add(ByteCode.ARETURN); + return; + } else if (isGenerator) { + if (((FunctionNode)scriptOrFn).getResumptionPoints() != null) { + cfw.markTableSwitchDefault(generatorSwitch); + } + + // change state for re-entry + generateSetGeneratorResumptionPoint(GENERATOR_TERMINATE); + + // throw StopIteration + cfw.addALoad(variableObjectLocal); + addOptRuntimeInvoke("throwStopIteration", + "(Ljava/lang/Object;)V"); + + Codegen.pushUndefined(cfw); + cfw.add(ByteCode.ARETURN); + + } else if (fnCurrent == null) { + cfw.addALoad(popvLocal); + cfw.add(ByteCode.ARETURN); + } else { + generateActivationExit(); + cfw.add(ByteCode.ARETURN); + + // Generate catch block to catch all and rethrow to call exit code + // under exception propagation as well. + + int finallyHandler = cfw.acquireLabel(); + cfw.markHandler(finallyHandler); + short exceptionObject = getNewWordLocal(); + cfw.addAStore(exceptionObject); + + // Duplicate generateActivationExit() in the catch block since it + // takes less space then full-featured ByteCode.JSR/ByteCode.RET + generateActivationExit(); + + cfw.addALoad(exceptionObject); + releaseWordLocal(exceptionObject); + // rethrow + cfw.add(ByteCode.ATHROW); + + // mark the handler + cfw.addExceptionHandler(enterAreaStartLabel, epilogueLabel, + finallyHandler, null); // catch any + } + } + + private void generateGetGeneratorLocalsState() { + cfw.addALoad(generatorStateLocal); + addOptRuntimeInvoke("getGeneratorLocalsState", + "(Ljava/lang/Object;)[Ljava/lang/Object;"); + } + + private void generateActivationExit() + { + if (fnCurrent == null || hasVarsInRegs) throw Kit.codeBug(); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("exitActivationFunction", + "(Lorg/mozilla/javascript/Context;)V"); + } + + private void generateStatement(Node node) + { + updateLineNumber(node); + int type = node.getType(); + Node child = node.getFirstChild(); + switch (type) { + case Token.LOOP: + case Token.LABEL: + case Token.WITH: + case Token.SCRIPT: + case Token.BLOCK: + case Token.EMPTY: + // no-ops. + while (child != null) { + generateStatement(child); + child = child.getNext(); + } + break; + + case Token.LOCAL_BLOCK: { + int local = getNewWordLocal(); + if (isGenerator) { + cfw.add(ByteCode.ACONST_NULL); + cfw.addAStore(local); + } + node.putIntProp(Node.LOCAL_PROP, local); + while (child != null) { + generateStatement(child); + child = child.getNext(); + } + releaseWordLocal((short)local); + node.removeProp(Node.LOCAL_PROP); + break; + } + + case Token.FUNCTION: { + int fnIndex = node.getExistingIntProp(Node.FUNCTION_PROP); + OptFunctionNode ofn = OptFunctionNode.get(scriptOrFn, fnIndex); + int t = ofn.fnode.getFunctionType(); + if (t == FunctionNode.FUNCTION_EXPRESSION_STATEMENT) { + visitFunction(ofn, t); + } else { + if (t != FunctionNode.FUNCTION_STATEMENT) { + throw Codegen.badTree(); + } + } + break; + } + + case Token.TRY: + visitTryCatchFinally((Node.Jump)node, child); + break; + + case Token.CATCH_SCOPE: + { + // nothing stays on the stack on entry into a catch scope + cfw.setStackTop((short) 0); + + int local = getLocalBlockRegister(node); + int scopeIndex + = node.getExistingIntProp(Node.CATCH_SCOPE_PROP); + + String name = child.getString(); // name of exception + child = child.getNext(); + generateExpression(child, node); // load expression object + if (scopeIndex == 0) { + cfw.add(ByteCode.ACONST_NULL); + } else { + // Load previous catch scope object + cfw.addALoad(local); + } + cfw.addPush(name); + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + + addScriptRuntimeInvoke( + "newCatchScope", + "(Ljava/lang/Throwable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(local); + } + break; + + case Token.THROW: + generateExpression(child, node); + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + generateThrowJavaScriptException(); + break; + + case Token.RETHROW: + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + cfw.addALoad(getLocalBlockRegister(node)); + cfw.add(ByteCode.ATHROW); + break; + + case Token.RETURN_RESULT: + case Token.RETURN: + if (!isGenerator) { + if (child != null) { + generateExpression(child, node); + } else if (type == Token.RETURN) { + Codegen.pushUndefined(cfw); + } else { + if (popvLocal < 0) throw Codegen.badTree(); + cfw.addALoad(popvLocal); + } + } + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + if (epilogueLabel == -1) { + if (!hasVarsInRegs) throw Codegen.badTree(); + epilogueLabel = cfw.acquireLabel(); + } + cfw.add(ByteCode.GOTO, epilogueLabel); + break; + + case Token.SWITCH: + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + visitSwitch((Node.Jump)node, child); + break; + + case Token.ENTERWITH: + generateExpression(child, node); + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke( + "enterWith", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + incReferenceWordLocal(variableObjectLocal); + break; + + case Token.LEAVEWITH: + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke( + "leaveWith", + "(Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + decReferenceWordLocal(variableObjectLocal); + break; + + case Token.ENUM_INIT_KEYS: + case Token.ENUM_INIT_VALUES: + case Token.ENUM_INIT_ARRAY: + generateExpression(child, node); + cfw.addALoad(contextLocal); + int enumType = type == Token.ENUM_INIT_KEYS + ? ScriptRuntime.ENUMERATE_KEYS : + type == Token.ENUM_INIT_VALUES + ? ScriptRuntime.ENUMERATE_VALUES : + ScriptRuntime.ENUMERATE_ARRAY; + cfw.addPush(enumType); + addScriptRuntimeInvoke("enumInit", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"I" + +")Ljava/lang/Object;"); + cfw.addAStore(getLocalBlockRegister(node)); + break; + + case Token.EXPR_VOID: + if (child.getType() == Token.SETVAR) { + /* special case this so as to avoid unnecessary + load's & pop's */ + visitSetVar(child, child.getFirstChild(), false); + } + else if (child.getType() == Token.SETCONSTVAR) { + /* special case this so as to avoid unnecessary + load's & pop's */ + visitSetConstVar(child, child.getFirstChild(), false); + } + else if (child.getType() == Token.YIELD) { + generateYieldPoint(child, false); + } + else { + generateExpression(child, node); + if (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1) + cfw.add(ByteCode.POP2); + else + cfw.add(ByteCode.POP); + } + break; + + case Token.EXPR_RESULT: + generateExpression(child, node); + if (popvLocal < 0) { + popvLocal = getNewWordLocal(); + } + cfw.addAStore(popvLocal); + break; + + case Token.TARGET: + { + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + int label = getTargetLabel(node); + cfw.markLabel(label); + if (compilerEnv.isGenerateObserverCount()) + saveCurrentCodeOffset(); + } + break; + + case Token.JSR: + case Token.GOTO: + case Token.IFEQ: + case Token.IFNE: + if (compilerEnv.isGenerateObserverCount()) + addInstructionCount(); + visitGoto((Node.Jump)node, type, child); + break; + + case Token.FINALLY: + { + if (compilerEnv.isGenerateObserverCount()) + saveCurrentCodeOffset(); + // there is exactly one value on the stack when enterring + // finally blocks: the return address (or its int encoding) + cfw.setStackTop((short)1); + + // Save return address in a new local + int finallyRegister = getNewWordLocal(); + if (isGenerator) + generateIntegerWrap(); + cfw.addAStore(finallyRegister); + + while (child != null) { + generateStatement(child); + child = child.getNext(); + } + if (isGenerator) { + cfw.addALoad(finallyRegister); + cfw.add(ByteCode.CHECKCAST, "java/lang/Integer"); + generateIntegerUnwrap(); + FinallyReturnPoint ret = + (FinallyReturnPoint)finallys.get(node); + ret.tableLabel = cfw.acquireLabel(); + cfw.add(ByteCode.GOTO, ret.tableLabel); + } else { + cfw.add(ByteCode.RET, finallyRegister); + } + releaseWordLocal((short)finallyRegister); + } + break; + + case Token.DEBUGGER: + break; + + default: + throw Codegen.badTree(); + } + + } + + private void generateIntegerWrap() + { + cfw.addInvoke(ByteCode.INVOKESTATIC, "java/lang/Integer", "valueOf", + "(I)Ljava/lang/Integer;"); + } + + + private void generateIntegerUnwrap() + { + cfw.addInvoke(ByteCode.INVOKEVIRTUAL, "java/lang/Integer", + "intValue", "()I"); + } + + + private void generateThrowJavaScriptException() + { + cfw.add(ByteCode.NEW, + "org/mozilla/javascript/JavaScriptException"); + cfw.add(ByteCode.DUP_X1); + cfw.add(ByteCode.SWAP); + cfw.addPush(scriptOrFn.getSourceName()); + cfw.addPush(itsLineNumber); + cfw.addInvoke( + ByteCode.INVOKESPECIAL, + "org/mozilla/javascript/JavaScriptException", + "<init>", + "(Ljava/lang/Object;Ljava/lang/String;I)V"); + cfw.add(ByteCode.ATHROW); + } + + private int getNextGeneratorState(Node node) + { + int nodeIndex = ((FunctionNode)scriptOrFn).getResumptionPoints() + .indexOf(node); + return nodeIndex + GENERATOR_YIELD_START; + } + + private void generateExpression(Node node, Node parent) + { + int type = node.getType(); + Node child = node.getFirstChild(); + switch (type) { + case Token.USE_STACK: + break; + + case Token.FUNCTION: + if (fnCurrent != null || parent.getType() != Token.SCRIPT) { + int fnIndex = node.getExistingIntProp(Node.FUNCTION_PROP); + OptFunctionNode ofn = OptFunctionNode.get(scriptOrFn, + fnIndex); + int t = ofn.fnode.getFunctionType(); + if (t != FunctionNode.FUNCTION_EXPRESSION) { + throw Codegen.badTree(); + } + visitFunction(ofn, t); + } + break; + + case Token.NAME: + { + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + cfw.addPush(node.getString()); + addScriptRuntimeInvoke( + "name", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +")Ljava/lang/Object;"); + } + break; + + case Token.CALL: + case Token.NEW: + { + int specialType = node.getIntProp(Node.SPECIALCALL_PROP, + Node.NON_SPECIALCALL); + if (specialType == Node.NON_SPECIALCALL) { + OptFunctionNode target; + target = (OptFunctionNode)node.getProp( + Node.DIRECTCALL_PROP); + + if (target != null) { + visitOptimizedCall(node, target, type, child); + } else if (type == Token.CALL) { + visitStandardCall(node, child); + } else { + visitStandardNew(node, child); + } + } else { + visitSpecialCall(node, type, specialType, child); + } + } + break; + + case Token.REF_CALL: + generateFunctionAndThisObj(child, node); + // stack: ... functionObj thisObj + child = child.getNext(); + generateCallArgArray(node, child, false); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "callRef", + "(Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/Ref;"); + break; + + case Token.NUMBER: + { + double num = node.getDouble(); + if (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1) { + cfw.addPush(num); + } else { + codegen.pushNumberAsObject(cfw, num); + } + } + break; + + case Token.STRING: + cfw.addPush(node.getString()); + break; + + case Token.THIS: + cfw.addALoad(thisObjLocal); + break; + + case Token.THISFN: + cfw.add(ByteCode.ALOAD_0); + break; + + case Token.NULL: + cfw.add(ByteCode.ACONST_NULL); + break; + + case Token.TRUE: + cfw.add(ByteCode.GETSTATIC, "java/lang/Boolean", + "TRUE", "Ljava/lang/Boolean;"); + break; + + case Token.FALSE: + cfw.add(ByteCode.GETSTATIC, "java/lang/Boolean", + "FALSE", "Ljava/lang/Boolean;"); + break; + + case Token.REGEXP: + { + int i = node.getExistingIntProp(Node.REGEXP_PROP); + // Scripts can not use REGEXP_ARRAY_FIELD_NAME since + // it it will make script.exec non-reentrant so they + // store regexp array in a local variable while + // functions always access precomputed + // REGEXP_ARRAY_FIELD_NAME not to consume locals + if (fnCurrent == null) { + cfw.addALoad(scriptRegexpLocal); + } else { + cfw.addALoad(funObjLocal); + cfw.add(ByteCode.GETFIELD, codegen.mainClassName, + Codegen.REGEXP_ARRAY_FIELD_NAME, + Codegen.REGEXP_ARRAY_FIELD_TYPE); + } + cfw.addPush(i); + cfw.add(ByteCode.AALOAD); + } + break; + + case Token.COMMA: { + Node next = child.getNext(); + while (next != null) { + generateExpression(child, node); + cfw.add(ByteCode.POP); + child = next; + next = next.getNext(); + } + generateExpression(child, node); + break; + } + + case Token.ENUM_NEXT: + case Token.ENUM_ID: { + int local = getLocalBlockRegister(node); + cfw.addALoad(local); + if (type == Token.ENUM_NEXT) { + addScriptRuntimeInvoke( + "enumNext", "(Ljava/lang/Object;)Ljava/lang/Boolean;"); + } else { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("enumId", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + break; + } + + case Token.ARRAYLIT: + visitArrayLiteral(node, child); + break; + + case Token.OBJECTLIT: + visitObjectLiteral(node, child); + break; + + case Token.NOT: { + int trueTarget = cfw.acquireLabel(); + int falseTarget = cfw.acquireLabel(); + int beyond = cfw.acquireLabel(); + generateIfJump(child, node, trueTarget, falseTarget); + + cfw.markLabel(trueTarget); + cfw.add(ByteCode.GETSTATIC, "java/lang/Boolean", + "FALSE", "Ljava/lang/Boolean;"); + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(falseTarget); + cfw.add(ByteCode.GETSTATIC, "java/lang/Boolean", + "TRUE", "Ljava/lang/Boolean;"); + cfw.markLabel(beyond); + cfw.adjustStackTop(-1); + break; + } + + case Token.BITNOT: + generateExpression(child, node); + addScriptRuntimeInvoke("toInt32", "(Ljava/lang/Object;)I"); + cfw.addPush(-1); // implement ~a as (a ^ -1) + cfw.add(ByteCode.IXOR); + cfw.add(ByteCode.I2D); + addDoubleWrap(); + break; + + case Token.VOID: + generateExpression(child, node); + cfw.add(ByteCode.POP); + Codegen.pushUndefined(cfw); + break; + + case Token.TYPEOF: + generateExpression(child, node); + addScriptRuntimeInvoke("typeof", + "(Ljava/lang/Object;" + +")Ljava/lang/String;"); + break; + + case Token.TYPEOFNAME: + visitTypeofname(node); + break; + + case Token.INC: + case Token.DEC: + visitIncDec(node); + break; + + case Token.OR: + case Token.AND: { + generateExpression(child, node); + cfw.add(ByteCode.DUP); + addScriptRuntimeInvoke("toBoolean", + "(Ljava/lang/Object;)Z"); + int falseTarget = cfw.acquireLabel(); + if (type == Token.AND) + cfw.add(ByteCode.IFEQ, falseTarget); + else + cfw.add(ByteCode.IFNE, falseTarget); + cfw.add(ByteCode.POP); + generateExpression(child.getNext(), node); + cfw.markLabel(falseTarget); + } + break; + + case Token.HOOK : { + Node ifThen = child.getNext(); + Node ifElse = ifThen.getNext(); + generateExpression(child, node); + addScriptRuntimeInvoke("toBoolean", + "(Ljava/lang/Object;)Z"); + int elseTarget = cfw.acquireLabel(); + cfw.add(ByteCode.IFEQ, elseTarget); + short stack = cfw.getStackTop(); + generateExpression(ifThen, node); + int afterHook = cfw.acquireLabel(); + cfw.add(ByteCode.GOTO, afterHook); + cfw.markLabel(elseTarget, stack); + generateExpression(ifElse, node); + cfw.markLabel(afterHook); + } + break; + + case Token.ADD: { + generateExpression(child, node); + generateExpression(child.getNext(), node); + switch (node.getIntProp(Node.ISNUMBER_PROP, -1)) { + case Node.BOTH: + cfw.add(ByteCode.DADD); + break; + case Node.LEFT: + addOptRuntimeInvoke("add", + "(DLjava/lang/Object;)Ljava/lang/Object;"); + break; + case Node.RIGHT: + addOptRuntimeInvoke("add", + "(Ljava/lang/Object;D)Ljava/lang/Object;"); + break; + default: + if (child.getType() == Token.STRING) { + addScriptRuntimeInvoke("add", + "(Ljava/lang/String;" + +"Ljava/lang/Object;" + +")Ljava/lang/String;"); + } else if (child.getNext().getType() == Token.STRING) { + addScriptRuntimeInvoke("add", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +")Ljava/lang/String;"); + } else { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("add", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + } + } + break; + + case Token.MUL: + visitArithmetic(node, ByteCode.DMUL, child, parent); + break; + + case Token.SUB: + visitArithmetic(node, ByteCode.DSUB, child, parent); + break; + + case Token.DIV: + case Token.MOD: + visitArithmetic(node, type == Token.DIV + ? ByteCode.DDIV + : ByteCode.DREM, child, parent); + break; + + case Token.BITOR: + case Token.BITXOR: + case Token.BITAND: + case Token.LSH: + case Token.RSH: + case Token.URSH: + visitBitOp(node, type, child); + break; + + case Token.POS: + case Token.NEG: + generateExpression(child, node); + addObjectToDouble(); + if (type == Token.NEG) { + cfw.add(ByteCode.DNEG); + } + addDoubleWrap(); + break; + + case Token.TO_DOUBLE: + // cnvt to double (not Double) + generateExpression(child, node); + addObjectToDouble(); + break; + + case Token.TO_OBJECT: { + // convert from double + int prop = -1; + if (child.getType() == Token.NUMBER) { + prop = child.getIntProp(Node.ISNUMBER_PROP, -1); + } + if (prop != -1) { + child.removeProp(Node.ISNUMBER_PROP); + generateExpression(child, node); + child.putIntProp(Node.ISNUMBER_PROP, prop); + } else { + generateExpression(child, node); + addDoubleWrap(); + } + break; + } + + case Token.IN: + case Token.INSTANCEOF: + case Token.LE: + case Token.LT: + case Token.GE: + case Token.GT: { + int trueGOTO = cfw.acquireLabel(); + int falseGOTO = cfw.acquireLabel(); + visitIfJumpRelOp(node, child, trueGOTO, falseGOTO); + addJumpedBooleanWrap(trueGOTO, falseGOTO); + break; + } + + case Token.EQ: + case Token.NE: + case Token.SHEQ: + case Token.SHNE: { + int trueGOTO = cfw.acquireLabel(); + int falseGOTO = cfw.acquireLabel(); + visitIfJumpEqOp(node, child, trueGOTO, falseGOTO); + addJumpedBooleanWrap(trueGOTO, falseGOTO); + break; + } + + case Token.GETPROP: + case Token.GETPROPNOWARN: + visitGetProp(node, child); + break; + + case Token.GETELEM: + generateExpression(child, node); // object + generateExpression(child.getNext(), node); // id + cfw.addALoad(contextLocal); + if (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1) { + addScriptRuntimeInvoke( + "getObjectIndex", + "(Ljava/lang/Object;D" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + else { + addScriptRuntimeInvoke( + "getObjectElem", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + break; + + case Token.GET_REF: + generateExpression(child, node); // reference + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "refGet", + "(Lorg/mozilla/javascript/Ref;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + break; + + case Token.GETVAR: + visitGetVar(node); + break; + + case Token.SETVAR: + visitSetVar(node, child, true); + break; + + case Token.SETNAME: + visitSetName(node, child); + break; + + case Token.SETCONST: + visitSetConst(node, child); + break; + + case Token.SETCONSTVAR: + visitSetConstVar(node, child, true); + break; + + case Token.SETPROP: + case Token.SETPROP_OP: + visitSetProp(type, node, child); + break; + + case Token.SETELEM: + case Token.SETELEM_OP: + visitSetElem(type, node, child); + break; + + case Token.SET_REF: + case Token.SET_REF_OP: + { + generateExpression(child, node); + child = child.getNext(); + if (type == Token.SET_REF_OP) { + cfw.add(ByteCode.DUP); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "refGet", + "(Lorg/mozilla/javascript/Ref;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "refSet", + "(Lorg/mozilla/javascript/Ref;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + break; + + case Token.DEL_REF: + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("refDel", + "(Lorg/mozilla/javascript/Ref;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + break; + + case Token.DELPROP: + generateExpression(child, node); + child = child.getNext(); + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("delete", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + break; + + case Token.BINDNAME: + { + while (child != null) { + generateExpression(child, node); + child = child.getNext(); + } + // Generate code for "ScriptRuntime.bind(varObj, "s")" + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + cfw.addPush(node.getString()); + addScriptRuntimeInvoke( + "bind", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +")Lorg/mozilla/javascript/Scriptable;"); + } + break; + + case Token.LOCAL_LOAD: + cfw.addALoad(getLocalBlockRegister(node)); + break; + + case Token.REF_SPECIAL: + { + String special = (String)node.getProp(Node.NAME_PROP); + generateExpression(child, node); + cfw.addPush(special); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "specialRef", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/Ref;"); + } + break; + + case Token.REF_MEMBER: + case Token.REF_NS_MEMBER: + case Token.REF_NAME: + case Token.REF_NS_NAME: + { + int memberTypeFlags + = node.getIntProp(Node.MEMBER_TYPE_PROP, 0); + // generate possible target, possible namespace and member + do { + generateExpression(child, node); + child = child.getNext(); + } while (child != null); + cfw.addALoad(contextLocal); + String methodName, signature; + switch (type) { + case Token.REF_MEMBER: + methodName = "memberRef"; + signature = "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"I" + +")Lorg/mozilla/javascript/Ref;"; + break; + case Token.REF_NS_MEMBER: + methodName = "memberRef"; + signature = "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"I" + +")Lorg/mozilla/javascript/Ref;"; + break; + case Token.REF_NAME: + methodName = "nameRef"; + signature = "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"I" + +")Lorg/mozilla/javascript/Ref;"; + cfw.addALoad(variableObjectLocal); + break; + case Token.REF_NS_NAME: + methodName = "nameRef"; + signature = "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"I" + +")Lorg/mozilla/javascript/Ref;"; + cfw.addALoad(variableObjectLocal); + break; + default: + throw Kit.codeBug(); + } + cfw.addPush(memberTypeFlags); + addScriptRuntimeInvoke(methodName, signature); + } + break; + + case Token.DOTQUERY: + visitDotQuery(node, child); + break; + + case Token.ESCXMLATTR: + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("escapeAttributeValue", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/String;"); + break; + + case Token.ESCXMLTEXT: + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("escapeTextValue", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/String;"); + break; + + case Token.DEFAULTNAMESPACE: + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke("setDefaultNamespace", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + break; + + case Token.YIELD: + generateYieldPoint(node, true); + break; + + case Token.WITHEXPR: { + Node enterWith = child; + Node with = enterWith.getNext(); + Node leaveWith = with.getNext(); + generateStatement(enterWith); + generateExpression(with.getFirstChild(), with); + generateStatement(leaveWith); + break; + } + + case Token.ARRAYCOMP: { + Node initStmt = child; + Node expr = child.getNext(); + generateStatement(initStmt); + generateExpression(expr, node); + break; + } + + default: + throw new RuntimeException("Unexpected node type "+type); + } + + } + + private void generateYieldPoint(Node node, boolean exprContext) { + // save stack state + int top = cfw.getStackTop(); + maxStack = maxStack > top ? maxStack : top; + if (cfw.getStackTop() != 0) { + generateGetGeneratorStackState(); + for (int i = 0; i < top; i++) { + cfw.add(ByteCode.DUP_X1); + cfw.add(ByteCode.SWAP); + cfw.addLoadConstant(i); + cfw.add(ByteCode.SWAP); + cfw.add(ByteCode.AASTORE); + } + // pop the array object + cfw.add(ByteCode.POP); + } + + // generate the yield argument + Node child = node.getFirstChild(); + if (child != null) + generateExpression(child, node); + else + Codegen.pushUndefined(cfw); + + // change the resumption state + int nextState = getNextGeneratorState(node); + generateSetGeneratorResumptionPoint(nextState); + + boolean hasLocals = generateSaveLocals(node); + + cfw.add(ByteCode.ARETURN); + + generateCheckForThrowOrClose(getTargetLabel(node), + hasLocals, nextState); + + // reconstruct the stack + if (top != 0) { + generateGetGeneratorStackState(); + for (int i = 0; i < top; i++) { + cfw.add(ByteCode.DUP); + cfw.addLoadConstant(top - i - 1); + cfw.add(ByteCode.AALOAD); + cfw.add(ByteCode.SWAP); + } + cfw.add(ByteCode.POP); + } + + // load return value from yield + if (exprContext) { + cfw.addALoad(argsLocal); + } + } + + private void generateCheckForThrowOrClose(int label, + boolean hasLocals, + int nextState) { + int throwLabel = cfw.acquireLabel(); + int closeLabel = cfw.acquireLabel(); + + // throw the user provided object, if the operation is .throw() + cfw.markLabel(throwLabel); + cfw.addALoad(argsLocal); + generateThrowJavaScriptException(); + + // throw our special internal exception if the generator is being closed + cfw.markLabel(closeLabel); + cfw.addALoad(argsLocal); + cfw.add(ByteCode.CHECKCAST, "java/lang/Throwable"); + cfw.add(ByteCode.ATHROW); + + // mark the re-entry point + // jump here after initializing the locals + if (label != -1) + cfw.markLabel(label); + if (!hasLocals) { + // jump here directly if there are no locals + cfw.markTableSwitchCase(generatorSwitch, nextState); + } + + // see if we need to dispatch for .close() or .throw() + cfw.addILoad(operationLocal); + cfw.addLoadConstant(NativeGenerator.GENERATOR_CLOSE); + cfw.add(ByteCode.IF_ICMPEQ, closeLabel); + cfw.addILoad(operationLocal); + cfw.addLoadConstant(NativeGenerator.GENERATOR_THROW); + cfw.add(ByteCode.IF_ICMPEQ, throwLabel); + } + + private void generateIfJump(Node node, Node parent, + int trueLabel, int falseLabel) + { + // System.out.println("gen code for " + node.toString()); + + int type = node.getType(); + Node child = node.getFirstChild(); + + switch (type) { + case Token.NOT: + generateIfJump(child, node, falseLabel, trueLabel); + break; + + case Token.OR: + case Token.AND: { + int interLabel = cfw.acquireLabel(); + if (type == Token.AND) { + generateIfJump(child, node, interLabel, falseLabel); + } + else { + generateIfJump(child, node, trueLabel, interLabel); + } + cfw.markLabel(interLabel); + child = child.getNext(); + generateIfJump(child, node, trueLabel, falseLabel); + break; + } + + case Token.IN: + case Token.INSTANCEOF: + case Token.LE: + case Token.LT: + case Token.GE: + case Token.GT: + visitIfJumpRelOp(node, child, trueLabel, falseLabel); + break; + + case Token.EQ: + case Token.NE: + case Token.SHEQ: + case Token.SHNE: + visitIfJumpEqOp(node, child, trueLabel, falseLabel); + break; + + default: + // Generate generic code for non-optimized jump + generateExpression(node, parent); + addScriptRuntimeInvoke("toBoolean", "(Ljava/lang/Object;)Z"); + cfw.add(ByteCode.IFNE, trueLabel); + cfw.add(ByteCode.GOTO, falseLabel); + } + } + + private void visitFunction(OptFunctionNode ofn, int functionType) + { + int fnIndex = codegen.getIndex(ofn.fnode); + cfw.add(ByteCode.NEW, codegen.mainClassName); + // Call function constructor + cfw.add(ByteCode.DUP); + cfw.addALoad(variableObjectLocal); + cfw.addALoad(contextLocal); // load 'cx' + cfw.addPush(fnIndex); + cfw.addInvoke(ByteCode.INVOKESPECIAL, codegen.mainClassName, + "<init>", Codegen.FUNCTION_CONSTRUCTOR_SIGNATURE); + + // Init mainScript field; + cfw.add(ByteCode.DUP); + if (isTopLevel) { + cfw.add(ByteCode.ALOAD_0); + } else { + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, + codegen.mainClassName, + Codegen.DIRECT_CALL_PARENT_FIELD, + codegen.mainClassSignature); + } + cfw.add(ByteCode.PUTFIELD, + codegen.mainClassName, + Codegen.DIRECT_CALL_PARENT_FIELD, + codegen.mainClassSignature); + + int directTargetIndex = ofn.getDirectTargetIndex(); + if (directTargetIndex >= 0) { + cfw.add(ByteCode.DUP); + if (isTopLevel) { + cfw.add(ByteCode.ALOAD_0); + } else { + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, + codegen.mainClassName, + Codegen.DIRECT_CALL_PARENT_FIELD, + codegen.mainClassSignature); + } + cfw.add(ByteCode.SWAP); + cfw.add(ByteCode.PUTFIELD, + codegen.mainClassName, + Codegen.getDirectTargetFieldName(directTargetIndex), + codegen.mainClassSignature); + } + + if (functionType == FunctionNode.FUNCTION_EXPRESSION) { + // Leave closure object on stack and do not pass it to + // initFunction which suppose to connect statements to scope + return; + } + cfw.addPush(functionType); + cfw.addALoad(variableObjectLocal); + cfw.addALoad(contextLocal); // load 'cx' + addOptRuntimeInvoke("initFunction", + "(Lorg/mozilla/javascript/NativeFunction;" + +"I" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Context;" + +")V"); + } + + private int getTargetLabel(Node target) + { + int labelId = target.labelId(); + if (labelId == -1) { + labelId = cfw.acquireLabel(); + target.labelId(labelId); + } + return labelId; + } + + private void visitGoto(Node.Jump node, int type, Node child) + { + Node target = node.target; + if (type == Token.IFEQ || type == Token.IFNE) { + if (child == null) throw Codegen.badTree(); + int targetLabel = getTargetLabel(target); + int fallThruLabel = cfw.acquireLabel(); + if (type == Token.IFEQ) + generateIfJump(child, node, targetLabel, fallThruLabel); + else + generateIfJump(child, node, fallThruLabel, targetLabel); + cfw.markLabel(fallThruLabel); + } else { + if (type == Token.JSR) { + if (isGenerator) { + addGotoWithReturn(target); + } else { + addGoto(target, ByteCode.JSR); + } + } else { + addGoto(target, ByteCode.GOTO); + } + } + } + + private void addGotoWithReturn(Node target) { + FinallyReturnPoint ret = + (FinallyReturnPoint)finallys.get(target); + cfw.addLoadConstant(ret.jsrPoints.size()); + addGoto(target, ByteCode.GOTO); + int retLabel = cfw.acquireLabel(); + cfw.markLabel(retLabel); + ret.jsrPoints.add(Integer.valueOf(retLabel)); + } + + private void visitArrayLiteral(Node node, Node child) + { + int count = 0; + for (Node cursor = child; cursor != null; cursor = cursor.getNext()) { + ++count; + } + // load array to store array literal objects + addNewObjectArray(count); + for (int i = 0; i != count; ++i) { + cfw.add(ByteCode.DUP); + cfw.addPush(i); + generateExpression(child, node); + cfw.add(ByteCode.AASTORE); + child = child.getNext(); + } + int[] skipIndexes = (int[])node.getProp(Node.SKIP_INDEXES_PROP); + if (skipIndexes == null) { + cfw.add(ByteCode.ACONST_NULL); + cfw.add(ByteCode.ICONST_0); + } else { + cfw.addPush(OptRuntime.encodeIntArray(skipIndexes)); + cfw.addPush(skipIndexes.length); + } + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + addOptRuntimeInvoke("newArrayLiteral", + "([Ljava/lang/Object;" + +"Ljava/lang/String;" + +"I" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + } + + private void visitObjectLiteral(Node node, Node child) + { + Object[] properties = (Object[])node.getProp(Node.OBJECT_IDS_PROP); + int count = properties.length; + + // load array with property ids + addNewObjectArray(count); + for (int i = 0; i != count; ++i) { + cfw.add(ByteCode.DUP); + cfw.addPush(i); + Object id = properties[i]; + if (id instanceof String) { + cfw.addPush((String)id); + } else { + cfw.addPush(((Integer)id).intValue()); + addScriptRuntimeInvoke("wrapInt", "(I)Ljava/lang/Integer;"); + } + cfw.add(ByteCode.AASTORE); + } + // load array with property values + addNewObjectArray(count); + Node child2 = child; + for (int i = 0; i != count; ++i) { + cfw.add(ByteCode.DUP); + cfw.addPush(i); + int childType = child.getType(); + if (childType == Token.GET) { + generateExpression(child.getFirstChild(), node); + } else if (childType == Token.SET) { + generateExpression(child.getFirstChild(), node); + } else { + generateExpression(child, node); + } + cfw.add(ByteCode.AASTORE); + child = child.getNext(); + } + // load array with getterSetter values + cfw.addPush(count); + cfw.add(ByteCode.NEWARRAY, ByteCode.T_INT); + for (int i = 0; i != count; ++i) { + cfw.add(ByteCode.DUP); + cfw.addPush(i); + int childType = child2.getType(); + if (childType == Token.GET) { + cfw.add(ByteCode.ICONST_M1); + } else if (childType == Token.SET) { + cfw.add(ByteCode.ICONST_1); + } else { + cfw.add(ByteCode.ICONST_0); + } + cfw.add(ByteCode.IASTORE); + child2 = child2.getNext(); + } + + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke("newObjectLiteral", + "([Ljava/lang/Object;" + +"[Ljava/lang/Object;" + +"[I" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + } + + private void visitSpecialCall(Node node, int type, int specialType, + Node child) + { + cfw.addALoad(contextLocal); + + if (type == Token.NEW) { + generateExpression(child, node); + // stack: ... cx functionObj + } else { + generateFunctionAndThisObj(child, node); + // stack: ... cx functionObj thisObj + } + child = child.getNext(); + + generateCallArgArray(node, child, false); + + String methodName; + String callSignature; + + if (type == Token.NEW) { + methodName = "newObjectSpecial"; + callSignature = "(Lorg/mozilla/javascript/Context;" + +"Ljava/lang/Object;" + +"[Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"I" // call type + +")Ljava/lang/Object;"; + cfw.addALoad(variableObjectLocal); + cfw.addALoad(thisObjLocal); + cfw.addPush(specialType); + } else { + methodName = "callSpecial"; + callSignature = "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"I" // call type + +"Ljava/lang/String;I" // filename, linenumber + +")Ljava/lang/Object;"; + cfw.addALoad(variableObjectLocal); + cfw.addALoad(thisObjLocal); + cfw.addPush(specialType); + String sourceName = scriptOrFn.getSourceName(); + cfw.addPush(sourceName == null ? "" : sourceName); + cfw.addPush(itsLineNumber); + } + + addOptRuntimeInvoke(methodName, callSignature); + } + + private void visitStandardCall(Node node, Node child) + { + if (node.getType() != Token.CALL) throw Codegen.badTree(); + + Node firstArgChild = child.getNext(); + int childType = child.getType(); + + String methodName; + String signature; + + if (firstArgChild == null) { + if (childType == Token.NAME) { + // name() call + String name = child.getString(); + cfw.addPush(name); + methodName = "callName0"; + signature = "(Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } else if (childType == Token.GETPROP) { + // x.name() call + Node propTarget = child.getFirstChild(); + generateExpression(propTarget, node); + Node id = propTarget.getNext(); + String property = id.getString(); + cfw.addPush(property); + methodName = "callProp0"; + signature = "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } else if (childType == Token.GETPROPNOWARN) { + throw Kit.codeBug(); + } else { + generateFunctionAndThisObj(child, node); + methodName = "call0"; + signature = "(Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } + + } else if (childType == Token.NAME) { + // XXX: this optimization is only possible if name + // resolution + // is not affected by arguments evaluation and currently + // there are no checks for it + String name = child.getString(); + generateCallArgArray(node, firstArgChild, false); + cfw.addPush(name); + methodName = "callName"; + signature = "([Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } else { + int argCount = 0; + for (Node arg = firstArgChild; arg != null; arg = arg.getNext()) { + ++argCount; + } + generateFunctionAndThisObj(child, node); + // stack: ... functionObj thisObj + if (argCount == 1) { + generateExpression(firstArgChild, node); + methodName = "call1"; + signature = "(Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } else if (argCount == 2) { + generateExpression(firstArgChild, node); + generateExpression(firstArgChild.getNext(), node); + methodName = "call2"; + signature = "(Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } else { + generateCallArgArray(node, firstArgChild, false); + methodName = "callN"; + signature = "(Lorg/mozilla/javascript/Callable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"; + } + } + + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + addOptRuntimeInvoke(methodName, signature); + } + + private void visitStandardNew(Node node, Node child) + { + if (node.getType() != Token.NEW) throw Codegen.badTree(); + + Node firstArgChild = child.getNext(); + + generateExpression(child, node); + // stack: ... functionObj + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + // stack: ... functionObj cx scope + generateCallArgArray(node, firstArgChild, false); + addScriptRuntimeInvoke( + "newObject", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + } + + private void visitOptimizedCall(Node node, OptFunctionNode target, + int type, Node child) + { + Node firstArgChild = child.getNext(); + + short thisObjLocal = 0; + if (type == Token.NEW) { + generateExpression(child, node); + } else { + generateFunctionAndThisObj(child, node); + thisObjLocal = getNewWordLocal(); + cfw.addAStore(thisObjLocal); + } + // stack: ... functionObj + + int beyond = cfw.acquireLabel(); + + int directTargetIndex = target.getDirectTargetIndex(); + if (isTopLevel) { + cfw.add(ByteCode.ALOAD_0); + } else { + cfw.add(ByteCode.ALOAD_0); + cfw.add(ByteCode.GETFIELD, codegen.mainClassName, + Codegen.DIRECT_CALL_PARENT_FIELD, + codegen.mainClassSignature); + } + cfw.add(ByteCode.GETFIELD, codegen.mainClassName, + Codegen.getDirectTargetFieldName(directTargetIndex), + codegen.mainClassSignature); + + cfw.add(ByteCode.DUP2); + // stack: ... functionObj directFunct functionObj directFunct + + int regularCall = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPNE, regularCall); + + // stack: ... functionObj directFunct + short stackHeight = cfw.getStackTop(); + cfw.add(ByteCode.SWAP); + cfw.add(ByteCode.POP); + // stack: ... directFunct + if (compilerEnv.isUseDynamicScope()) { + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + } else { + cfw.add(ByteCode.DUP); + // stack: ... directFunct directFunct + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/Scriptable", + "getParentScope", + "()Lorg/mozilla/javascript/Scriptable;"); + // stack: ... directFunct scope + cfw.addALoad(contextLocal); + // stack: ... directFunct scope cx + cfw.add(ByteCode.SWAP); + } + // stack: ... directFunc cx scope + + if (type == Token.NEW) { + cfw.add(ByteCode.ACONST_NULL); + } else { + cfw.addALoad(thisObjLocal); + } + // stack: ... directFunc cx scope thisObj +/* +Remember that directCall parameters are paired in 1 aReg and 1 dReg +If the argument is an incoming arg, just pass the orginal pair thru. +Else, if the argument is known to be typed 'Number', pass Void.TYPE +in the aReg and the number is the dReg +Else pass the JS object in the aReg and 0.0 in the dReg. +*/ + Node argChild = firstArgChild; + while (argChild != null) { + int dcp_register = nodeIsDirectCallParameter(argChild); + if (dcp_register >= 0) { + cfw.addALoad(dcp_register); + cfw.addDLoad(dcp_register + 1); + } else if (argChild.getIntProp(Node.ISNUMBER_PROP, -1) + == Node.BOTH) + { + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + generateExpression(argChild, node); + } else { + generateExpression(argChild, node); + cfw.addPush(0.0); + } + argChild = argChild.getNext(); + } + + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/ScriptRuntime", + "emptyArgs", "[Ljava/lang/Object;"); + cfw.addInvoke(ByteCode.INVOKESTATIC, + codegen.mainClassName, + (type == Token.NEW) + ? codegen.getDirectCtorName(target.fnode) + : codegen.getBodyMethodName(target.fnode), + codegen.getBodyMethodSignature(target.fnode)); + + cfw.add(ByteCode.GOTO, beyond); + + cfw.markLabel(regularCall, stackHeight); + // stack: ... functionObj directFunct + cfw.add(ByteCode.POP); + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + // stack: ... functionObj cx scope + if (type != Token.NEW) { + cfw.addALoad(thisObjLocal); + releaseWordLocal(thisObjLocal); + // stack: ... functionObj cx scope thisObj + } + // XXX: this will generate code for the child array the second time, + // so expression code generation better not to alter tree structure... + generateCallArgArray(node, firstArgChild, true); + + if (type == Token.NEW) { + addScriptRuntimeInvoke( + "newObject", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Lorg/mozilla/javascript/Scriptable;"); + } else { + cfw.addInvoke(ByteCode.INVOKEINTERFACE, + "org/mozilla/javascript/Callable", + "call", + "(Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Lorg/mozilla/javascript/Scriptable;" + +"[Ljava/lang/Object;" + +")Ljava/lang/Object;"); + } + + cfw.markLabel(beyond); + } + + private void generateCallArgArray(Node node, Node argChild, boolean directCall) + { + int argCount = 0; + for (Node child = argChild; child != null; child = child.getNext()) { + ++argCount; + } + // load array object to set arguments + if (argCount == 1 && itsOneArgArray >= 0) { + cfw.addALoad(itsOneArgArray); + } else { + addNewObjectArray(argCount); + } + // Copy arguments into it + for (int i = 0; i != argCount; ++i) { + // If we are compiling a generator an argument could be the result + // of a yield. In that case we will have an immediate on the stack + // which we need to avoid + if (!isGenerator) { + cfw.add(ByteCode.DUP); + cfw.addPush(i); + } + + if (!directCall) { + generateExpression(argChild, node); + } else { + // If this has also been a directCall sequence, the Number + // flag will have remained set for any parameter so that + // the values could be copied directly into the outgoing + // args. Here we want to force it to be treated as not in + // a Number context, so we set the flag off. + int dcp_register = nodeIsDirectCallParameter(argChild); + if (dcp_register >= 0) { + dcpLoadAsObject(dcp_register); + } else { + generateExpression(argChild, node); + int childNumberFlag + = argChild.getIntProp(Node.ISNUMBER_PROP, -1); + if (childNumberFlag == Node.BOTH) { + addDoubleWrap(); + } + } + } + + // When compiling generators, any argument to a method may be a + // yield expression. Hence we compile the argument first and then + // load the argument index and assign the value to the args array. + if (isGenerator) { + short tempLocal = getNewWordLocal(); + cfw.addAStore(tempLocal); + cfw.add(ByteCode.CHECKCAST, "[Ljava/lang/Object;"); + cfw.add(ByteCode.DUP); + cfw.addPush(i); + cfw.addALoad(tempLocal); + releaseWordLocal(tempLocal); + } + + cfw.add(ByteCode.AASTORE); + + argChild = argChild.getNext(); + } + } + + private void generateFunctionAndThisObj(Node node, Node parent) + { + // Place on stack (function object, function this) pair + int type = node.getType(); + switch (node.getType()) { + case Token.GETPROPNOWARN: + throw Kit.codeBug(); + + case Token.GETPROP: + case Token.GETELEM: { + Node target = node.getFirstChild(); + generateExpression(target, node); + Node id = target.getNext(); + if (type == Token.GETPROP) { + String property = id.getString(); + cfw.addPush(property); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getPropFunctionAndThis", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/Callable;"); + } else { + // Optimizer do not optimize this case for now + if (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1) + throw Codegen.badTree(); + generateExpression(id, node); // id + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getElemFunctionAndThis", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/Callable;"); + } + break; + } + + case Token.NAME: { + String name = node.getString(); + cfw.addPush(name); + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke( + "getNameFunctionAndThis", + "(Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Callable;"); + break; + } + + default: // including GETVAR + generateExpression(node, parent); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getValueFunctionAndThis", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/Callable;"); + break; + } + // Get thisObj prepared by get(Name|Prop|Elem|Value)FunctionAndThis + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "lastStoredScriptable", + "(Lorg/mozilla/javascript/Context;" + +")Lorg/mozilla/javascript/Scriptable;"); + } + + private void updateLineNumber(Node node) + { + itsLineNumber = node.getLineno(); + if (itsLineNumber == -1) + return; + cfw.addLineNumberEntry((short)itsLineNumber); + } + + private void visitTryCatchFinally(Node.Jump node, Node child) + { + /* Save the variable object, in case there are with statements + * enclosed by the try block and we catch some exception. + * We'll restore it for the catch block so that catch block + * statements get the right scope. + */ + + // OPT we only need to do this if there are enclosed WITH + // statements; could statically check and omit this if there aren't any. + + // XXX OPT Maybe instead do syntactic transforms to associate + // each 'with' with a try/finally block that does the exitwith. + + short savedVariableObject = getNewWordLocal(); + cfw.addALoad(variableObjectLocal); + cfw.addAStore(savedVariableObject); + + /* + * Generate the code for the tree; most of the work is done in IRFactory + * and NodeTransformer; Codegen just adds the java handlers for the + * javascript catch and finally clauses. */ + + int startLabel = cfw.acquireLabel(); + cfw.markLabel(startLabel, (short)0); + + Node catchTarget = node.target; + Node finallyTarget = node.getFinally(); + + // create a table for the equivalent of JSR returns + if (isGenerator && finallyTarget != null) { + FinallyReturnPoint ret = new FinallyReturnPoint(); + if (finallys == null) { + finallys = new Hashtable(); + } + // add the finally target to hashtable + finallys.put(finallyTarget, ret); + // add the finally node as well to the hash table + finallys.put(finallyTarget.getNext(), ret); + } + + while (child != null) { + generateStatement(child); + child = child.getNext(); + } + + // control flow skips the handlers + int realEnd = cfw.acquireLabel(); + cfw.add(ByteCode.GOTO, realEnd); + + int exceptionLocal = getLocalBlockRegister(node); + // javascript handler; unwrap exception and GOTO to javascript + // catch area. + if (catchTarget != null) { + // get the label to goto + int catchLabel = catchTarget.labelId(); + + generateCatchBlock(JAVASCRIPT_EXCEPTION, savedVariableObject, + catchLabel, startLabel, exceptionLocal); + /* + * catch WrappedExceptions, see if they are wrapped + * JavaScriptExceptions. Otherwise, rethrow. + */ + generateCatchBlock(EVALUATOR_EXCEPTION, savedVariableObject, + catchLabel, startLabel, exceptionLocal); + + /* + we also need to catch EcmaErrors and feed the + associated error object to the handler + */ + generateCatchBlock(ECMAERROR_EXCEPTION, savedVariableObject, + catchLabel, startLabel, exceptionLocal); + + Context cx = Context.getCurrentContext(); + if (cx != null && + cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS)) + { + generateCatchBlock(THROWABLE_EXCEPTION, savedVariableObject, + catchLabel, startLabel, exceptionLocal); + } + } + + // finally handler; catch all exceptions, store to a local; JSR to + // the finally, then re-throw. + if (finallyTarget != null) { + int finallyHandler = cfw.acquireLabel(); + cfw.markHandler(finallyHandler); + cfw.addAStore(exceptionLocal); + + // reset the variable object local + cfw.addALoad(savedVariableObject); + cfw.addAStore(variableObjectLocal); + + // get the label to JSR to + int finallyLabel = finallyTarget.labelId(); + if (isGenerator) + addGotoWithReturn(finallyTarget); + else + cfw.add(ByteCode.JSR, finallyLabel); + + // rethrow + cfw.addALoad(exceptionLocal); + if (isGenerator) + cfw.add(ByteCode.CHECKCAST, "java/lang/Throwable"); + cfw.add(ByteCode.ATHROW); + + // mark the handler + cfw.addExceptionHandler(startLabel, finallyLabel, + finallyHandler, null); // catch any + } + releaseWordLocal(savedVariableObject); + cfw.markLabel(realEnd); + } + + private static final int JAVASCRIPT_EXCEPTION = 0; + private static final int EVALUATOR_EXCEPTION = 1; + private static final int ECMAERROR_EXCEPTION = 2; + private static final int THROWABLE_EXCEPTION = 3; + + private void generateCatchBlock(int exceptionType, + short savedVariableObject, + int catchLabel, int startLabel, + int exceptionLocal) + { + int handler = cfw.acquireLabel(); + cfw.markHandler(handler); + + // MS JVM gets cranky if the exception object is left on the stack + cfw.addAStore(exceptionLocal); + + // reset the variable object local + cfw.addALoad(savedVariableObject); + cfw.addAStore(variableObjectLocal); + + String exceptionName; + if (exceptionType == JAVASCRIPT_EXCEPTION) { + exceptionName = "org/mozilla/javascript/JavaScriptException"; + } else if (exceptionType == EVALUATOR_EXCEPTION) { + exceptionName = "org/mozilla/javascript/EvaluatorException"; + } else if (exceptionType == ECMAERROR_EXCEPTION) { + exceptionName = "org/mozilla/javascript/EcmaError"; + } else if (exceptionType == THROWABLE_EXCEPTION) { + exceptionName = "java/lang/Throwable"; + } else { + throw Kit.codeBug(); + } + + // mark the handler + cfw.addExceptionHandler(startLabel, catchLabel, handler, + exceptionName); + + cfw.add(ByteCode.GOTO, catchLabel); + } + + + private boolean generateSaveLocals(Node node) + { + int count = 0; + for (int i = 0; i < firstFreeLocal; i++) { + if (locals[i] != 0) + count++; + } + + if (count == 0) { + ((FunctionNode)scriptOrFn).addLiveLocals(node, null); + return false; + } + + // calculate the max locals + maxLocals = maxLocals > count ? maxLocals : count; + + // create a locals list + int[] ls = new int[count]; + int s = 0; + for (int i = 0; i < firstFreeLocal; i++) { + if (locals[i] != 0) { + ls[s] = i; + s++; + } + } + + // save the locals + ((FunctionNode)scriptOrFn).addLiveLocals(node, ls); + + // save locals + generateGetGeneratorLocalsState(); + for (int i = 0; i < count; i++) { + cfw.add(ByteCode.DUP); + cfw.addLoadConstant(i); + cfw.addALoad(ls[i]); + cfw.add(ByteCode.AASTORE); + } + // pop the array off the stack + cfw.add(ByteCode.POP); + + return true; + } + + private void visitSwitch(Node.Jump switchNode, Node child) + { + // See comments in IRFactory.createSwitch() for description + // of SWITCH node + + generateExpression(child, switchNode); + // save selector value + short selector = getNewWordLocal(); + cfw.addAStore(selector); + + for (Node.Jump caseNode = (Node.Jump)child.getNext(); + caseNode != null; + caseNode = (Node.Jump)caseNode.getNext()) + { + if (caseNode.getType() != Token.CASE) + throw Codegen.badTree(); + Node test = caseNode.getFirstChild(); + generateExpression(test, caseNode); + cfw.addALoad(selector); + addScriptRuntimeInvoke("shallowEq", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +")Z"); + addGoto(caseNode.target, ByteCode.IFNE); + } + releaseWordLocal(selector); + } + + private void visitTypeofname(Node node) + { + if (hasVarsInRegs) { + int varIndex = fnCurrent.fnode.getIndexForNameNode(node); + if (varIndex >= 0) { + if (fnCurrent.isNumberVar(varIndex)) { + cfw.addPush("number"); + } else if (varIsDirectCallParameter(varIndex)) { + int dcp_register = varRegisters[varIndex]; + cfw.addALoad(dcp_register); + cfw.add(ByteCode.GETSTATIC, "java/lang/Void", "TYPE", + "Ljava/lang/Class;"); + int isNumberLabel = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPEQ, isNumberLabel); + short stack = cfw.getStackTop(); + cfw.addALoad(dcp_register); + addScriptRuntimeInvoke("typeof", + "(Ljava/lang/Object;" + +")Ljava/lang/String;"); + int beyond = cfw.acquireLabel(); + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(isNumberLabel, stack); + cfw.addPush("number"); + cfw.markLabel(beyond); + } else { + cfw.addALoad(varRegisters[varIndex]); + addScriptRuntimeInvoke("typeof", + "(Ljava/lang/Object;" + +")Ljava/lang/String;"); + } + return; + } + } + cfw.addALoad(variableObjectLocal); + cfw.addPush(node.getString()); + addScriptRuntimeInvoke("typeofName", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +")Ljava/lang/String;"); + } + + /** + * Save the current code offset. This saved code offset is used to + * compute instruction counts in subsequent calls to + * {@link #addInstructionCount}. + */ + private void saveCurrentCodeOffset() { + savedCodeOffset = cfw.getCurrentCodeOffset(); + } + + /** + * Generate calls to ScriptRuntime.addInstructionCount to keep track of + * executed instructions and call <code>observeInstructionCount()</code> + * if a threshold is exceeded. + */ + private void addInstructionCount() { + int count = cfw.getCurrentCodeOffset() - savedCodeOffset; + if (count == 0) + return; + cfw.addALoad(contextLocal); + cfw.addPush(count); + addScriptRuntimeInvoke("addInstructionCount", + "(Lorg/mozilla/javascript/Context;" + +"I)V"); + } + + private void visitIncDec(Node node) + { + int incrDecrMask = node.getExistingIntProp(Node.INCRDECR_PROP); + Node child = node.getFirstChild(); + switch (child.getType()) { + case Token.GETVAR: + if (!hasVarsInRegs) Kit.codeBug(); + if (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1) { + boolean post = ((incrDecrMask & Node.POST_FLAG) != 0); + int varIndex = fnCurrent.getVarIndex(child); + short reg = varRegisters[varIndex]; + int offset = varIsDirectCallParameter(varIndex) ? 1 : 0; + cfw.addDLoad(reg + offset); + if (post) { + cfw.add(ByteCode.DUP2); + } + cfw.addPush(1.0); + if ((incrDecrMask & Node.DECR_FLAG) == 0) { + cfw.add(ByteCode.DADD); + } else { + cfw.add(ByteCode.DSUB); + } + if (!post) { + cfw.add(ByteCode.DUP2); + } + cfw.addDStore(reg + offset); + } else { + boolean post = ((incrDecrMask & Node.POST_FLAG) != 0); + int varIndex = fnCurrent.getVarIndex(child); + short reg = varRegisters[varIndex]; + cfw.addALoad(reg); + if (post) { + cfw.add(ByteCode.DUP); + } + addObjectToDouble(); + cfw.addPush(1.0); + if ((incrDecrMask & Node.DECR_FLAG) == 0) { + cfw.add(ByteCode.DADD); + } else { + cfw.add(ByteCode.DSUB); + } + addDoubleWrap(); + if (!post) { + cfw.add(ByteCode.DUP); + } + cfw.addAStore(reg); + break; + } + break; + case Token.NAME: + cfw.addALoad(variableObjectLocal); + cfw.addPush(child.getString()); // push name + cfw.addALoad(contextLocal); + cfw.addPush(incrDecrMask); + addScriptRuntimeInvoke("nameIncrDecr", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"I)Ljava/lang/Object;"); + break; + case Token.GETPROPNOWARN: + throw Kit.codeBug(); + case Token.GETPROP: { + Node getPropChild = child.getFirstChild(); + generateExpression(getPropChild, node); + generateExpression(getPropChild.getNext(), node); + cfw.addALoad(contextLocal); + cfw.addPush(incrDecrMask); + addScriptRuntimeInvoke("propIncrDecr", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +"I)Ljava/lang/Object;"); + break; + } + case Token.GETELEM: { + Node elemChild = child.getFirstChild(); + generateExpression(elemChild, node); + generateExpression(elemChild.getNext(), node); + cfw.addALoad(contextLocal); + cfw.addPush(incrDecrMask); + if (elemChild.getNext().getIntProp(Node.ISNUMBER_PROP, -1) != -1) { + addOptRuntimeInvoke("elemIncrDecr", + "(Ljava/lang/Object;" + +"D" + +"Lorg/mozilla/javascript/Context;" + +"I" + +")Ljava/lang/Object;"); + } else { + addScriptRuntimeInvoke("elemIncrDecr", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"I" + +")Ljava/lang/Object;"); + } + break; + } + case Token.GET_REF: { + Node refChild = child.getFirstChild(); + generateExpression(refChild, node); + cfw.addALoad(contextLocal); + cfw.addPush(incrDecrMask); + addScriptRuntimeInvoke( + "refIncrDecr", + "(Lorg/mozilla/javascript/Ref;" + +"Lorg/mozilla/javascript/Context;" + +"I)Ljava/lang/Object;"); + break; + } + default: + Codegen.badTree(); + } + } + + private static boolean isArithmeticNode(Node node) + { + int type = node.getType(); + return (type == Token.SUB) + || (type == Token.MOD) + || (type == Token.DIV) + || (type == Token.MUL); + } + + private void visitArithmetic(Node node, int opCode, Node child, + Node parent) + { + int childNumberFlag = node.getIntProp(Node.ISNUMBER_PROP, -1); + if (childNumberFlag != -1) { + generateExpression(child, node); + generateExpression(child.getNext(), node); + cfw.add(opCode); + } + else { + boolean childOfArithmetic = isArithmeticNode(parent); + generateExpression(child, node); + if (!isArithmeticNode(child)) + addObjectToDouble(); + generateExpression(child.getNext(), node); + if (!isArithmeticNode(child.getNext())) + addObjectToDouble(); + cfw.add(opCode); + if (!childOfArithmetic) { + addDoubleWrap(); + } + } + } + + private void visitBitOp(Node node, int type, Node child) + { + int childNumberFlag = node.getIntProp(Node.ISNUMBER_PROP, -1); + generateExpression(child, node); + + // special-case URSH; work with the target arg as a long, so + // that we can return a 32-bit unsigned value, and call + // toUint32 instead of toInt32. + if (type == Token.URSH) { + addScriptRuntimeInvoke("toUint32", "(Ljava/lang/Object;)J"); + generateExpression(child.getNext(), node); + addScriptRuntimeInvoke("toInt32", "(Ljava/lang/Object;)I"); + // Looks like we need to explicitly mask the shift to 5 bits - + // LUSHR takes 6 bits. + cfw.addPush(31); + cfw.add(ByteCode.IAND); + cfw.add(ByteCode.LUSHR); + cfw.add(ByteCode.L2D); + addDoubleWrap(); + return; + } + if (childNumberFlag == -1) { + addScriptRuntimeInvoke("toInt32", "(Ljava/lang/Object;)I"); + generateExpression(child.getNext(), node); + addScriptRuntimeInvoke("toInt32", "(Ljava/lang/Object;)I"); + } + else { + addScriptRuntimeInvoke("toInt32", "(D)I"); + generateExpression(child.getNext(), node); + addScriptRuntimeInvoke("toInt32", "(D)I"); + } + switch (type) { + case Token.BITOR: + cfw.add(ByteCode.IOR); + break; + case Token.BITXOR: + cfw.add(ByteCode.IXOR); + break; + case Token.BITAND: + cfw.add(ByteCode.IAND); + break; + case Token.RSH: + cfw.add(ByteCode.ISHR); + break; + case Token.LSH: + cfw.add(ByteCode.ISHL); + break; + default: + throw Codegen.badTree(); + } + cfw.add(ByteCode.I2D); + if (childNumberFlag == -1) { + addDoubleWrap(); + } + } + + private int nodeIsDirectCallParameter(Node node) + { + if (node.getType() == Token.GETVAR + && inDirectCallFunction && !itsForcedObjectParameters) + { + int varIndex = fnCurrent.getVarIndex(node); + if (fnCurrent.isParameter(varIndex)) { + return varRegisters[varIndex]; + } + } + return -1; + } + + private boolean varIsDirectCallParameter(int varIndex) + { + return fnCurrent.isParameter(varIndex) + && inDirectCallFunction && !itsForcedObjectParameters; + } + + private void genSimpleCompare(int type, int trueGOTO, int falseGOTO) + { + if (trueGOTO == -1) throw Codegen.badTree(); + switch (type) { + case Token.LE : + cfw.add(ByteCode.DCMPG); + cfw.add(ByteCode.IFLE, trueGOTO); + break; + case Token.GE : + cfw.add(ByteCode.DCMPL); + cfw.add(ByteCode.IFGE, trueGOTO); + break; + case Token.LT : + cfw.add(ByteCode.DCMPG); + cfw.add(ByteCode.IFLT, trueGOTO); + break; + case Token.GT : + cfw.add(ByteCode.DCMPL); + cfw.add(ByteCode.IFGT, trueGOTO); + break; + default : + throw Codegen.badTree(); + + } + if (falseGOTO != -1) + cfw.add(ByteCode.GOTO, falseGOTO); + } + + private void visitIfJumpRelOp(Node node, Node child, + int trueGOTO, int falseGOTO) + { + if (trueGOTO == -1 || falseGOTO == -1) throw Codegen.badTree(); + int type = node.getType(); + Node rChild = child.getNext(); + if (type == Token.INSTANCEOF || type == Token.IN) { + generateExpression(child, node); + generateExpression(rChild, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + (type == Token.INSTANCEOF) ? "instanceOf" : "in", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Z"); + cfw.add(ByteCode.IFNE, trueGOTO); + cfw.add(ByteCode.GOTO, falseGOTO); + return; + } + int childNumberFlag = node.getIntProp(Node.ISNUMBER_PROP, -1); + int left_dcp_register = nodeIsDirectCallParameter(child); + int right_dcp_register = nodeIsDirectCallParameter(rChild); + if (childNumberFlag != -1) { + // Force numeric context on both parameters and optimize + // direct call case as Optimizer currently does not handle it + + if (childNumberFlag != Node.RIGHT) { + // Left already has number content + generateExpression(child, node); + } else if (left_dcp_register != -1) { + dcpLoadAsNumber(left_dcp_register); + } else { + generateExpression(child, node); + addObjectToDouble(); + } + + if (childNumberFlag != Node.LEFT) { + // Right already has number content + generateExpression(rChild, node); + } else if (right_dcp_register != -1) { + dcpLoadAsNumber(right_dcp_register); + } else { + generateExpression(rChild, node); + addObjectToDouble(); + } + + genSimpleCompare(type, trueGOTO, falseGOTO); + + } else { + if (left_dcp_register != -1 && right_dcp_register != -1) { + // Generate code to dynamically check for number content + // if both operands are dcp + short stack = cfw.getStackTop(); + int leftIsNotNumber = cfw.acquireLabel(); + cfw.addALoad(left_dcp_register); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + cfw.add(ByteCode.IF_ACMPNE, leftIsNotNumber); + cfw.addDLoad(left_dcp_register + 1); + dcpLoadAsNumber(right_dcp_register); + genSimpleCompare(type, trueGOTO, falseGOTO); + if (stack != cfw.getStackTop()) throw Codegen.badTree(); + + cfw.markLabel(leftIsNotNumber); + int rightIsNotNumber = cfw.acquireLabel(); + cfw.addALoad(right_dcp_register); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + cfw.add(ByteCode.IF_ACMPNE, rightIsNotNumber); + cfw.addALoad(left_dcp_register); + addObjectToDouble(); + cfw.addDLoad(right_dcp_register + 1); + genSimpleCompare(type, trueGOTO, falseGOTO); + if (stack != cfw.getStackTop()) throw Codegen.badTree(); + + cfw.markLabel(rightIsNotNumber); + // Load both register as objects to call generic cmp_* + cfw.addALoad(left_dcp_register); + cfw.addALoad(right_dcp_register); + + } else { + generateExpression(child, node); + generateExpression(rChild, node); + } + + if (type == Token.GE || type == Token.GT) { + cfw.add(ByteCode.SWAP); + } + String routine = ((type == Token.LT) + || (type == Token.GT)) ? "cmp_LT" : "cmp_LE"; + addScriptRuntimeInvoke(routine, + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +")Z"); + cfw.add(ByteCode.IFNE, trueGOTO); + cfw.add(ByteCode.GOTO, falseGOTO); + } + } + + private void visitIfJumpEqOp(Node node, Node child, + int trueGOTO, int falseGOTO) + { + if (trueGOTO == -1 || falseGOTO == -1) throw Codegen.badTree(); + + short stackInitial = cfw.getStackTop(); + int type = node.getType(); + Node rChild = child.getNext(); + + // Optimize if one of operands is null + if (child.getType() == Token.NULL || rChild.getType() == Token.NULL) { + // eq is symmetric in this case + if (child.getType() == Token.NULL) { + child = rChild; + } + generateExpression(child, node); + if (type == Token.SHEQ || type == Token.SHNE) { + int testCode = (type == Token.SHEQ) + ? ByteCode.IFNULL : ByteCode.IFNONNULL; + cfw.add(testCode, trueGOTO); + } else { + if (type != Token.EQ) { + // swap false/true targets for != + if (type != Token.NE) throw Codegen.badTree(); + int tmp = trueGOTO; + trueGOTO = falseGOTO; + falseGOTO = tmp; + } + cfw.add(ByteCode.DUP); + int undefCheckLabel = cfw.acquireLabel(); + cfw.add(ByteCode.IFNONNULL, undefCheckLabel); + short stack = cfw.getStackTop(); + cfw.add(ByteCode.POP); + cfw.add(ByteCode.GOTO, trueGOTO); + cfw.markLabel(undefCheckLabel, stack); + Codegen.pushUndefined(cfw); + cfw.add(ByteCode.IF_ACMPEQ, trueGOTO); + } + cfw.add(ByteCode.GOTO, falseGOTO); + } else { + int child_dcp_register = nodeIsDirectCallParameter(child); + if (child_dcp_register != -1 + && rChild.getType() == Token.TO_OBJECT) + { + Node convertChild = rChild.getFirstChild(); + if (convertChild.getType() == Token.NUMBER) { + cfw.addALoad(child_dcp_register); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + int notNumbersLabel = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPNE, notNumbersLabel); + cfw.addDLoad(child_dcp_register + 1); + cfw.addPush(convertChild.getDouble()); + cfw.add(ByteCode.DCMPL); + if (type == Token.EQ) + cfw.add(ByteCode.IFEQ, trueGOTO); + else + cfw.add(ByteCode.IFNE, trueGOTO); + cfw.add(ByteCode.GOTO, falseGOTO); + cfw.markLabel(notNumbersLabel); + // fall thru into generic handling + } + } + + generateExpression(child, node); + generateExpression(rChild, node); + + String name; + int testCode; + switch (type) { + case Token.EQ: + name = "eq"; + testCode = ByteCode.IFNE; + break; + case Token.NE: + name = "eq"; + testCode = ByteCode.IFEQ; + break; + case Token.SHEQ: + name = "shallowEq"; + testCode = ByteCode.IFNE; + break; + case Token.SHNE: + name = "shallowEq"; + testCode = ByteCode.IFEQ; + break; + default: + throw Codegen.badTree(); + } + addScriptRuntimeInvoke(name, + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +")Z"); + cfw.add(testCode, trueGOTO); + cfw.add(ByteCode.GOTO, falseGOTO); + } + if (stackInitial != cfw.getStackTop()) throw Codegen.badTree(); + } + + private void visitSetName(Node node, Node child) + { + String name = node.getFirstChild().getString(); + while (child != null) { + generateExpression(child, node); + child = child.getNext(); + } + cfw.addALoad(contextLocal); + cfw.addALoad(variableObjectLocal); + cfw.addPush(name); + addScriptRuntimeInvoke( + "setName", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +")Ljava/lang/Object;"); + } + + private void visitSetConst(Node node, Node child) + { + String name = node.getFirstChild().getString(); + while (child != null) { + generateExpression(child, node); + child = child.getNext(); + } + cfw.addALoad(contextLocal); + cfw.addPush(name); + addScriptRuntimeInvoke( + "setConst", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +"Ljava/lang/String;" + +")Ljava/lang/Object;"); + } + + private void visitGetVar(Node node) + { + if (!hasVarsInRegs) Kit.codeBug(); + int varIndex = fnCurrent.getVarIndex(node); + short reg = varRegisters[varIndex]; + if (varIsDirectCallParameter(varIndex)) { + // Remember that here the isNumber flag means that we + // want to use the incoming parameter in a Number + // context, so test the object type and convert the + // value as necessary. + if (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1) { + dcpLoadAsNumber(reg); + } else { + dcpLoadAsObject(reg); + } + } else if (fnCurrent.isNumberVar(varIndex)) { + cfw.addDLoad(reg); + } else { + cfw.addALoad(reg); + } + } + + private void visitSetVar(Node node, Node child, boolean needValue) + { + if (!hasVarsInRegs) Kit.codeBug(); + int varIndex = fnCurrent.getVarIndex(node); + generateExpression(child.getNext(), node); + boolean isNumber = (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1); + short reg = varRegisters[varIndex]; + boolean [] constDeclarations = fnCurrent.fnode.getParamAndVarConst(); + if (constDeclarations[varIndex]) { + if (!needValue) { + if (isNumber) + cfw.add(ByteCode.POP2); + else + cfw.add(ByteCode.POP); + } + } + else if (varIsDirectCallParameter(varIndex)) { + if (isNumber) { + if (needValue) cfw.add(ByteCode.DUP2); + cfw.addALoad(reg); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + int isNumberLabel = cfw.acquireLabel(); + int beyond = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPEQ, isNumberLabel); + short stack = cfw.getStackTop(); + addDoubleWrap(); + cfw.addAStore(reg); + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(isNumberLabel, stack); + cfw.addDStore(reg + 1); + cfw.markLabel(beyond); + } + else { + if (needValue) cfw.add(ByteCode.DUP); + cfw.addAStore(reg); + } + } else { + boolean isNumberVar = fnCurrent.isNumberVar(varIndex); + if (isNumber) { + if (isNumberVar) { + cfw.addDStore(reg); + if (needValue) cfw.addDLoad(reg); + } else { + if (needValue) cfw.add(ByteCode.DUP2); + // Cannot save number in variable since !isNumberVar, + // so convert to object + addDoubleWrap(); + cfw.addAStore(reg); + } + } else { + if (isNumberVar) Kit.codeBug(); + cfw.addAStore(reg); + if (needValue) cfw.addALoad(reg); + } + } + } + + private void visitSetConstVar(Node node, Node child, boolean needValue) + { + if (!hasVarsInRegs) Kit.codeBug(); + int varIndex = fnCurrent.getVarIndex(node); + generateExpression(child.getNext(), node); + boolean isNumber = (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1); + short reg = varRegisters[varIndex]; + int beyond = cfw.acquireLabel(); + int noAssign = cfw.acquireLabel(); + if (isNumber) { + cfw.addILoad(reg + 2); + cfw.add(ByteCode.IFNE, noAssign); + short stack = cfw.getStackTop(); + cfw.addPush(1); + cfw.addIStore(reg + 2); + cfw.addDStore(reg); + if (needValue) { + cfw.addDLoad(reg); + cfw.markLabel(noAssign, stack); + } else { + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(noAssign, stack); + cfw.add(ByteCode.POP2); + } + } + else { + cfw.addILoad(reg + 1); + cfw.add(ByteCode.IFNE, noAssign); + short stack = cfw.getStackTop(); + cfw.addPush(1); + cfw.addIStore(reg + 1); + cfw.addAStore(reg); + if (needValue) { + cfw.addALoad(reg); + cfw.markLabel(noAssign, stack); + } else { + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(noAssign, stack); + cfw.add(ByteCode.POP); + } + } + cfw.markLabel(beyond); + } + + private void visitGetProp(Node node, Node child) + { + generateExpression(child, node); // object + Node nameChild = child.getNext(); + generateExpression(nameChild, node); // the name + if (node.getType() == Token.GETPROPNOWARN) { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getObjectPropNoWarn", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + return; + } + /* + for 'this.foo' we call getObjectProp(Scriptable...) which can + skip some casting overhead. + */ + int childType = child.getType(); + if (childType == Token.THIS && nameChild.getType() == Token.STRING) { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getObjectProp", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } else { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getObjectProp", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + } + + private void visitSetProp(int type, Node node, Node child) + { + Node objectChild = child; + generateExpression(child, node); + child = child.getNext(); + if (type == Token.SETPROP_OP) { + cfw.add(ByteCode.DUP); + } + Node nameChild = child; + generateExpression(child, node); + child = child.getNext(); + if (type == Token.SETPROP_OP) { + // stack: ... object object name -> ... object name object name + cfw.add(ByteCode.DUP_X1); + //for 'this.foo += ...' we call thisGet which can skip some + //casting overhead. + if (objectChild.getType() == Token.THIS + && nameChild.getType() == Token.STRING) + { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getObjectProp", + "(Lorg/mozilla/javascript/Scriptable;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } else { + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getObjectProp", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + } + generateExpression(child, node); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "setObjectProp", + "(Ljava/lang/Object;" + +"Ljava/lang/String;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + + private void visitSetElem(int type, Node node, Node child) + { + generateExpression(child, node); + child = child.getNext(); + if (type == Token.SETELEM_OP) { + cfw.add(ByteCode.DUP); + } + generateExpression(child, node); + child = child.getNext(); + boolean indexIsNumber = (node.getIntProp(Node.ISNUMBER_PROP, -1) != -1); + if (type == Token.SETELEM_OP) { + if (indexIsNumber) { + // stack: ... object object number + // -> ... object number object number + cfw.add(ByteCode.DUP2_X1); + cfw.addALoad(contextLocal); + addOptRuntimeInvoke( + "getObjectIndex", + "(Ljava/lang/Object;D" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } else { + // stack: ... object object indexObject + // -> ... object indexObject object indexObject + cfw.add(ByteCode.DUP_X1); + cfw.addALoad(contextLocal); + addScriptRuntimeInvoke( + "getObjectElem", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + } + generateExpression(child, node); + cfw.addALoad(contextLocal); + if (indexIsNumber) { + addScriptRuntimeInvoke( + "setObjectIndex", + "(Ljava/lang/Object;" + +"D" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } else { + addScriptRuntimeInvoke( + "setObjectElem", + "(Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Context;" + +")Ljava/lang/Object;"); + } + } + + private void visitDotQuery(Node node, Node child) + { + updateLineNumber(node); + generateExpression(child, node); + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke("enterDotQuery", + "(Ljava/lang/Object;" + +"Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + + // add push null/pop with label in between to simplify code for loop + // continue when it is necessary to pop the null result from + // updateDotQuery + cfw.add(ByteCode.ACONST_NULL); + int queryLoopStart = cfw.acquireLabel(); + cfw.markLabel(queryLoopStart); // loop continue jumps here + cfw.add(ByteCode.POP); + + generateExpression(child.getNext(), node); + addScriptRuntimeInvoke("toBoolean", "(Ljava/lang/Object;)Z"); + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke("updateDotQuery", + "(Z" + +"Lorg/mozilla/javascript/Scriptable;" + +")Ljava/lang/Object;"); + cfw.add(ByteCode.DUP); + cfw.add(ByteCode.IFNULL, queryLoopStart); + // stack: ... non_null_result_of_updateDotQuery + cfw.addALoad(variableObjectLocal); + addScriptRuntimeInvoke("leaveDotQuery", + "(Lorg/mozilla/javascript/Scriptable;" + +")Lorg/mozilla/javascript/Scriptable;"); + cfw.addAStore(variableObjectLocal); + } + + private int getLocalBlockRegister(Node node) + { + Node localBlock = (Node)node.getProp(Node.LOCAL_BLOCK_PROP); + int localSlot = localBlock.getExistingIntProp(Node.LOCAL_PROP); + return localSlot; + } + + private void dcpLoadAsNumber(int dcp_register) + { + cfw.addALoad(dcp_register); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + int isNumberLabel = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPEQ, isNumberLabel); + short stack = cfw.getStackTop(); + cfw.addALoad(dcp_register); + addObjectToDouble(); + int beyond = cfw.acquireLabel(); + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(isNumberLabel, stack); + cfw.addDLoad(dcp_register + 1); + cfw.markLabel(beyond); + } + + private void dcpLoadAsObject(int dcp_register) + { + cfw.addALoad(dcp_register); + cfw.add(ByteCode.GETSTATIC, + "java/lang/Void", + "TYPE", + "Ljava/lang/Class;"); + int isNumberLabel = cfw.acquireLabel(); + cfw.add(ByteCode.IF_ACMPEQ, isNumberLabel); + short stack = cfw.getStackTop(); + cfw.addALoad(dcp_register); + int beyond = cfw.acquireLabel(); + cfw.add(ByteCode.GOTO, beyond); + cfw.markLabel(isNumberLabel, stack); + cfw.addDLoad(dcp_register + 1); + addDoubleWrap(); + cfw.markLabel(beyond); + } + + private void addGoto(Node target, int jumpcode) + { + int targetLabel = getTargetLabel(target); + cfw.add(jumpcode, targetLabel); + } + + private void addObjectToDouble() + { + addScriptRuntimeInvoke("toNumber", "(Ljava/lang/Object;)D"); + } + + private void addNewObjectArray(int size) + { + if (size == 0) { + if (itsZeroArgArray >= 0) { + cfw.addALoad(itsZeroArgArray); + } else { + cfw.add(ByteCode.GETSTATIC, + "org/mozilla/javascript/ScriptRuntime", + "emptyArgs", "[Ljava/lang/Object;"); + } + } else { + cfw.addPush(size); + cfw.add(ByteCode.ANEWARRAY, "java/lang/Object"); + } + } + + private void addScriptRuntimeInvoke(String methodName, + String methodSignature) + { + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org.mozilla.javascript.ScriptRuntime", + methodName, + methodSignature); + } + + private void addOptRuntimeInvoke(String methodName, + String methodSignature) + { + cfw.addInvoke(ByteCode.INVOKESTATIC, + "org/mozilla/javascript/optimizer/OptRuntime", + methodName, + methodSignature); + } + + private void addJumpedBooleanWrap(int trueLabel, int falseLabel) + { + cfw.markLabel(falseLabel); + int skip = cfw.acquireLabel(); + cfw.add(ByteCode.GETSTATIC, "java/lang/Boolean", + "FALSE", "Ljava/lang/Boolean;"); + cfw.add(ByteCode.GOTO, skip); + cfw.markLabel(trueLabel); + cfw.add(ByteCode.GETSTATIC, "java/lang/Boolean", + "TRUE", "Ljava/lang/Boolean;"); + cfw.markLabel(skip); + cfw.adjustStackTop(-1); // only have 1 of true/false + } + + private void addDoubleWrap() + { + addOptRuntimeInvoke("wrapDouble", "(D)Ljava/lang/Double;"); + } + + /** + * Const locals use an extra slot to hold the has-been-assigned-once flag at + * runtime. + * @param isConst true iff the variable is const + * @return the register for the word pair (double/long) + */ + private short getNewWordPairLocal(boolean isConst) + { + short result = getConsecutiveSlots(2, isConst); + if (result < (MAX_LOCALS - 1)) { + locals[result] = 1; + locals[result + 1] = 1; + if (isConst) + locals[result + 2] = 1; + if (result == firstFreeLocal) { + for (int i = firstFreeLocal + 2; i < MAX_LOCALS; i++) { + if (locals[i] == 0) { + firstFreeLocal = (short) i; + if (localsMax < firstFreeLocal) + localsMax = firstFreeLocal; + return result; + } + } + } + else { + return result; + } + } + throw Context.reportRuntimeError("Program too complex " + + "(out of locals)"); + } + + private short getNewWordLocal(boolean isConst) + { + short result = getConsecutiveSlots(1, isConst); + if (result < (MAX_LOCALS - 1)) { + locals[result] = 1; + if (isConst) + locals[result + 1] = 1; + if (result == firstFreeLocal) { + for (int i = firstFreeLocal + 2; i < MAX_LOCALS; i++) { + if (locals[i] == 0) { + firstFreeLocal = (short) i; + if (localsMax < firstFreeLocal) + localsMax = firstFreeLocal; + return result; + } + } + } + else { + return result; + } + } + throw Context.reportRuntimeError("Program too complex " + + "(out of locals)"); + } + + private short getNewWordLocal() + { + short result = firstFreeLocal; + locals[result] = 1; + for (int i = firstFreeLocal + 1; i < MAX_LOCALS; i++) { + if (locals[i] == 0) { + firstFreeLocal = (short) i; + if (localsMax < firstFreeLocal) + localsMax = firstFreeLocal; + return result; + } + } + throw Context.reportRuntimeError("Program too complex " + + "(out of locals)"); + } + + private short getConsecutiveSlots(int count, boolean isConst) { + if (isConst) + count++; + short result = firstFreeLocal; + while (true) { + if (result >= (MAX_LOCALS - 1)) + break; + int i; + for (i = 0; i < count; i++) + if (locals[result + i] != 0) + break; + if (i >= count) + break; + result++; + } + return result; + } + + // This is a valid call only for a local that is allocated by default. + private void incReferenceWordLocal(short local) + { + locals[local]++; + } + + // This is a valid call only for a local that is allocated by default. + private void decReferenceWordLocal(short local) + { + locals[local]--; + } + + private void releaseWordLocal(short local) + { + if (local < firstFreeLocal) + firstFreeLocal = local; + locals[local] = 0; + } + + + static final int GENERATOR_TERMINATE = -1; + static final int GENERATOR_START = 0; + static final int GENERATOR_YIELD_START = 1; + + ClassFileWriter cfw; + Codegen codegen; + CompilerEnvirons compilerEnv; + ScriptOrFnNode scriptOrFn; + public int scriptOrFnIndex; + private int savedCodeOffset; + + private OptFunctionNode fnCurrent; + private boolean isTopLevel; + + private static final int MAX_LOCALS = 256; + private int[] locals; + private short firstFreeLocal; + private short localsMax; + + private int itsLineNumber; + + private boolean hasVarsInRegs; + private short[] varRegisters; + private boolean inDirectCallFunction; + private boolean itsForcedObjectParameters; + private int enterAreaStartLabel; + private int epilogueLabel; + + // special known locals. If you add a new local here, be sure + // to initialize it to -1 in initBodyGeneration + private short variableObjectLocal; + private short popvLocal; + private short contextLocal; + private short argsLocal; + private short operationLocal; + private short thisObjLocal; + private short funObjLocal; + private short itsZeroArgArray; + private short itsOneArgArray; + private short scriptRegexpLocal; + private short generatorStateLocal; + + private boolean isGenerator; + private int generatorSwitch; + private int maxLocals = 0; + private int maxStack = 0; + + private Hashtable finallys; + + class FinallyReturnPoint { + public ArrayList jsrPoints = new ArrayList(); + public int tableLabel = 0; + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/DataFlowBitSet.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/DataFlowBitSet.java new file mode 100644 index 0000000..607e649 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/DataFlowBitSet.java @@ -0,0 +1,134 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + + +package org.mozilla.javascript.optimizer; + +class DataFlowBitSet { + + private int itsBits[]; + private int itsSize; + + DataFlowBitSet(int size) + { + itsSize = size; + itsBits = new int[(size + 31) >> 5]; + } + + void set(int n) + { + if (!(0 <= n && n < itsSize)) badIndex(n); + itsBits[n >> 5] |= 1 << (n & 31); + } + + boolean test(int n) + { + if (!(0 <= n && n < itsSize)) badIndex(n); + return ((itsBits[n >> 5] & (1 << (n & 31))) != 0); + } + + void not() + { + int bitsLength = itsBits.length; + for (int i = 0; i < bitsLength; i++) + itsBits[i] = ~itsBits[i]; + } + + void clear(int n) + { + if (!(0 <= n && n < itsSize)) badIndex(n); + itsBits[n >> 5] &= ~(1 << (n & 31)); + } + + void clear() + { + int bitsLength = itsBits.length; + for (int i = 0; i < bitsLength; i++) + itsBits[i] = 0; + } + + void or(DataFlowBitSet b) + { + int bitsLength = itsBits.length; + for (int i = 0; i < bitsLength; i++) + itsBits[i] |= b.itsBits[i]; + } + + public String toString() + { + StringBuffer sb = new StringBuffer(); + sb.append("DataFlowBitSet, size = "); + sb.append(itsSize); + sb.append('\n'); + int bitsLength = itsBits.length; + for (int i = 0; i < bitsLength; i++) { + sb.append(Integer.toHexString(itsBits[i])); + sb.append(' '); + } + return sb.toString(); + } + + boolean df(DataFlowBitSet in, DataFlowBitSet gen, DataFlowBitSet notKill) + { + int bitsLength = itsBits.length; + boolean changed = false; + for (int i = 0; i < bitsLength; i++) { + int oldBits = itsBits[i]; + itsBits[i] = (in.itsBits[i] | gen.itsBits[i]) & notKill.itsBits[i]; + changed |= (oldBits != itsBits[i]); + } + return changed; + } + + boolean df2(DataFlowBitSet in, DataFlowBitSet gen, DataFlowBitSet notKill) + { + int bitsLength = itsBits.length; + boolean changed = false; + for (int i = 0; i < bitsLength; i++) { + int oldBits = itsBits[i]; + itsBits[i] = (in.itsBits[i] & notKill.itsBits[i]) | gen.itsBits[i]; + changed |= (oldBits != itsBits[i]); + } + return changed; + } + + private void badIndex(int n) + { + throw new RuntimeException("DataFlowBitSet bad index " + n); + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptFunctionNode.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptFunctionNode.java new file mode 100644 index 0000000..e043165 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptFunctionNode.java @@ -0,0 +1,149 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Bob Jervis + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; + +final class OptFunctionNode +{ + OptFunctionNode(FunctionNode fnode) + { + this.fnode = fnode; + fnode.setCompilerData(this); + } + + static OptFunctionNode get(ScriptOrFnNode scriptOrFn, int i) + { + FunctionNode fnode = scriptOrFn.getFunctionNode(i); + return (OptFunctionNode)fnode.getCompilerData(); + } + + static OptFunctionNode get(ScriptOrFnNode scriptOrFn) + { + return (OptFunctionNode)scriptOrFn.getCompilerData(); + } + + boolean isTargetOfDirectCall() + { + return directTargetIndex >= 0; + } + + int getDirectTargetIndex() + { + return directTargetIndex; + } + + void setDirectTargetIndex(int directTargetIndex) + { + // One time action + if (directTargetIndex < 0 || this.directTargetIndex >= 0) + Kit.codeBug(); + this.directTargetIndex = directTargetIndex; + } + + void setParameterNumberContext(boolean b) + { + itsParameterNumberContext = b; + } + + boolean getParameterNumberContext() + { + return itsParameterNumberContext; + } + + int getVarCount() + { + return fnode.getParamAndVarCount(); + } + + boolean isParameter(int varIndex) + { + return varIndex < fnode.getParamCount(); + } + + boolean isNumberVar(int varIndex) + { + varIndex -= fnode.getParamCount(); + if (varIndex >= 0 && numberVarFlags != null) { + return numberVarFlags[varIndex]; + } + return false; + } + + void setIsNumberVar(int varIndex) + { + varIndex -= fnode.getParamCount(); + // Can only be used with non-parameters + if (varIndex < 0) Kit.codeBug(); + if (numberVarFlags == null) { + int size = fnode.getParamAndVarCount() - fnode.getParamCount(); + numberVarFlags = new boolean[size]; + } + numberVarFlags[varIndex] = true; + } + + int getVarIndex(Node n) + { + int index = n.getIntProp(Node.VARIABLE_PROP, -1); + if (index == -1) { + Node node; + int type = n.getType(); + if (type == Token.GETVAR) { + node = n; + } else if (type == Token.SETVAR || + type == Token.SETCONSTVAR) { + node = n.getFirstChild(); + } else { + throw Kit.codeBug(); + } + index = fnode.getIndexForNameNode(node); + if (index < 0) throw Kit.codeBug(); + n.putIntProp(Node.VARIABLE_PROP, index); + } + return index; + } + + FunctionNode fnode; + private boolean[] numberVarFlags; + private int directTargetIndex = -1; + private boolean itsParameterNumberContext; + boolean itsContainsCalls0; + boolean itsContainsCalls1; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptRuntime.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptRuntime.java new file mode 100644 index 0000000..ba8ca03 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptRuntime.java @@ -0,0 +1,311 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * Hannes Wallnoefer + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; + +public final class OptRuntime extends ScriptRuntime +{ + + public static final Double zeroObj = new Double(0.0); + public static final Double oneObj = new Double(1.0); + public static final Double minusOneObj = new Double(-1.0); + + /** + * Implement ....() call shrinking optimizer code. + */ + public static Object call0(Callable fun, Scriptable thisObj, + Context cx, Scriptable scope) + { + return fun.call(cx, scope, thisObj, ScriptRuntime.emptyArgs); + } + + /** + * Implement ....(arg) call shrinking optimizer code. + */ + public static Object call1(Callable fun, Scriptable thisObj, Object arg0, + Context cx, Scriptable scope) + { + return fun.call(cx, scope, thisObj, new Object[] { arg0 } ); + } + + /** + * Implement ....(arg0, arg1) call shrinking optimizer code. + */ + public static Object call2(Callable fun, Scriptable thisObj, + Object arg0, Object arg1, + Context cx, Scriptable scope) + { + return fun.call(cx, scope, thisObj, new Object[] { arg0, arg1 }); + } + + /** + * Implement ....(arg0, arg1, ...) call shrinking optimizer code. + */ + public static Object callN(Callable fun, Scriptable thisObj, + Object[] args, + Context cx, Scriptable scope) + { + return fun.call(cx, scope, thisObj, args); + } + + /** + * Implement name(args) call shrinking optimizer code. + */ + public static Object callName(Object[] args, String name, + Context cx, Scriptable scope) + { + Callable f = getNameFunctionAndThis(name, cx, scope); + Scriptable thisObj = lastStoredScriptable(cx); + return f.call(cx, scope, thisObj, args); + } + + /** + * Implement name() call shrinking optimizer code. + */ + public static Object callName0(String name, + Context cx, Scriptable scope) + { + Callable f = getNameFunctionAndThis(name, cx, scope); + Scriptable thisObj = lastStoredScriptable(cx); + return f.call(cx, scope, thisObj, ScriptRuntime.emptyArgs); + } + + /** + * Implement x.property() call shrinking optimizer code. + */ + public static Object callProp0(Object value, String property, + Context cx, Scriptable scope) + { + Callable f = getPropFunctionAndThis(value, property, cx); + Scriptable thisObj = lastStoredScriptable(cx); + return f.call(cx, scope, thisObj, ScriptRuntime.emptyArgs); + } + + public static Object add(Object val1, double val2) + { + if (val1 instanceof Scriptable) + val1 = ((Scriptable) val1).getDefaultValue(null); + if (!(val1 instanceof String)) + return wrapDouble(toNumber(val1) + val2); + return ((String)val1).concat(toString(val2)); + } + + public static Object add(double val1, Object val2) + { + if (val2 instanceof Scriptable) + val2 = ((Scriptable) val2).getDefaultValue(null); + if (!(val2 instanceof String)) + return wrapDouble(toNumber(val2) + val1); + return toString(val1).concat((String)val2); + } + + public static Object elemIncrDecr(Object obj, double index, + Context cx, int incrDecrMask) + { + return ScriptRuntime.elemIncrDecr(obj, new Double(index), cx, + incrDecrMask); + } + + public static Object[] padStart(Object[] currentArgs, int count) { + Object[] result = new Object[currentArgs.length + count]; + System.arraycopy(currentArgs, 0, result, count, currentArgs.length); + return result; + } + + public static void initFunction(NativeFunction fn, int functionType, + Scriptable scope, Context cx) + { + ScriptRuntime.initFunction(cx, scope, fn, functionType, false); + } + + public static Object callSpecial(Context cx, Callable fun, + Scriptable thisObj, Object[] args, + Scriptable scope, + Scriptable callerThis, int callType, + String fileName, int lineNumber) + { + return ScriptRuntime.callSpecial(cx, fun, thisObj, args, scope, + callerThis, callType, + fileName, lineNumber); + } + + public static Object newObjectSpecial(Context cx, Object fun, + Object[] args, Scriptable scope, + Scriptable callerThis, int callType) + { + return ScriptRuntime.newSpecial(cx, fun, args, scope, callType); + } + + public static Double wrapDouble(double num) + { + if (num == 0.0) { + if (1 / num > 0) { + // +0.0 + return zeroObj; + } + } else if (num == 1.0) { + return oneObj; + } else if (num == -1.0) { + return minusOneObj; + } else if (num != num) { + return NaNobj; + } + return new Double(num); + } + + static String encodeIntArray(int[] array) + { + // XXX: this extremely inefficient for small integers + if (array == null) { return null; } + int n = array.length; + char[] buffer = new char[1 + n * 2]; + buffer[0] = 1; + for (int i = 0; i != n; ++i) { + int value = array[i]; + int shift = 1 + i * 2; + buffer[shift] = (char)(value >>> 16); + buffer[shift + 1] = (char)value; + } + return new String(buffer); + } + + private static int[] decodeIntArray(String str, int arraySize) + { + // XXX: this extremely inefficient for small integers + if (arraySize == 0) { + if (str != null) throw new IllegalArgumentException(); + return null; + } + if (str.length() != 1 + arraySize * 2 && str.charAt(0) != 1) { + throw new IllegalArgumentException(); + } + int[] array = new int[arraySize]; + for (int i = 0; i != arraySize; ++i) { + int shift = 1 + i * 2; + array[i] = (str.charAt(shift) << 16) | str.charAt(shift + 1); + } + return array; + } + + public static Scriptable newArrayLiteral(Object[] objects, + String encodedInts, + int skipCount, + Context cx, + Scriptable scope) + { + int[] skipIndexces = decodeIntArray(encodedInts, skipCount); + return newArrayLiteral(objects, skipIndexces, cx, scope); + } + + public static void main(final Script script, final String[] args) + { + Context.call(new ContextAction() { + public Object run(Context cx) + { + ScriptableObject global = getGlobal(cx); + + // get the command line arguments and define "arguments" + // array in the top-level object + Object[] argsCopy = new Object[args.length]; + System.arraycopy(args, 0, argsCopy, 0, args.length); + Scriptable argsObj = cx.newArray(global, argsCopy); + global.defineProperty("arguments", argsObj, + ScriptableObject.DONTENUM); + script.exec(cx, global); + return null; + } + }); + } + + public static void throwStopIteration(Object obj) { + throw new JavaScriptException( + NativeIterator.getStopIterationObject((Scriptable)obj), "", 0); + } + + public static Scriptable createNativeGenerator(NativeFunction funObj, + Scriptable scope, + Scriptable thisObj, + int maxLocals, + int maxStack) + { + return new NativeGenerator(scope, funObj, + new GeneratorState(thisObj, maxLocals, maxStack)); + } + + public static Object[] getGeneratorStackState(Object obj) { + GeneratorState rgs = (GeneratorState) obj; + if (rgs.stackState == null) + rgs.stackState = new Object[rgs.maxStack]; + return rgs.stackState; + } + + public static Object[] getGeneratorLocalsState(Object obj) { + GeneratorState rgs = (GeneratorState) obj; + if (rgs.localsState == null) + rgs.localsState = new Object[rgs.maxLocals]; + return rgs.localsState; + } + + public static class GeneratorState { + static final String CLASS_NAME = + "org/mozilla/javascript/optimizer/OptRuntime$GeneratorState"; + + public int resumptionPoint; + static final String resumptionPoint_NAME = "resumptionPoint"; + static final String resumptionPoint_TYPE = "I"; + + public Scriptable thisObj; + static final String thisObj_NAME = "thisObj"; + static final String thisObj_TYPE = + "Lorg/mozilla/javascript/Scriptable;"; + + Object[] stackState; + Object[] localsState; + int maxLocals; + int maxStack; + + GeneratorState(Scriptable thisObj, int maxLocals, int maxStack) { + this.thisObj = thisObj; + this.maxLocals = maxLocals; + this.maxStack = maxStack; + } + } +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptTransformer.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptTransformer.java new file mode 100644 index 0000000..7cf679f --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/OptTransformer.java @@ -0,0 +1,133 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; +import java.util.Hashtable; + +/** + * This class performs node transforms to prepare for optimization. + * + * @see NodeTransformer + * @author Norris Boyd + */ + +class OptTransformer extends NodeTransformer { + + OptTransformer(Hashtable possibleDirectCalls, ObjArray directCallTargets) + { + this.possibleDirectCalls = possibleDirectCalls; + this.directCallTargets = directCallTargets; + } + + protected void visitNew(Node node, ScriptOrFnNode tree) { + detectDirectCall(node, tree); + super.visitNew(node, tree); + } + + protected void visitCall(Node node, ScriptOrFnNode tree) { + detectDirectCall(node, tree); + super.visitCall(node, tree); + } + + private void detectDirectCall(Node node, ScriptOrFnNode tree) + { + if (tree.getType() == Token.FUNCTION) { + Node left = node.getFirstChild(); + + // count the arguments + int argCount = 0; + Node arg = left.getNext(); + while (arg != null) { + arg = arg.getNext(); + argCount++; + } + + if (argCount == 0) { + OptFunctionNode.get(tree).itsContainsCalls0 = true; + } + + /* + * Optimize a call site by converting call("a", b, c) into : + * + * FunctionObjectFor"a" <-- instance variable init'd by constructor + * + * // this is a DIRECTCALL node + * fn = GetProp(tmp = GetBase("a"), "a"); + * if (fn == FunctionObjectFor"a") + * fn.call(tmp, b, c) + * else + * ScriptRuntime.Call(fn, tmp, b, c) + */ + if (possibleDirectCalls != null) { + String targetName = null; + if (left.getType() == Token.NAME) { + targetName = left.getString(); + } else if (left.getType() == Token.GETPROP) { + targetName = left.getFirstChild().getNext().getString(); + } else if (left.getType() == Token.GETPROPNOWARN) { + throw Kit.codeBug(); + } + if (targetName != null) { + OptFunctionNode ofn; + ofn = (OptFunctionNode)possibleDirectCalls.get(targetName); + if (ofn != null + && argCount == ofn.fnode.getParamCount() + && !ofn.fnode.requiresActivation()) + { + // Refuse to directCall any function with more + // than 32 parameters - prevent code explosion + // for wacky test cases + if (argCount <= 32) { + node.putProp(Node.DIRECTCALL_PROP, ofn); + if (!ofn.isTargetOfDirectCall()) { + int index = directCallTargets.size(); + directCallTargets.add(ofn); + ofn.setDirectTargetIndex(index); + } + } + } + } + } + } + } + + private Hashtable possibleDirectCalls; + private ObjArray directCallTargets; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Optimizer.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Optimizer.java new file mode 100644 index 0000000..575c7e7 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/optimizer/Optimizer.java @@ -0,0 +1,510 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Roger Lawrence + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + + + +package org.mozilla.javascript.optimizer; + +import org.mozilla.javascript.*; + +class Optimizer +{ + + static final int NoType = 0; + static final int NumberType = 1; + static final int AnyType = 3; + + // It is assumed that (NumberType | AnyType) == AnyType + + void optimize(ScriptOrFnNode scriptOrFn) + { + // run on one function at a time for now + int functionCount = scriptOrFn.getFunctionCount(); + for (int i = 0; i != functionCount; ++i) { + OptFunctionNode f = OptFunctionNode.get(scriptOrFn, i); + optimizeFunction(f); + } + } + + private void optimizeFunction(OptFunctionNode theFunction) + { + if (theFunction.fnode.requiresActivation()) return; + + inDirectCallFunction = theFunction.isTargetOfDirectCall(); + this.theFunction = theFunction; + + ObjArray statementsArray = new ObjArray(); + buildStatementList_r(theFunction.fnode, statementsArray); + Node[] theStatementNodes = new Node[statementsArray.size()]; + statementsArray.toArray(theStatementNodes); + + Block.runFlowAnalyzes(theFunction, theStatementNodes); + + if (!theFunction.fnode.requiresActivation()) { + /* + * Now that we know which local vars are in fact always + * Numbers, we re-write the tree to take advantage of + * that. Any arithmetic or assignment op involving just + * Number typed vars is marked so that the codegen will + * generate non-object code. + */ + parameterUsedInNumberContext = false; + for (int i = 0; i < theStatementNodes.length; i++) { + rewriteForNumberVariables(theStatementNodes[i]); + } + theFunction.setParameterNumberContext(parameterUsedInNumberContext); + } + + } + + +/* + Each directCall parameter is passed as a pair of values - an object + and a double. The value passed depends on the type of value available at + the call site. If a double is available, the object in java/lang/Void.TYPE + is passed as the object value, and if an object value is available, then + 0.0 is passed as the double value. + + The receiving routine always tests the object value before proceeding. + If the parameter is being accessed in a 'Number Context' then the code + sequence is : + if ("parameter_objectValue" == java/lang/Void.TYPE) + ...fine..., use the parameter_doubleValue + else + toNumber(parameter_objectValue) + + and if the parameter is being referenced in an Object context, the code is + if ("parameter_objectValue" == java/lang/Void.TYPE) + new Double(parameter_doubleValue) + else + ...fine..., use the parameter_objectValue + + If the receiving code never uses the doubleValue, it is converted on + entry to a Double instead. +*/ + + +/* + We're referencing a node in a Number context (i.e. we'd prefer it + was a double value). If the node is a parameter in a directCall + function, mark it as being referenced in this context. +*/ + private void markDCPNumberContext(Node n) + { + if (inDirectCallFunction && n.getType() == Token.GETVAR) { + int varIndex = theFunction.getVarIndex(n); + if (theFunction.isParameter(varIndex)) { + parameterUsedInNumberContext = true; + } + } + } + + private boolean convertParameter(Node n) + { + if (inDirectCallFunction && n.getType() == Token.GETVAR) { + int varIndex = theFunction.getVarIndex(n); + if (theFunction.isParameter(varIndex)) { + n.removeProp(Node.ISNUMBER_PROP); + return true; + } + } + return false; + } + + private int rewriteForNumberVariables(Node n) + { + switch (n.getType()) { + case Token.EXPR_VOID : { + Node child = n.getFirstChild(); + int type = rewriteForNumberVariables(child); + if (type == NumberType) + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NoType; + } + case Token.NUMBER : + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + + case Token.GETVAR : + { + int varIndex = theFunction.getVarIndex(n); + if (inDirectCallFunction + && theFunction.isParameter(varIndex)) + { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + } + else if (theFunction.isNumberVar(varIndex)) { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + } + return NoType; + } + + case Token.INC : + case Token.DEC : { + Node child = n.getFirstChild(); + // "child" will be GETVAR or GETPROP or GETELEM + if (child.getType() == Token.GETVAR) { + if (rewriteForNumberVariables(child) == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + markDCPNumberContext(child); + return NumberType; + } + return NoType; + } + else if (child.getType() == Token.GETELEM) { + return rewriteForNumberVariables(child); + } + return NoType; + } + case Token.SETVAR : { + Node lChild = n.getFirstChild(); + Node rChild = lChild.getNext(); + int rType = rewriteForNumberVariables(rChild); + int varIndex = theFunction.getVarIndex(n); + if (inDirectCallFunction + && theFunction.isParameter(varIndex)) + { + if (rType == NumberType) { + if (!convertParameter(rChild)) { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + } + markDCPNumberContext(rChild); + return NoType; + } + else + return rType; + } + else if (theFunction.isNumberVar(varIndex)) { + if (rType != NumberType) { + n.removeChild(rChild); + n.addChildToBack( + new Node(Token.TO_DOUBLE, rChild)); + } + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + markDCPNumberContext(rChild); + return NumberType; + } + else { + if (rType == NumberType) { + if (!convertParameter(rChild)) { + n.removeChild(rChild); + n.addChildToBack( + new Node(Token.TO_OBJECT, rChild)); + } + } + return NoType; + } + } + case Token.LE : + case Token.LT : + case Token.GE : + case Token.GT : { + Node lChild = n.getFirstChild(); + Node rChild = lChild.getNext(); + int lType = rewriteForNumberVariables(lChild); + int rType = rewriteForNumberVariables(rChild); + markDCPNumberContext(lChild); + markDCPNumberContext(rChild); + + if (convertParameter(lChild)) { + if (convertParameter(rChild)) { + return NoType; + } else if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.RIGHT); + } + } + else if (convertParameter(rChild)) { + if (lType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.LEFT); + } + } + else { + if (lType == NumberType) { + if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + } + else { + n.putIntProp(Node.ISNUMBER_PROP, Node.LEFT); + } + } + else { + if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.RIGHT); + } + } + } + // we actually build a boolean value + return NoType; + } + + case Token.ADD : { + Node lChild = n.getFirstChild(); + Node rChild = lChild.getNext(); + int lType = rewriteForNumberVariables(lChild); + int rType = rewriteForNumberVariables(rChild); + + + if (convertParameter(lChild)) { + if (convertParameter(rChild)) { + return NoType; + } + else { + if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.RIGHT); + } + } + } + else { + if (convertParameter(rChild)) { + if (lType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.LEFT); + } + } + else { + if (lType == NumberType) { + if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + } + else { + n.putIntProp(Node.ISNUMBER_PROP, Node.LEFT); + } + } + else { + if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, + Node.RIGHT); + } + } + } + } + return NoType; + } + + case Token.BITXOR : + case Token.BITOR : + case Token.BITAND : + case Token.RSH : + case Token.LSH : + case Token.SUB : + case Token.MUL : + case Token.DIV : + case Token.MOD : { + Node lChild = n.getFirstChild(); + Node rChild = lChild.getNext(); + int lType = rewriteForNumberVariables(lChild); + int rType = rewriteForNumberVariables(rChild); + markDCPNumberContext(lChild); + markDCPNumberContext(rChild); + if (lType == NumberType) { + if (rType == NumberType) { + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + } + else { + if (!convertParameter(rChild)) { + n.removeChild(rChild); + n.addChildToBack( + new Node(Token.TO_DOUBLE, rChild)); + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + } + return NumberType; + } + } + else { + if (rType == NumberType) { + if (!convertParameter(lChild)) { + n.removeChild(lChild); + n.addChildToFront( + new Node(Token.TO_DOUBLE, lChild)); + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + } + return NumberType; + } + else { + if (!convertParameter(lChild)) { + n.removeChild(lChild); + n.addChildToFront( + new Node(Token.TO_DOUBLE, lChild)); + } + if (!convertParameter(rChild)) { + n.removeChild(rChild); + n.addChildToBack( + new Node(Token.TO_DOUBLE, rChild)); + } + n.putIntProp(Node.ISNUMBER_PROP, Node.BOTH); + return NumberType; + } + } + } + case Token.SETELEM : + case Token.SETELEM_OP : { + Node arrayBase = n.getFirstChild(); + Node arrayIndex = arrayBase.getNext(); + Node rValue = arrayIndex.getNext(); + int baseType = rewriteForNumberVariables(arrayBase); + if (baseType == NumberType) {// can never happen ??? + if (!convertParameter(arrayBase)) { + n.removeChild(arrayBase); + n.addChildToFront( + new Node(Token.TO_OBJECT, arrayBase)); + } + } + int indexType = rewriteForNumberVariables(arrayIndex); + if (indexType == NumberType) { + // setting the ISNUMBER_PROP signals the codegen + // to use the OptRuntime.setObjectIndex that takes + // a double index + n.putIntProp(Node.ISNUMBER_PROP, Node.LEFT); + markDCPNumberContext(arrayIndex); + } + int rValueType = rewriteForNumberVariables(rValue); + if (rValueType == NumberType) { + if (!convertParameter(rValue)) { + n.removeChild(rValue); + n.addChildToBack( + new Node(Token.TO_OBJECT, rValue)); + } + } + return NoType; + } + case Token.GETELEM : { + Node arrayBase = n.getFirstChild(); + Node arrayIndex = arrayBase.getNext(); + int baseType = rewriteForNumberVariables(arrayBase); + if (baseType == NumberType) {// can never happen ??? + if (!convertParameter(arrayBase)) { + n.removeChild(arrayBase); + n.addChildToFront( + new Node(Token.TO_OBJECT, arrayBase)); + } + } + int indexType = rewriteForNumberVariables(arrayIndex); + if (indexType == NumberType) { + if (!convertParameter(arrayIndex)) { + // setting the ISNUMBER_PROP signals the codegen + // to use the OptRuntime.getObjectIndex that takes + // a double index + n.putIntProp(Node.ISNUMBER_PROP, Node.RIGHT); + } + } + return NoType; + } + case Token.CALL : + { + Node child = n.getFirstChild(); // the function node + if (child.getType() == Token.GETELEM) { + // Optimization of x[0]() is not supported + // so bypass GETELEM optimization that + // rewriteForNumberVariables would trigger + rewriteAsObjectChildren(child, child.getFirstChild()); + } else { + rewriteForNumberVariables(child); + } + child = child.getNext(); // the first arg + + OptFunctionNode target + = (OptFunctionNode)n.getProp(Node.DIRECTCALL_PROP); + if (target != null) { +/* + we leave each child as a Number if it can be. The codegen will + handle moving the pairs of parameters. +*/ + while (child != null) { + int type = rewriteForNumberVariables(child); + if (type == NumberType) { + markDCPNumberContext(child); + } + child = child.getNext(); + } + } else { + rewriteAsObjectChildren(n, child); + } + return NoType; + } + default : { + rewriteAsObjectChildren(n, n.getFirstChild()); + return NoType; + } + } + } + + private void rewriteAsObjectChildren(Node n, Node child) + { + // Force optimized children to be objects + while (child != null) { + Node nextChild = child.getNext(); + int type = rewriteForNumberVariables(child); + if (type == NumberType) { + if (!convertParameter(child)) { + n.removeChild(child); + Node nuChild = new Node(Token.TO_OBJECT, child); + if (nextChild == null) + n.addChildToBack(nuChild); + else + n.addChildBefore(nuChild, nextChild); + } + } + child = nextChild; + } + } + + private static void buildStatementList_r(Node node, ObjArray statements) + { + int type = node.getType(); + if (type == Token.BLOCK + || type == Token.LOCAL_BLOCK + || type == Token.LOOP + || type == Token.FUNCTION) + { + Node child = node.getFirstChild(); + while (child != null) { + buildStatementList_r(child, statements); + child = child.getNext(); + } + } else { + statements.add(node); + } + } + + private boolean inDirectCallFunction; + OptFunctionNode theFunction; + private boolean parameterUsedInNumberContext; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/NativeRegExp.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/NativeRegExp.java new file mode 100644 index 0000000..a893841 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/NativeRegExp.java @@ -0,0 +1,2782 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1998. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Brendan Eich + * Matthias Radestock + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.regexp; + +import java.io.Serializable; + +import org.mozilla.javascript.Context; +import org.mozilla.javascript.Function; +import org.mozilla.javascript.IdFunctionObject; +import org.mozilla.javascript.IdScriptableObject; +import org.mozilla.javascript.Kit; +import org.mozilla.javascript.ScriptRuntime; +import org.mozilla.javascript.Scriptable; +import org.mozilla.javascript.ScriptableObject; +import org.mozilla.javascript.Undefined; + +/** + * This class implements the RegExp native object. + * + * Revision History: + * Implementation in C by Brendan Eich + * Initial port to Java by Norris Boyd from jsregexp.c version 1.36 + * Merged up to version 1.38, which included Unicode support. + * Merged bug fixes in version 1.39. + * Merged JSFUN13_BRANCH changes up to 1.32.2.13 + * + * @author Brendan Eich + * @author Norris Boyd + */ + + + +public class NativeRegExp extends IdScriptableObject implements Function +{ + static final long serialVersionUID = 4965263491464903264L; + + private static final Object REGEXP_TAG = new Object(); + + public static final int JSREG_GLOB = 0x1; // 'g' flag: global + public static final int JSREG_FOLD = 0x2; // 'i' flag: fold + public static final int JSREG_MULTILINE = 0x4; // 'm' flag: multiline + + //type of match to perform + public static final int TEST = 0; + public static final int MATCH = 1; + public static final int PREFIX = 2; + + private static final boolean debug = false; + + private static final byte REOP_EMPTY = 0; /* match rest of input against rest of r.e. */ + private static final byte REOP_ALT = 1; /* alternative subexpressions in kid and next */ + private static final byte REOP_BOL = 2; /* beginning of input (or line if multiline) */ + private static final byte REOP_EOL = 3; /* end of input (or line if multiline) */ + private static final byte REOP_WBDRY = 4; /* match "" at word boundary */ + private static final byte REOP_WNONBDRY = 5; /* match "" at word non-boundary */ + private static final byte REOP_QUANT = 6; /* quantified atom: atom{1,2} */ + private static final byte REOP_STAR = 7; /* zero or more occurrences of kid */ + private static final byte REOP_PLUS = 8; /* one or more occurrences of kid */ + private static final byte REOP_OPT = 9; /* optional subexpression in kid */ + private static final byte REOP_LPAREN = 10; /* left paren bytecode: kid is u.num'th sub-regexp */ + private static final byte REOP_RPAREN = 11; /* right paren bytecode */ + private static final byte REOP_DOT = 12; /* stands for any character */ +// private static final byte REOP_CCLASS = 13; /* character class: [a-f] */ + private static final byte REOP_DIGIT = 14; /* match a digit char: [0-9] */ + private static final byte REOP_NONDIGIT = 15; /* match a non-digit char: [^0-9] */ + private static final byte REOP_ALNUM = 16; /* match an alphanumeric char: [0-9a-z_A-Z] */ + private static final byte REOP_NONALNUM = 17; /* match a non-alphanumeric char: [^0-9a-z_A-Z] */ + private static final byte REOP_SPACE = 18; /* match a whitespace char */ + private static final byte REOP_NONSPACE = 19; /* match a non-whitespace char */ + private static final byte REOP_BACKREF = 20; /* back-reference (e.g., \1) to a parenthetical */ + private static final byte REOP_FLAT = 21; /* match a flat string */ + private static final byte REOP_FLAT1 = 22; /* match a single char */ + private static final byte REOP_JUMP = 23; /* for deoptimized closure loops */ +// private static final byte REOP_DOTSTAR = 24; /* optimize .* to use a single opcode */ +// private static final byte REOP_ANCHOR = 25; /* like .* but skips left context to unanchored r.e. */ +// private static final byte REOP_EOLONLY = 26; /* $ not preceded by any pattern */ +// private static final byte REOP_UCFLAT = 27; /* flat Unicode string; len immediate counts chars */ + private static final byte REOP_UCFLAT1 = 28; /* single Unicode char */ +// private static final byte REOP_UCCLASS = 29; /* Unicode character class, vector of chars to match */ +// private static final byte REOP_NUCCLASS = 30; /* negated Unicode character class */ +// private static final byte REOP_BACKREFi = 31; /* case-independent REOP_BACKREF */ + private static final byte REOP_FLATi = 32; /* case-independent REOP_FLAT */ + private static final byte REOP_FLAT1i = 33; /* case-independent REOP_FLAT1 */ +// private static final byte REOP_UCFLATi = 34; /* case-independent REOP_UCFLAT */ + private static final byte REOP_UCFLAT1i = 35; /* case-independent REOP_UCFLAT1 */ +// private static final byte REOP_ANCHOR1 = 36; /* first-char discriminating REOP_ANCHOR */ +// private static final byte REOP_NCCLASS = 37; /* negated 8-bit character class */ +// private static final byte REOP_DOTSTARMIN = 38; /* ungreedy version of REOP_DOTSTAR */ +// private static final byte REOP_LPARENNON = 39; /* non-capturing version of REOP_LPAREN */ +// private static final byte REOP_RPARENNON = 40; /* non-capturing version of REOP_RPAREN */ + private static final byte REOP_ASSERT = 41; /* zero width positive lookahead assertion */ + private static final byte REOP_ASSERT_NOT = 42; /* zero width negative lookahead assertion */ + private static final byte REOP_ASSERTTEST = 43; /* sentinel at end of assertion child */ + private static final byte REOP_ASSERTNOTTEST = 44; /* sentinel at end of !assertion child */ + private static final byte REOP_MINIMALSTAR = 45; /* non-greedy version of * */ + private static final byte REOP_MINIMALPLUS = 46; /* non-greedy version of + */ + private static final byte REOP_MINIMALOPT = 47; /* non-greedy version of ? */ + private static final byte REOP_MINIMALQUANT = 48; /* non-greedy version of {} */ + private static final byte REOP_ENDCHILD = 49; /* sentinel at end of quantifier child */ + private static final byte REOP_CLASS = 50; /* character class with index */ + private static final byte REOP_REPEAT = 51; /* directs execution of greedy quantifier */ + private static final byte REOP_MINIMALREPEAT = 52; /* directs execution of non-greedy quantifier */ + private static final byte REOP_END = 53; + + + + public static void init(Context cx, Scriptable scope, boolean sealed) + { + + NativeRegExp proto = new NativeRegExp(); + proto.re = (RECompiled)compileRE(cx, "", null, false); + proto.activatePrototypeMap(MAX_PROTOTYPE_ID); + proto.setParentScope(scope); + proto.setPrototype(getObjectPrototype(scope)); + + NativeRegExpCtor ctor = new NativeRegExpCtor(); + // Bug #324006: ECMA-262 15.10.6.1 says "The initial value of + // RegExp.prototype.constructor is the builtin RegExp constructor." + proto.put("constructor", proto, ctor); + + ScriptRuntime.setFunctionProtoAndParent(ctor, scope); + + ctor.setImmunePrototypeProperty(proto); + + if (sealed) { + proto.sealObject(); + ctor.sealObject(); + } + + defineProperty(scope, "RegExp", ctor, ScriptableObject.DONTENUM); + } + + NativeRegExp(Scriptable scope, Object regexpCompiled) + { + this.re = (RECompiled)regexpCompiled; + this.lastIndex = 0; + ScriptRuntime.setObjectProtoAndParent(this, scope); + } + + public String getClassName() + { + return "RegExp"; + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + return execSub(cx, scope, args, MATCH); + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + return (Scriptable)execSub(cx, scope, args, MATCH); + } + + Scriptable compile(Context cx, Scriptable scope, Object[] args) + { + if (args.length > 0 && args[0] instanceof NativeRegExp) { + if (args.length > 1 && args[1] != Undefined.instance) { + // report error + throw ScriptRuntime.typeError0("msg.bad.regexp.compile"); + } + NativeRegExp thatObj = (NativeRegExp) args[0]; + this.re = thatObj.re; + this.lastIndex = thatObj.lastIndex; + return this; + } + String s = args.length == 0 ? "" : ScriptRuntime.toString(args[0]); + String global = args.length > 1 && args[1] != Undefined.instance + ? ScriptRuntime.toString(args[1]) + : null; + this.re = (RECompiled)compileRE(cx, s, global, false); + this.lastIndex = 0; + return this; + } + + public String toString() + { + StringBuffer buf = new StringBuffer(); + buf.append('/'); + if (re.source.length != 0) { + buf.append(re.source); + } else { + // See bugzilla 226045 + buf.append("(?:)"); + } + buf.append('/'); + if ((re.flags & JSREG_GLOB) != 0) + buf.append('g'); + if ((re.flags & JSREG_FOLD) != 0) + buf.append('i'); + if ((re.flags & JSREG_MULTILINE) != 0) + buf.append('m'); + return buf.toString(); + } + + NativeRegExp() { } + + private static RegExpImpl getImpl(Context cx) + { + return (RegExpImpl) ScriptRuntime.getRegExpProxy(cx); + } + + private Object execSub(Context cx, Scriptable scopeObj, + Object[] args, int matchType) + { + RegExpImpl reImpl = getImpl(cx); + String str; + if (args.length == 0) { + str = reImpl.input; + if (str == null) { + reportError("msg.no.re.input.for", toString()); + } + } else { + str = ScriptRuntime.toString(args[0]); + } + double d = ((re.flags & JSREG_GLOB) != 0) ? lastIndex : 0; + + Object rval; + if (d < 0 || str.length() < d) { + lastIndex = 0; + rval = null; + } + else { + int indexp[] = { (int)d }; + rval = executeRegExp(cx, scopeObj, reImpl, str, indexp, matchType); + if ((re.flags & JSREG_GLOB) != 0) { + lastIndex = (rval == null || rval == Undefined.instance) + ? 0 : indexp[0]; + } + } + return rval; + } + + static Object compileRE(Context cx, String str, String global, boolean flat) + { + RECompiled regexp = new RECompiled(); + regexp.source = str.toCharArray(); + int length = str.length(); + + int flags = 0; + if (global != null) { + for (int i = 0; i < global.length(); i++) { + char c = global.charAt(i); + if (c == 'g') { + flags |= JSREG_GLOB; + } else if (c == 'i') { + flags |= JSREG_FOLD; + } else if (c == 'm') { + flags |= JSREG_MULTILINE; + } else { + reportError("msg.invalid.re.flag", String.valueOf(c)); + } + } + } + regexp.flags = flags; + + CompilerState state = new CompilerState(cx, regexp.source, length, flags); + if (flat && length > 0) { +if (debug) { +System.out.println("flat = \"" + str + "\""); +} + state.result = new RENode(REOP_FLAT); + state.result.chr = state.cpbegin[0]; + state.result.length = length; + state.result.flatIndex = 0; + state.progLength += 5; + } + else + if (!parseDisjunction(state)) + return null; + + regexp.program = new byte[state.progLength + 1]; + if (state.classCount != 0) { + regexp.classList = new RECharSet[state.classCount]; + regexp.classCount = state.classCount; + } + int endPC = emitREBytecode(state, regexp, 0, state.result); + regexp.program[endPC++] = REOP_END; + +if (debug) { +System.out.println("Prog. length = " + endPC); +for (int i = 0; i < endPC; i++) { + System.out.print(regexp.program[i]); + if (i < (endPC - 1)) System.out.print(", "); +} +System.out.println(); +} + regexp.parenCount = state.parenCount; + + // If re starts with literal, init anchorCh accordingly + switch (regexp.program[0]) { + case REOP_UCFLAT1: + case REOP_UCFLAT1i: + regexp.anchorCh = (char)getIndex(regexp.program, 1); + break; + case REOP_FLAT1: + case REOP_FLAT1i: + regexp.anchorCh = (char)(regexp.program[1] & 0xFF); + break; + case REOP_FLAT: + case REOP_FLATi: + int k = getIndex(regexp.program, 1); + regexp.anchorCh = regexp.source[k]; + break; + } + +if (debug) { +if (regexp.anchorCh >= 0) { + System.out.println("Anchor ch = '" + (char)regexp.anchorCh + "'"); +} +} + return regexp; + } + + static boolean isDigit(char c) + { + return '0' <= c && c <= '9'; + } + + private static boolean isWord(char c) + { + return Character.isLetter(c) || isDigit(c) || c == '_'; + } + + private static boolean isLineTerm(char c) + { + return ScriptRuntime.isJSLineTerminator(c); + } + + private static boolean isREWhiteSpace(int c) + { + return (c == '\u0020' || c == '\u0009' + || c == '\n' || c == '\r' + || c == 0x2028 || c == 0x2029 + || c == '\u000C' || c == '\u000B' + || c == '\u00A0' + || Character.getType((char)c) == Character.SPACE_SEPARATOR); + } + + /* + * + * 1. If IgnoreCase is false, return ch. + * 2. Let u be ch converted to upper case as if by calling + * String.prototype.toUpperCase on the one-character string ch. + * 3. If u does not consist of a single character, return ch. + * 4. Let cu be u's character. + * 5. If ch's code point value is greater than or equal to decimal 128 and cu's + * code point value is less than decimal 128, then return ch. + * 6. Return cu. + */ + private static char upcase(char ch) + { + if (ch < 128) { + if ('a' <= ch && ch <= 'z') { + return (char)(ch + ('A' - 'a')); + } + return ch; + } + char cu = Character.toUpperCase(ch); + if ((ch >= 128) && (cu < 128)) return ch; + return cu; + } + + private static char downcase(char ch) + { + if (ch < 128) { + if ('A' <= ch && ch <= 'Z') { + return (char)(ch + ('a' - 'A')); + } + return ch; + } + char cl = Character.toLowerCase(ch); + if ((ch >= 128) && (cl < 128)) return ch; + return cl; + } + +/* + * Validates and converts hex ascii value. + */ + private static int toASCIIHexDigit(int c) + { + if (c < '0') + return -1; + if (c <= '9') { + return c - '0'; + } + c |= 0x20; + if ('a' <= c && c <= 'f') { + return c - 'a' + 10; + } + return -1; + } + +/* + * Top-down regular expression grammar, based closely on Perl4. + * + * regexp: altern A regular expression is one or more + * altern '|' regexp alternatives separated by vertical bar. + */ + private static boolean parseDisjunction(CompilerState state) + { + if (!parseAlternative(state)) + return false; + char[] source = state.cpbegin; + int index = state.cp; + if (index != source.length && source[index] == '|') { + RENode altResult; + ++state.cp; + altResult = new RENode(REOP_ALT); + altResult.kid = state.result; + if (!parseDisjunction(state)) + return false; + altResult.kid2 = state.result; + state.result = altResult; + /* ALT, <next>, ..., JUMP, <end> ... JUMP <end> */ + state.progLength += 9; + } + return true; + } + +/* + * altern: item An alternative is one or more items, + * item altern concatenated together. + */ + private static boolean parseAlternative(CompilerState state) + { + RENode headTerm = null; + RENode tailTerm = null; + char[] source = state.cpbegin; + while (true) { + if (state.cp == state.cpend || source[state.cp] == '|' + || (state.parenNesting != 0 && source[state.cp] == ')')) + { + if (headTerm == null) { + state.result = new RENode(REOP_EMPTY); + } + else + state.result = headTerm; + return true; + } + if (!parseTerm(state)) + return false; + if (headTerm == null) + headTerm = state.result; + else { + if (tailTerm == null) { + headTerm.next = state.result; + tailTerm = state.result; + while (tailTerm.next != null) tailTerm = tailTerm.next; + } + else { + tailTerm.next = state.result; + tailTerm = tailTerm.next; + while (tailTerm.next != null) tailTerm = tailTerm.next; + } + } + } + } + + /* calculate the total size of the bitmap required for a class expression */ + private static boolean + calculateBitmapSize(CompilerState state, RENode target, char[] src, + int index, int end) + { + char rangeStart = 0; + char c; + int n; + int nDigits; + int i; + int max = 0; + boolean inRange = false; + + target.bmsize = 0; + + if (index == end) + return true; + + if (src[index] == '^') + ++index; + + while (index != end) { + int localMax = 0; + nDigits = 2; + switch (src[index]) { + case '\\': + ++index; + c = src[index++]; + switch (c) { + case 'b': + localMax = 0x8; + break; + case 'f': + localMax = 0xC; + break; + case 'n': + localMax = 0xA; + break; + case 'r': + localMax = 0xD; + break; + case 't': + localMax = 0x9; + break; + case 'v': + localMax = 0xB; + break; + case 'c': + if (((index + 1) < end) && Character.isLetter(src[index + 1])) + localMax = (char)(src[index++] & 0x1F); + else + localMax = '\\'; + break; + case 'u': + nDigits += 2; + // fall thru... + case 'x': + n = 0; + for (i = 0; (i < nDigits) && (index < end); i++) { + c = src[index++]; + n = Kit.xDigitToInt(c, n); + if (n < 0) { + // Back off to accepting the original + // '\' as a literal + index -= (i + 1); + n = '\\'; + break; + } + } + localMax = n; + break; + case 'd': + if (inRange) { + reportError("msg.bad.range", ""); + return false; + } + localMax = '9'; + break; + case 'D': + case 's': + case 'S': + case 'w': + case 'W': + if (inRange) { + reportError("msg.bad.range", ""); + return false; + } + target.bmsize = 65535; + return true; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + /* + * This is a non-ECMA extension - decimal escapes (in this + * case, octal!) are supposed to be an error inside class + * ranges, but supported here for backwards compatibility. + * + */ + n = (c - '0'); + c = src[index]; + if ('0' <= c && c <= '7') { + index++; + n = 8 * n + (c - '0'); + c = src[index]; + if ('0' <= c && c <= '7') { + index++; + i = 8 * n + (c - '0'); + if (i <= 0377) + n = i; + else + index--; + } + } + localMax = n; + break; + + default: + localMax = c; + break; + } + break; + default: + localMax = src[index++]; + break; + } + if (inRange) { + if (rangeStart > localMax) { + reportError("msg.bad.range", ""); + return false; + } + inRange = false; + } + else { + if (index < (end - 1)) { + if (src[index] == '-') { + ++index; + inRange = true; + rangeStart = (char)localMax; + continue; + } + } + } + if ((state.flags & JSREG_FOLD) != 0){ + char cu = upcase((char)localMax); + char cd = downcase((char)localMax); + localMax = (cu >= cd) ? cu : cd; + } + if (localMax > max) + max = localMax; + } + target.bmsize = max; + return true; + } + + /* + * item: assertion An item is either an assertion or + * quantatom a quantified atom. + * + * assertion: '^' Assertions match beginning of string + * (or line if the class static property + * RegExp.multiline is true). + * '$' End of string (or line if the class + * static property RegExp.multiline is + * true). + * '\b' Word boundary (between \w and \W). + * '\B' Word non-boundary. + * + * quantatom: atom An unquantified atom. + * quantatom '{' n ',' m '}' + * Atom must occur between n and m times. + * quantatom '{' n ',' '}' Atom must occur at least n times. + * quantatom '{' n '}' Atom must occur exactly n times. + * quantatom '*' Zero or more times (same as {0,}). + * quantatom '+' One or more times (same as {1,}). + * quantatom '?' Zero or one time (same as {0,1}). + * + * any of which can be optionally followed by '?' for ungreedy + * + * atom: '(' regexp ')' A parenthesized regexp (what matched + * can be addressed using a backreference, + * see '\' n below). + * '.' Matches any char except '\n'. + * '[' classlist ']' A character class. + * '[' '^' classlist ']' A negated character class. + * '\f' Form Feed. + * '\n' Newline (Line Feed). + * '\r' Carriage Return. + * '\t' Horizontal Tab. + * '\v' Vertical Tab. + * '\d' A digit (same as [0-9]). + * '\D' A non-digit. + * '\w' A word character, [0-9a-z_A-Z]. + * '\W' A non-word character. + * '\s' A whitespace character, [ \b\f\n\r\t\v]. + * '\S' A non-whitespace character. + * '\' n A backreference to the nth (n decimal + * and positive) parenthesized expression. + * '\' octal An octal escape sequence (octal must be + * two or three digits long, unless it is + * 0 for the null character). + * '\x' hex A hex escape (hex must be two digits). + * '\c' ctrl A control character, ctrl is a letter. + * '\' literalatomchar Any character except one of the above + * that follow '\' in an atom. + * otheratomchar Any character not first among the other + * atom right-hand sides. + */ + + private static void doFlat(CompilerState state, char c) + { + state.result = new RENode(REOP_FLAT); + state.result.chr = c; + state.result.length = 1; + state.result.flatIndex = -1; + state.progLength += 3; + } + + private static int + getDecimalValue(char c, CompilerState state, int maxValue, + String overflowMessageId) + { + boolean overflow = false; + int start = state.cp; + char[] src = state.cpbegin; + int value = c - '0'; + for (; state.cp != state.cpend; ++state.cp) { + c = src[state.cp]; + if (!isDigit(c)) { + break; + } + if (!overflow) { + int digit = c - '0'; + if (value < (maxValue - digit) / 10) { + value = value * 10 + digit; + } else { + overflow = true; + value = maxValue; + } + } + } + if (overflow) { + reportError(overflowMessageId, + String.valueOf(src, start, state.cp - start)); + } + return value; + } + + private static boolean + parseTerm(CompilerState state) + { + char[] src = state.cpbegin; + char c = src[state.cp++]; + int nDigits = 2; + int parenBaseCount = state.parenCount; + int num, tmp; + RENode term; + int termStart; + + switch (c) { + /* assertions and atoms */ + case '^': + state.result = new RENode(REOP_BOL); + state.progLength++; + return true; + case '$': + state.result = new RENode(REOP_EOL); + state.progLength++; + return true; + case '\\': + if (state.cp < state.cpend) { + c = src[state.cp++]; + switch (c) { + /* assertion escapes */ + case 'b' : + state.result = new RENode(REOP_WBDRY); + state.progLength++; + return true; + case 'B': + state.result = new RENode(REOP_WNONBDRY); + state.progLength++; + return true; + /* Decimal escape */ + case '0': +/* + * Under 'strict' ECMA 3, we interpret \0 as NUL and don't accept octal. + * However, (XXX and since Rhino doesn't have a 'strict' mode) we'll just + * behave the old way for compatibility reasons. + * (see http://bugzilla.mozilla.org/show_bug.cgi?id=141078) + * + */ + reportWarning(state.cx, "msg.bad.backref", ""); + /* octal escape */ + num = 0; + while (state.cp < state.cpend) { + c = src[state.cp]; + if ((c >= '0') && (c <= '7')) { + state.cp++; + tmp = 8 * num + (c - '0'); + if (tmp > 0377) + break; + num = tmp; + } + else + break; + } + c = (char)(num); + doFlat(state, c); + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + termStart = state.cp - 1; + num = getDecimalValue(c, state, 0xFFFF, + "msg.overlarge.backref"); + if (num > state.parenCount) + reportWarning(state.cx, "msg.bad.backref", ""); + /* + * n > 9 or > count of parentheses, + * then treat as octal instead. + */ + if ((num > 9) && (num > state.parenCount)) { + state.cp = termStart; + num = 0; + while (state.cp < state.cpend) { + c = src[state.cp]; + if ((c >= '0') && (c <= '7')) { + state.cp++; + tmp = 8 * num + (c - '0'); + if (tmp > 0377) + break; + num = tmp; + } + else + break; + } + c = (char)(num); + doFlat(state, c); + break; + } + /* otherwise, it's a back-reference */ + state.result = new RENode(REOP_BACKREF); + state.result.parenIndex = num - 1; + state.progLength += 3; + break; + /* Control escape */ + case 'f': + c = 0xC; + doFlat(state, c); + break; + case 'n': + c = 0xA; + doFlat(state, c); + break; + case 'r': + c = 0xD; + doFlat(state, c); + break; + case 't': + c = 0x9; + doFlat(state, c); + break; + case 'v': + c = 0xB; + doFlat(state, c); + break; + /* Control letter */ + case 'c': + if (((state.cp + 1) < state.cpend) && + Character.isLetter(src[state.cp + 1])) + c = (char)(src[state.cp++] & 0x1F); + else { + /* back off to accepting the original '\' as a literal */ + --state.cp; + c = '\\'; + } + doFlat(state, c); + break; + /* UnicodeEscapeSequence */ + case 'u': + nDigits += 2; + // fall thru... + /* HexEscapeSequence */ + case 'x': + { + int n = 0; + int i; + for (i = 0; (i < nDigits) + && (state.cp < state.cpend); i++) { + c = src[state.cp++]; + n = Kit.xDigitToInt(c, n); + if (n < 0) { + // Back off to accepting the original + // 'u' or 'x' as a literal + state.cp -= (i + 2); + n = src[state.cp++]; + break; + } + } + c = (char)(n); + } + doFlat(state, c); + break; + /* Character class escapes */ + case 'd': + state.result = new RENode(REOP_DIGIT); + state.progLength++; + break; + case 'D': + state.result = new RENode(REOP_NONDIGIT); + state.progLength++; + break; + case 's': + state.result = new RENode(REOP_SPACE); + state.progLength++; + break; + case 'S': + state.result = new RENode(REOP_NONSPACE); + state.progLength++; + break; + case 'w': + state.result = new RENode(REOP_ALNUM); + state.progLength++; + break; + case 'W': + state.result = new RENode(REOP_NONALNUM); + state.progLength++; + break; + /* IdentityEscape */ + default: + state.result = new RENode(REOP_FLAT); + state.result.chr = c; + state.result.length = 1; + state.result.flatIndex = state.cp - 1; + state.progLength += 3; + break; + } + break; + } + else { + /* a trailing '\' is an error */ + reportError("msg.trail.backslash", ""); + return false; + } + case '(': { + RENode result = null; + termStart = state.cp; + if (state.cp + 1 < state.cpend && src[state.cp] == '?' + && ((c = src[state.cp + 1]) == '=' || c == '!' || c == ':')) + { + state.cp += 2; + if (c == '=') { + result = new RENode(REOP_ASSERT); + /* ASSERT, <next>, ... ASSERTTEST */ + state.progLength += 4; + } else if (c == '!') { + result = new RENode(REOP_ASSERT_NOT); + /* ASSERTNOT, <next>, ... ASSERTNOTTEST */ + state.progLength += 4; + } + } else { + result = new RENode(REOP_LPAREN); + /* LPAREN, <index>, ... RPAREN, <index> */ + state.progLength += 6; + result.parenIndex = state.parenCount++; + } + ++state.parenNesting; + if (!parseDisjunction(state)) + return false; + if (state.cp == state.cpend || src[state.cp] != ')') { + reportError("msg.unterm.paren", "in regular expression"/*APPJET*/); + return false; + } + ++state.cp; + --state.parenNesting; + if (result != null) { + result.kid = state.result; + state.result = result; + } + break; + } + case ')': + reportError("msg.re.unmatched.right.paren", ""); + return false; + case '[': + state.result = new RENode(REOP_CLASS); + termStart = state.cp; + state.result.startIndex = termStart; + while (true) { + if (state.cp == state.cpend) { + reportError("msg.unterm.class", ""); + return false; + } + if (src[state.cp] == '\\') + state.cp++; + else { + if (src[state.cp] == ']') { + state.result.kidlen = state.cp - termStart; + break; + } + } + state.cp++; + } + state.result.index = state.classCount++; + /* + * Call calculateBitmapSize now as we want any errors it finds + * to be reported during the parse phase, not at execution. + */ + if (!calculateBitmapSize(state, state.result, src, termStart, state.cp++)) + return false; + state.progLength += 3; /* CLASS, <index> */ + break; + + case '.': + state.result = new RENode(REOP_DOT); + state.progLength++; + break; + case '*': + case '+': + case '?': + reportError("msg.bad.quant", String.valueOf(src[state.cp - 1])); + return false; + default: + state.result = new RENode(REOP_FLAT); + state.result.chr = c; + state.result.length = 1; + state.result.flatIndex = state.cp - 1; + state.progLength += 3; + break; + } + + term = state.result; + if (state.cp == state.cpend) { + return true; + } + boolean hasQ = false; + switch (src[state.cp]) { + case '+': + state.result = new RENode(REOP_QUANT); + state.result.min = 1; + state.result.max = -1; + /* <PLUS>, <parencount>, <parenindex>, <next> ... <ENDCHILD> */ + state.progLength += 8; + hasQ = true; + break; + case '*': + state.result = new RENode(REOP_QUANT); + state.result.min = 0; + state.result.max = -1; + /* <STAR>, <parencount>, <parenindex>, <next> ... <ENDCHILD> */ + state.progLength += 8; + hasQ = true; + break; + case '?': + state.result = new RENode(REOP_QUANT); + state.result.min = 0; + state.result.max = 1; + /* <OPT>, <parencount>, <parenindex>, <next> ... <ENDCHILD> */ + state.progLength += 8; + hasQ = true; + break; + case '{': /* balance '}' */ + { + int min = 0; + int max = -1; + int leftCurl = state.cp; + + /* For Perl etc. compatibility, if quntifier does not match + * \{\d+(,\d*)?\} exactly back off from it + * being a quantifier, and chew it up as a literal + * atom next time instead. + */ + + c = src[++state.cp]; + if (isDigit(c)) { + ++state.cp; + min = getDecimalValue(c, state, 0xFFFF, + "msg.overlarge.min"); + c = src[state.cp]; + if (c == ',') { + c = src[++state.cp]; + if (isDigit(c)) { + ++state.cp; + max = getDecimalValue(c, state, 0xFFFF, + "msg.overlarge.max"); + c = src[state.cp]; + if (min > max) { + reportError("msg.max.lt.min", + String.valueOf(src[state.cp])); + return false; + } + } + } else { + max = min; + } + /* balance '{' */ + if (c == '}') { + state.result = new RENode(REOP_QUANT); + state.result.min = min; + state.result.max = max; + // QUANT, <min>, <max>, <parencount>, + // <parenindex>, <next> ... <ENDCHILD> + state.progLength += 12; + hasQ = true; + } + } + if (!hasQ) { + state.cp = leftCurl; + } + break; + } + } + if (!hasQ) + return true; + + ++state.cp; + state.result.kid = term; + state.result.parenIndex = parenBaseCount; + state.result.parenCount = state.parenCount - parenBaseCount; + if ((state.cp < state.cpend) && (src[state.cp] == '?')) { + ++state.cp; + state.result.greedy = false; + } + else + state.result.greedy = true; + return true; + } + + private static void resolveForwardJump(byte[] array, int from, int pc) + { + if (from > pc) throw Kit.codeBug(); + addIndex(array, from, pc - from); + } + + private static int getOffset(byte[] array, int pc) + { + return getIndex(array, pc); + } + + private static int addIndex(byte[] array, int pc, int index) + { + if (index < 0) throw Kit.codeBug(); + if (index > 0xFFFF) + throw Context.reportRuntimeError("Too complex regexp"); + array[pc] = (byte)(index >> 8); + array[pc + 1] = (byte)(index); + return pc + 2; + } + + private static int getIndex(byte[] array, int pc) + { + return ((array[pc] & 0xFF) << 8) | (array[pc + 1] & 0xFF); + } + + private static final int OFFSET_LEN = 2; + private static final int INDEX_LEN = 2; + + private static int + emitREBytecode(CompilerState state, RECompiled re, int pc, RENode t) + { + RENode nextAlt; + int nextAltFixup, nextTermFixup; + byte[] program = re.program; + + while (t != null) { + program[pc++] = t.op; + switch (t.op) { + case REOP_EMPTY: + --pc; + break; + case REOP_ALT: + nextAlt = t.kid2; + nextAltFixup = pc; /* address of next alternate */ + pc += OFFSET_LEN; + pc = emitREBytecode(state, re, pc, t.kid); + program[pc++] = REOP_JUMP; + nextTermFixup = pc; /* address of following term */ + pc += OFFSET_LEN; + resolveForwardJump(program, nextAltFixup, pc); + pc = emitREBytecode(state, re, pc, nextAlt); + + program[pc++] = REOP_JUMP; + nextAltFixup = pc; + pc += OFFSET_LEN; + + resolveForwardJump(program, nextTermFixup, pc); + resolveForwardJump(program, nextAltFixup, pc); + break; + case REOP_FLAT: + /* + * Consecutize FLAT's if possible. + */ + if (t.flatIndex != -1) { + while ((t.next != null) && (t.next.op == REOP_FLAT) + && ((t.flatIndex + t.length) + == t.next.flatIndex)) { + t.length += t.next.length; + t.next = t.next.next; + } + } + if ((t.flatIndex != -1) && (t.length > 1)) { + if ((state.flags & JSREG_FOLD) != 0) + program[pc - 1] = REOP_FLATi; + else + program[pc - 1] = REOP_FLAT; + pc = addIndex(program, pc, t.flatIndex); + pc = addIndex(program, pc, t.length); + } + else { + if (t.chr < 256) { + if ((state.flags & JSREG_FOLD) != 0) + program[pc - 1] = REOP_FLAT1i; + else + program[pc - 1] = REOP_FLAT1; + program[pc++] = (byte)(t.chr); + } + else { + if ((state.flags & JSREG_FOLD) != 0) + program[pc - 1] = REOP_UCFLAT1i; + else + program[pc - 1] = REOP_UCFLAT1; + pc = addIndex(program, pc, t.chr); + } + } + break; + case REOP_LPAREN: + pc = addIndex(program, pc, t.parenIndex); + pc = emitREBytecode(state, re, pc, t.kid); + program[pc++] = REOP_RPAREN; + pc = addIndex(program, pc, t.parenIndex); + break; + case REOP_BACKREF: + pc = addIndex(program, pc, t.parenIndex); + break; + case REOP_ASSERT: + nextTermFixup = pc; + pc += OFFSET_LEN; + pc = emitREBytecode(state, re, pc, t.kid); + program[pc++] = REOP_ASSERTTEST; + resolveForwardJump(program, nextTermFixup, pc); + break; + case REOP_ASSERT_NOT: + nextTermFixup = pc; + pc += OFFSET_LEN; + pc = emitREBytecode(state, re, pc, t.kid); + program[pc++] = REOP_ASSERTNOTTEST; + resolveForwardJump(program, nextTermFixup, pc); + break; + case REOP_QUANT: + if ((t.min == 0) && (t.max == -1)) + program[pc - 1] = (t.greedy) ? REOP_STAR : REOP_MINIMALSTAR; + else + if ((t.min == 0) && (t.max == 1)) + program[pc - 1] = (t.greedy) ? REOP_OPT : REOP_MINIMALOPT; + else + if ((t.min == 1) && (t.max == -1)) + program[pc - 1] = (t.greedy) ? REOP_PLUS : REOP_MINIMALPLUS; + else { + if (!t.greedy) program[pc - 1] = REOP_MINIMALQUANT; + pc = addIndex(program, pc, t.min); + // max can be -1 which addIndex does not accept + pc = addIndex(program, pc, t.max + 1); + } + pc = addIndex(program, pc, t.parenCount); + pc = addIndex(program, pc, t.parenIndex); + nextTermFixup = pc; + pc += OFFSET_LEN; + pc = emitREBytecode(state, re, pc, t.kid); + program[pc++] = REOP_ENDCHILD; + resolveForwardJump(program, nextTermFixup, pc); + break; + case REOP_CLASS: + pc = addIndex(program, pc, t.index); + re.classList[t.index] = new RECharSet(t.bmsize, t.startIndex, + t.kidlen); + break; + default: + break; + } + t = t.next; + } + return pc; + } + + private static void + pushProgState(REGlobalData gData, int min, int max, + REBackTrackData backTrackLastToSave, + int continuation_pc, int continuation_op) + { + gData.stateStackTop = new REProgState(gData.stateStackTop, min, max, + gData.cp, backTrackLastToSave, + continuation_pc, + continuation_op); + } + + private static REProgState + popProgState(REGlobalData gData) + { + REProgState state = gData.stateStackTop; + gData.stateStackTop = state.previous; + return state; + } + + private static void + pushBackTrackState(REGlobalData gData, byte op, int target) + { + gData.backTrackStackTop = new REBackTrackData(gData, op, target); + } + + /* + * Consecutive literal characters. + */ + private static boolean + flatNMatcher(REGlobalData gData, int matchChars, + int length, char[] chars, int end) + { + if ((gData.cp + length) > end) + return false; + for (int i = 0; i < length; i++) { + if (gData.regexp.source[matchChars + i] != chars[gData.cp + i]) { + return false; + } + } + gData.cp += length; + return true; + } + + private static boolean + flatNIMatcher(REGlobalData gData, int matchChars, + int length, char[] chars, int end) + { + if ((gData.cp + length) > end) + return false; + for (int i = 0; i < length; i++) { + if (upcase(gData.regexp.source[matchChars + i]) + != upcase(chars[gData.cp + i])) + { + return false; + } + } + gData.cp += length; + return true; + } + + /* + 1. Evaluate DecimalEscape to obtain an EscapeValue E. + 2. If E is not a character then go to step 6. + 3. Let ch be E's character. + 4. Let A be a one-element RECharSet containing the character ch. + 5. Call CharacterSetMatcher(A, false) and return its Matcher result. + 6. E must be an integer. Let n be that integer. + 7. If n=0 or n>NCapturingParens then throw a SyntaxError exception. + 8. Return an internal Matcher closure that takes two arguments, a State x + and a Continuation c, and performs the following: + 1. Let cap be x's captures internal array. + 2. Let s be cap[n]. + 3. If s is undefined, then call c(x) and return its result. + 4. Let e be x's endIndex. + 5. Let len be s's length. + 6. Let f be e+len. + 7. If f>InputLength, return failure. + 8. If there exists an integer i between 0 (inclusive) and len (exclusive) + such that Canonicalize(s[i]) is not the same character as + Canonicalize(Input [e+i]), then return failure. + 9. Let y be the State (f, cap). + 10. Call c(y) and return its result. + */ + private static boolean + backrefMatcher(REGlobalData gData, int parenIndex, + char[] chars, int end) + { + int len; + int i; + int parenContent = gData.parens_index(parenIndex); + if (parenContent == -1) + return true; + + len = gData.parens_length(parenIndex); + if ((gData.cp + len) > end) + return false; + + if ((gData.regexp.flags & JSREG_FOLD) != 0) { + for (i = 0; i < len; i++) { + if (upcase(chars[parenContent + i]) != upcase(chars[gData.cp + i])) + return false; + } + } + else { + for (i = 0; i < len; i++) { + if (chars[parenContent + i] != chars[gData.cp + i]) + return false; + } + } + gData.cp += len; + return true; + } + + + /* Add a single character to the RECharSet */ + private static void + addCharacterToCharSet(RECharSet cs, char c) + { + int byteIndex = (c / 8); + if (c > cs.length) + throw new RuntimeException(); + cs.bits[byteIndex] |= 1 << (c & 0x7); + } + + + /* Add a character range, c1 to c2 (inclusive) to the RECharSet */ + private static void + addCharacterRangeToCharSet(RECharSet cs, char c1, char c2) + { + int i; + + int byteIndex1 = (c1 / 8); + int byteIndex2 = (c2 / 8); + + if ((c2 > cs.length) || (c1 > c2)) + throw new RuntimeException(); + + c1 &= 0x7; + c2 &= 0x7; + + if (byteIndex1 == byteIndex2) { + cs.bits[byteIndex1] |= ((0xFF) >> (7 - (c2 - c1))) << c1; + } + else { + cs.bits[byteIndex1] |= 0xFF << c1; + for (i = byteIndex1 + 1; i < byteIndex2; i++) + cs.bits[i] = (byte)0xFF; + cs.bits[byteIndex2] |= (0xFF) >> (7 - c2); + } + } + + /* Compile the source of the class into a RECharSet */ + private static void + processCharSet(REGlobalData gData, RECharSet charSet) + { + synchronized (charSet) { + if (!charSet.converted) { + processCharSetImpl(gData, charSet); + charSet.converted = true; + } + } + } + + + private static void + processCharSetImpl(REGlobalData gData, RECharSet charSet) + { + int src = charSet.startIndex; + int end = src + charSet.strlength; + + char rangeStart = 0, thisCh; + int byteLength; + char c; + int n; + int nDigits; + int i; + boolean inRange = false; + + charSet.sense = true; + byteLength = (charSet.length / 8) + 1; + charSet.bits = new byte[byteLength]; + + if (src == end) + return; + + if (gData.regexp.source[src] == '^') { + charSet.sense = false; + ++src; + } + + while (src != end) { + nDigits = 2; + switch (gData.regexp.source[src]) { + case '\\': + ++src; + c = gData.regexp.source[src++]; + switch (c) { + case 'b': + thisCh = 0x8; + break; + case 'f': + thisCh = 0xC; + break; + case 'n': + thisCh = 0xA; + break; + case 'r': + thisCh = 0xD; + break; + case 't': + thisCh = 0x9; + break; + case 'v': + thisCh = 0xB; + break; + case 'c': + if (((src + 1) < end) && isWord(gData.regexp.source[src + 1])) + thisCh = (char)(gData.regexp.source[src++] & 0x1F); + else { + --src; + thisCh = '\\'; + } + break; + case 'u': + nDigits += 2; + // fall thru + case 'x': + n = 0; + for (i = 0; (i < nDigits) && (src < end); i++) { + c = gData.regexp.source[src++]; + int digit = toASCIIHexDigit(c); + if (digit < 0) { + /* back off to accepting the original '\' + * as a literal + */ + src -= (i + 1); + n = '\\'; + break; + } + n = (n << 4) | digit; + } + thisCh = (char)(n); + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + /* + * This is a non-ECMA extension - decimal escapes (in this + * case, octal!) are supposed to be an error inside class + * ranges, but supported here for backwards compatibility. + * + */ + n = (c - '0'); + c = gData.regexp.source[src]; + if ('0' <= c && c <= '7') { + src++; + n = 8 * n + (c - '0'); + c = gData.regexp.source[src]; + if ('0' <= c && c <= '7') { + src++; + i = 8 * n + (c - '0'); + if (i <= 0377) + n = i; + else + src--; + } + } + thisCh = (char)(n); + break; + + case 'd': + addCharacterRangeToCharSet(charSet, '0', '9'); + continue; /* don't need range processing */ + case 'D': + addCharacterRangeToCharSet(charSet, (char)0, (char)('0' - 1)); + addCharacterRangeToCharSet(charSet, (char)('9' + 1), + (char)(charSet.length)); + continue; + case 's': + for (i = charSet.length; i >= 0; i--) + if (isREWhiteSpace(i)) + addCharacterToCharSet(charSet, (char)(i)); + continue; + case 'S': + for (i = charSet.length; i >= 0; i--) + if (!isREWhiteSpace(i)) + addCharacterToCharSet(charSet, (char)(i)); + continue; + case 'w': + for (i = charSet.length; i >= 0; i--) + if (isWord((char)i)) + addCharacterToCharSet(charSet, (char)(i)); + continue; + case 'W': + for (i = charSet.length; i >= 0; i--) + if (!isWord((char)i)) + addCharacterToCharSet(charSet, (char)(i)); + continue; + default: + thisCh = c; + break; + + } + break; + + default: + thisCh = gData.regexp.source[src++]; + break; + + } + if (inRange) { + if ((gData.regexp.flags & JSREG_FOLD) != 0) { + addCharacterRangeToCharSet(charSet, + upcase(rangeStart), + upcase(thisCh)); + addCharacterRangeToCharSet(charSet, + downcase(rangeStart), + downcase(thisCh)); + } else { + addCharacterRangeToCharSet(charSet, rangeStart, thisCh); + } + inRange = false; + } + else { + if ((gData.regexp.flags & JSREG_FOLD) != 0) { + addCharacterToCharSet(charSet, upcase(thisCh)); + addCharacterToCharSet(charSet, downcase(thisCh)); + } else { + addCharacterToCharSet(charSet, thisCh); + } + if (src < (end - 1)) { + if (gData.regexp.source[src] == '-') { + ++src; + inRange = true; + rangeStart = thisCh; + } + } + } + } + } + + + /* + * Initialize the character set if it this is the first call. + * Test the bit - if the ^ flag was specified, non-inclusion is a success + */ + private static boolean + classMatcher(REGlobalData gData, RECharSet charSet, char ch) + { + if (!charSet.converted) { + processCharSet(gData, charSet); + } + + int byteIndex = ch / 8; + if (charSet.sense) { + if ((charSet.length == 0) || + ( (ch > charSet.length) + || ((charSet.bits[byteIndex] & (1 << (ch & 0x7))) == 0) )) + return false; + } else { + if (! ((charSet.length == 0) || + ( (ch > charSet.length) + || ((charSet.bits[byteIndex] & (1 << (ch & 0x7))) == 0) ))) + return false; + } + return true; + } + + private static boolean + executeREBytecode(REGlobalData gData, char[] chars, int end) + { + int pc = 0; + byte program[] = gData.regexp.program; + int currentContinuation_op; + int currentContinuation_pc; + boolean result = false; + + currentContinuation_pc = 0; + currentContinuation_op = REOP_END; +if (debug) { +System.out.println("Input = \"" + new String(chars) + "\", start at " + gData.cp); +} + int op = program[pc++]; + for (;;) { +if (debug) { +System.out.println("Testing at " + gData.cp + ", op = " + op); +} + switch (op) { + case REOP_EMPTY: + result = true; + break; + case REOP_BOL: + if (gData.cp != 0) { + if (gData.multiline || + ((gData.regexp.flags & JSREG_MULTILINE) != 0)) { + if (!isLineTerm(chars[gData.cp - 1])) { + result = false; + break; + } + } + else { + result = false; + break; + } + } + result = true; + break; + case REOP_EOL: + if (gData.cp != end) { + if (gData.multiline || + ((gData.regexp.flags & JSREG_MULTILINE) != 0)) { + if (!isLineTerm(chars[gData.cp])) { + result = false; + break; + } + } + else { + result = false; + break; + } + } + result = true; + break; + case REOP_WBDRY: + result = ((gData.cp == 0 || !isWord(chars[gData.cp - 1])) + ^ !((gData.cp < end) && isWord(chars[gData.cp]))); + break; + case REOP_WNONBDRY: + result = ((gData.cp == 0 || !isWord(chars[gData.cp - 1])) + ^ ((gData.cp < end) && isWord(chars[gData.cp]))); + break; + case REOP_DOT: + result = (gData.cp != end && !isLineTerm(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_DIGIT: + result = (gData.cp != end && isDigit(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_NONDIGIT: + result = (gData.cp != end && !isDigit(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_SPACE: + result = (gData.cp != end && isREWhiteSpace(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_NONSPACE: + result = (gData.cp != end && !isREWhiteSpace(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_ALNUM: + result = (gData.cp != end && isWord(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_NONALNUM: + result = (gData.cp != end && !isWord(chars[gData.cp])); + if (result) { + gData.cp++; + } + break; + case REOP_FLAT: + { + int offset = getIndex(program, pc); + pc += INDEX_LEN; + int length = getIndex(program, pc); + pc += INDEX_LEN; + result = flatNMatcher(gData, offset, length, chars, end); + } + break; + case REOP_FLATi: + { + int offset = getIndex(program, pc); + pc += INDEX_LEN; + int length = getIndex(program, pc); + pc += INDEX_LEN; + result = flatNIMatcher(gData, offset, length, chars, end); + } + break; + case REOP_FLAT1: + { + char matchCh = (char)(program[pc++] & 0xFF); + result = (gData.cp != end && chars[gData.cp] == matchCh); + if (result) { + gData.cp++; + } + } + break; + case REOP_FLAT1i: + { + char matchCh = (char)(program[pc++] & 0xFF); + result = (gData.cp != end + && upcase(chars[gData.cp]) == upcase(matchCh)); + if (result) { + gData.cp++; + } + } + break; + case REOP_UCFLAT1: + { + char matchCh = (char)getIndex(program, pc); + pc += INDEX_LEN; + result = (gData.cp != end && chars[gData.cp] == matchCh); + if (result) { + gData.cp++; + } + } + break; + case REOP_UCFLAT1i: + { + char matchCh = (char)getIndex(program, pc); + pc += INDEX_LEN; + result = (gData.cp != end + && upcase(chars[gData.cp]) == upcase(matchCh)); + if (result) { + gData.cp++; + } + } + break; + case REOP_ALT: + { + int nextpc; + byte nextop; + pushProgState(gData, 0, 0, null, + currentContinuation_pc, + currentContinuation_op); + nextpc = pc + getOffset(program, pc); + nextop = program[nextpc++]; + pushBackTrackState(gData, nextop, nextpc); + pc += INDEX_LEN; + op = program[pc++]; + } + continue; + + case REOP_JUMP: + { + int offset; + REProgState state = popProgState(gData); + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + offset = getOffset(program, pc); + pc += offset; + op = program[pc++]; + } + continue; + + + case REOP_LPAREN: + { + int parenIndex = getIndex(program, pc); + pc += INDEX_LEN; + gData.set_parens(parenIndex, gData.cp, 0); + op = program[pc++]; + } + continue; + case REOP_RPAREN: + { + int cap_index; + int parenIndex = getIndex(program, pc); + pc += INDEX_LEN; + cap_index = gData.parens_index(parenIndex); + gData.set_parens(parenIndex, cap_index, + gData.cp - cap_index); + if (parenIndex > gData.lastParen) + gData.lastParen = parenIndex; + op = program[pc++]; + } + continue; + case REOP_BACKREF: + { + int parenIndex = getIndex(program, pc); + pc += INDEX_LEN; + result = backrefMatcher(gData, parenIndex, chars, end); + } + break; + + case REOP_CLASS: + { + int index = getIndex(program, pc); + pc += INDEX_LEN; + if (gData.cp != end) { + if (classMatcher(gData, gData.regexp.classList[index], + chars[gData.cp])) + { + gData.cp++; + result = true; + break; + } + } + result = false; + } + break; + + case REOP_ASSERT: + case REOP_ASSERT_NOT: + { + byte testOp; + pushProgState(gData, 0, 0, gData.backTrackStackTop, + currentContinuation_pc, + currentContinuation_op); + if (op == REOP_ASSERT) { + testOp = REOP_ASSERTTEST; + } else { + testOp = REOP_ASSERTNOTTEST; + } + pushBackTrackState(gData, testOp, + pc + getOffset(program, pc)); + pc += INDEX_LEN; + op = program[pc++]; + } + continue; + + case REOP_ASSERTTEST: + case REOP_ASSERTNOTTEST: + { + REProgState state = popProgState(gData); + gData.cp = state.index; + gData.backTrackStackTop = state.backTrack; + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + if (result) { + if (op == REOP_ASSERTTEST) { + result = true; + } else { + result = false; + } + } else { + if (op == REOP_ASSERTTEST) { + // Do nothing + } else { + result = true; + } + } + } + break; + + case REOP_STAR: + case REOP_PLUS: + case REOP_OPT: + case REOP_QUANT: + case REOP_MINIMALSTAR: + case REOP_MINIMALPLUS: + case REOP_MINIMALOPT: + case REOP_MINIMALQUANT: + { + int min, max; + boolean greedy = false; + switch (op) { + case REOP_STAR: + greedy = true; + // fallthrough + case REOP_MINIMALSTAR: + min = 0; + max = -1; + break; + case REOP_PLUS: + greedy = true; + // fallthrough + case REOP_MINIMALPLUS: + min = 1; + max = -1; + break; + case REOP_OPT: + greedy = true; + // fallthrough + case REOP_MINIMALOPT: + min = 0; + max = 1; + break; + case REOP_QUANT: + greedy = true; + // fallthrough + case REOP_MINIMALQUANT: + min = getOffset(program, pc); + pc += INDEX_LEN; + // See comments in emitREBytecode for " - 1" reason + max = getOffset(program, pc) - 1; + pc += INDEX_LEN; + break; + default: + throw Kit.codeBug(); + } + pushProgState(gData, min, max, null, + currentContinuation_pc, + currentContinuation_op); + if (greedy) { + currentContinuation_op = REOP_REPEAT; + currentContinuation_pc = pc; + pushBackTrackState(gData, REOP_REPEAT, pc); + /* Step over <parencount>, <parenindex> & <next> */ + pc += 3 * INDEX_LEN; + op = program[pc++]; + } else { + if (min != 0) { + currentContinuation_op = REOP_MINIMALREPEAT; + currentContinuation_pc = pc; + /* <parencount> <parenindex> & <next> */ + pc += 3 * INDEX_LEN; + op = program[pc++]; + } else { + pushBackTrackState(gData, REOP_MINIMALREPEAT, pc); + popProgState(gData); + pc += 2 * INDEX_LEN; // <parencount> & <parenindex> + pc = pc + getOffset(program, pc); + op = program[pc++]; + } + } + } + continue; + + case REOP_ENDCHILD: + // Use the current continuation. + pc = currentContinuation_pc; + op = currentContinuation_op; + continue; + + case REOP_REPEAT: + { + REProgState state = popProgState(gData); + if (!result) { + // + // There's been a failure, see if we have enough + // children. + // + if (state.min == 0) + result = true; + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + pc += 2 * INDEX_LEN; /* <parencount> & <parenindex> */ + pc = pc + getOffset(program, pc); + break; + } + else { + if (state.min == 0 && gData.cp == state.index) { + // matched an empty string, that'll get us nowhere + result = false; + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + pc += 2 * INDEX_LEN; + pc = pc + getOffset(program, pc); + break; + } + int new_min = state.min, new_max = state.max; + if (new_min != 0) new_min--; + if (new_max != -1) new_max--; + if (new_max == 0) { + result = true; + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + pc += 2 * INDEX_LEN; + pc = pc + getOffset(program, pc); + break; + } + pushProgState(gData, new_min, new_max, null, + state.continuation_pc, + state.continuation_op); + currentContinuation_op = REOP_REPEAT; + currentContinuation_pc = pc; + pushBackTrackState(gData, REOP_REPEAT, pc); + int parenCount = getIndex(program, pc); + pc += INDEX_LEN; + int parenIndex = getIndex(program, pc); + pc += 2 * INDEX_LEN; + op = program[pc++]; + for (int k = 0; k < parenCount; k++) { + gData.set_parens(parenIndex + k, -1, 0); + } + } + } + continue; + + case REOP_MINIMALREPEAT: + { + REProgState state = popProgState(gData); + if (!result) { + // + // Non-greedy failure - try to consume another child. + // + if (state.max == -1 || state.max > 0) { + pushProgState(gData, state.min, state.max, null, + state.continuation_pc, + state.continuation_op); + currentContinuation_op = REOP_MINIMALREPEAT; + currentContinuation_pc = pc; + int parenCount = getIndex(program, pc); + pc += INDEX_LEN; + int parenIndex = getIndex(program, pc); + pc += 2 * INDEX_LEN; + for (int k = 0; k < parenCount; k++) { + gData.set_parens(parenIndex + k, -1, 0); + } + op = program[pc++]; + continue; + } else { + // Don't need to adjust pc since we're going to pop. + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + break; + } + } else { + if (state.min == 0 && gData.cp == state.index) { + // Matched an empty string, that'll get us nowhere. + result = false; + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + break; + } + int new_min = state.min, new_max = state.max; + if (new_min != 0) new_min--; + if (new_max != -1) new_max--; + pushProgState(gData, new_min, new_max, null, + state.continuation_pc, + state.continuation_op); + if (new_min != 0) { + currentContinuation_op = REOP_MINIMALREPEAT; + currentContinuation_pc = pc; + int parenCount = getIndex(program, pc); + pc += INDEX_LEN; + int parenIndex = getIndex(program, pc); + pc += 2 * INDEX_LEN; + for (int k = 0; k < parenCount; k++) { + gData.set_parens(parenIndex + k, -1, 0); + } + op = program[pc++]; + } else { + currentContinuation_pc = state.continuation_pc; + currentContinuation_op = state.continuation_op; + pushBackTrackState(gData, REOP_MINIMALREPEAT, pc); + popProgState(gData); + pc += 2 * INDEX_LEN; + pc = pc + getOffset(program, pc); + op = program[pc++]; + } + continue; + } + } + + case REOP_END: + return true; + + default: + throw Kit.codeBug(); + + } + /* + * If the match failed and there's a backtrack option, take it. + * Otherwise this is a complete and utter failure. + */ + if (!result) { + REBackTrackData backTrackData = gData.backTrackStackTop; + if (backTrackData != null) { + gData.backTrackStackTop = backTrackData.previous; + + gData.lastParen = backTrackData.lastParen; + + // XXX: If backTrackData will no longer be used, then + // there is no need to clone backTrackData.parens + if (backTrackData.parens != null) { + gData.parens = backTrackData.parens.clone(); + } + + gData.cp = backTrackData.cp; + + gData.stateStackTop = backTrackData.stateStackTop; + + currentContinuation_op + = gData.stateStackTop.continuation_op; + currentContinuation_pc + = gData.stateStackTop.continuation_pc; + pc = backTrackData.continuation_pc; + op = backTrackData.continuation_op; + continue; + } + else + return false; + } + + op = program[pc++]; + } + + } + + private static boolean + matchRegExp(REGlobalData gData, RECompiled re, + char[] chars, int start, int end, boolean multiline) + { + if (re.parenCount != 0) { + gData.parens = new long[re.parenCount]; + } else { + gData.parens = null; + } + + gData.backTrackStackTop = null; + + gData.stateStackTop = null; + + gData.multiline = multiline; + gData.regexp = re; + gData.lastParen = 0; + + int anchorCh = gData.regexp.anchorCh; + // + // have to include the position beyond the last character + // in order to detect end-of-input/line condition + // + for (int i = start; i <= end; ++i) { + // + // If the first node is a literal match, step the index into + // the string until that match is made, or fail if it can't be + // found at all. + // + if (anchorCh >= 0) { + for (;;) { + if (i == end) { + return false; + } + char matchCh = chars[i]; + if (matchCh == anchorCh || + ((gData.regexp.flags & JSREG_FOLD) != 0 + && upcase(matchCh) == upcase((char)anchorCh))) + { + break; + } + ++i; + } + } + gData.cp = i; + for (int j = 0; j < re.parenCount; j++) { + gData.set_parens(j, -1, 0); + } + boolean result = executeREBytecode(gData, chars, end); + + gData.backTrackStackTop = null; + gData.stateStackTop = null; + if (result) { + gData.skipped = i - start; + return true; + } + } + return false; + } + + /* + * indexp is assumed to be an array of length 1 + */ + Object executeRegExp(Context cx, Scriptable scopeObj, RegExpImpl res, + String str, int indexp[], int matchType) + { + REGlobalData gData = new REGlobalData(); + + int start = indexp[0]; + char[] charArray = str.toCharArray(); + int end = charArray.length; + if (start > end) + start = end; + // + // Call the recursive matcher to do the real work. + // + boolean matches = matchRegExp(gData, re, charArray, start, end, + res.multiline); + if (!matches) { + if (matchType != PREFIX) return null; + return Undefined.instance; + } + int index = gData.cp; + int i = index; + indexp[0] = i; + int matchlen = i - (start + gData.skipped); + int ep = index; + index -= matchlen; + Object result; + Scriptable obj; + + if (matchType == TEST) { + /* + * Testing for a match and updating cx.regExpImpl: don't allocate + * an array object, do return true. + */ + result = Boolean.TRUE; + obj = null; + } + else { + /* + * The array returned on match has element 0 bound to the matched + * string, elements 1 through re.parenCount bound to the paren + * matches, an index property telling the length of the left context, + * and an input property referring to the input string. + */ + Scriptable scope = getTopLevelScope(scopeObj); + result = ScriptRuntime.newObject(cx, scope, "Array", null); + obj = (Scriptable) result; + + String matchstr = new String(charArray, index, matchlen); + obj.put(0, obj, matchstr); + } + + if (re.parenCount == 0) { + res.parens = null; + res.lastParen = SubString.emptySubString; + } else { + SubString parsub = null; + int num; + res.parens = new SubString[re.parenCount]; + for (num = 0; num < re.parenCount; num++) { + int cap_index = gData.parens_index(num); + String parstr; + if (cap_index != -1) { + int cap_length = gData.parens_length(num); + parsub = new SubString(charArray, cap_index, cap_length); + res.parens[num] = parsub; + if (matchType == TEST) continue; + parstr = parsub.toString(); + obj.put(num+1, obj, parstr); + } + else { + if (matchType != TEST) + obj.put(num+1, obj, Undefined.instance); + } + } + res.lastParen = parsub; + } + + if (! (matchType == TEST)) { + /* + * Define the index and input properties last for better for/in loop + * order (so they come after the elements). + */ + obj.put("index", obj, new Integer(start + gData.skipped)); + obj.put("input", obj, str); + } + + if (res.lastMatch == null) { + res.lastMatch = new SubString(); + res.leftContext = new SubString(); + res.rightContext = new SubString(); + } + res.lastMatch.charArray = charArray; + res.lastMatch.index = index; + res.lastMatch.length = matchlen; + + res.leftContext.charArray = charArray; + if (cx.getLanguageVersion() == Context.VERSION_1_2) { + /* + * JS1.2 emulated Perl4.0.1.8 (patch level 36) for global regexps used + * in scalar contexts, and unintentionally for the string.match "list" + * psuedo-context. On "hi there bye", the following would result: + * + * Language while(/ /g){print("$`");} s/ /$`/g + * perl4.036 "hi", "there" "hihitherehi therebye" + * perl5 "hi", "hi there" "hihitherehi therebye" + * js1.2 "hi", "there" "hihitheretherebye" + * + * Insofar as JS1.2 always defined $` as "left context from the last + * match" for global regexps, it was more consistent than perl4. + */ + res.leftContext.index = start; + res.leftContext.length = gData.skipped; + } else { + /* + * For JS1.3 and ECMAv2, emulate Perl5 exactly: + * + * js1.3 "hi", "hi there" "hihitherehi therebye" + */ + res.leftContext.index = 0; + res.leftContext.length = start + gData.skipped; + } + + res.rightContext.charArray = charArray; + res.rightContext.index = ep; + res.rightContext.length = end - ep; + + return result; + } + + int getFlags() + { + return re.flags; + } + + private static void reportWarning(Context cx, String messageId, String arg) + { + if (cx.hasFeature(Context.FEATURE_STRICT_MODE)) { + String msg = ScriptRuntime.getMessage1(messageId, arg); + Context.reportWarning(msg); + } + } + + private static void reportError(String messageId, String arg) + { + String msg = ScriptRuntime.getMessage1(messageId, arg); + throw ScriptRuntime.constructError("SyntaxError", msg); + } + +// #string_id_map# + + private static final int + Id_lastIndex = 1, + Id_source = 2, + Id_global = 3, + Id_ignoreCase = 4, + Id_multiline = 5, + + MAX_INSTANCE_ID = 5; + + protected int getMaxInstanceId() + { + return MAX_INSTANCE_ID; + } + + protected int findInstanceIdInfo(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:16:24 EDT + L0: { id = 0; String X = null; int c; + int s_length = s.length(); + if (s_length==6) { + c=s.charAt(0); + if (c=='g') { X="global";id=Id_global; } + else if (c=='s') { X="source";id=Id_source; } + } + else if (s_length==9) { + c=s.charAt(0); + if (c=='l') { X="lastIndex";id=Id_lastIndex; } + else if (c=='m') { X="multiline";id=Id_multiline; } + } + else if (s_length==10) { X="ignoreCase";id=Id_ignoreCase; } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# +// #/string_id_map# + + if (id == 0) return super.findInstanceIdInfo(s); + + int attr; + switch (id) { + case Id_lastIndex: + attr = PERMANENT | DONTENUM; + break; + case Id_source: + case Id_global: + case Id_ignoreCase: + case Id_multiline: + attr = PERMANENT | READONLY | DONTENUM; + break; + default: + throw new IllegalStateException(); + } + return instanceIdInfo(attr, id); + } + + protected String getInstanceIdName(int id) + { + switch (id) { + case Id_lastIndex: return "lastIndex"; + case Id_source: return "source"; + case Id_global: return "global"; + case Id_ignoreCase: return "ignoreCase"; + case Id_multiline: return "multiline"; + } + return super.getInstanceIdName(id); + } + + protected Object getInstanceIdValue(int id) + { + switch (id) { + case Id_lastIndex: + return ScriptRuntime.wrapNumber(lastIndex); + case Id_source: + return new String(re.source); + case Id_global: + return ScriptRuntime.wrapBoolean((re.flags & JSREG_GLOB) != 0); + case Id_ignoreCase: + return ScriptRuntime.wrapBoolean((re.flags & JSREG_FOLD) != 0); + case Id_multiline: + return ScriptRuntime.wrapBoolean((re.flags & JSREG_MULTILINE) != 0); + } + return super.getInstanceIdValue(id); + } + + protected void setInstanceIdValue(int id, Object value) + { + if (id == Id_lastIndex) { + lastIndex = ScriptRuntime.toNumber(value); + return; + } + super.setInstanceIdValue(id, value); + } + + protected void initPrototypeId(int id) + { + String s; + int arity; + switch (id) { + case Id_compile: arity=1; s="compile"; break; + case Id_toString: arity=0; s="toString"; break; + case Id_toSource: arity=0; s="toSource"; break; + case Id_exec: arity=1; s="exec"; break; + case Id_test: arity=1; s="test"; break; + case Id_prefix: arity=1; s="prefix"; break; + default: throw new IllegalArgumentException(String.valueOf(id)); + } + initPrototypeMethod(REGEXP_TAG, id, s, arity); + } + + public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, + Scriptable thisObj, Object[] args) + { + if (!f.hasTag(REGEXP_TAG)) { + return super.execIdCall(f, cx, scope, thisObj, args); + } + int id = f.methodId(); + switch (id) { + case Id_compile: + return realThis(thisObj, f).compile(cx, scope, args); + + case Id_toString: + case Id_toSource: + return realThis(thisObj, f).toString(); + + case Id_exec: + return realThis(thisObj, f).execSub(cx, scope, args, MATCH); + + case Id_test: { + Object x = realThis(thisObj, f).execSub(cx, scope, args, TEST); + return Boolean.TRUE.equals(x) ? Boolean.TRUE : Boolean.FALSE; + } + + case Id_prefix: + return realThis(thisObj, f).execSub(cx, scope, args, PREFIX); + } + throw new IllegalArgumentException(String.valueOf(id)); + } + + private static NativeRegExp realThis(Scriptable thisObj, IdFunctionObject f) + { + if (!(thisObj instanceof NativeRegExp)) + throw incompatibleCallError(f); + return (NativeRegExp)thisObj; + } + +// #string_id_map# + protected int findPrototypeId(String s) + { + int id; +// #generated# Last update: 2007-05-09 08:16:24 EDT + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 4: c=s.charAt(0); + if (c=='e') { X="exec";id=Id_exec; } + else if (c=='t') { X="test";id=Id_test; } + break L; + case 6: X="prefix";id=Id_prefix; break L; + case 7: X="compile";id=Id_compile; break L; + case 8: c=s.charAt(3); + if (c=='o') { X="toSource";id=Id_toSource; } + else if (c=='t') { X="toString";id=Id_toString; } + break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + break L0; + } +// #/generated# + return id; + } + + private static final int + Id_compile = 1, + Id_toString = 2, + Id_toSource = 3, + Id_exec = 4, + Id_test = 5, + Id_prefix = 6, + + MAX_PROTOTYPE_ID = 6; + +// #/string_id_map# + + private RECompiled re; + double lastIndex; /* index after last match, for //g iterator */ + +} // class NativeRegExp + +class RECompiled implements Serializable +{ + static final long serialVersionUID = -6144956577595844213L; + + char []source; /* locked source string, sans // */ + int parenCount; /* number of parenthesized submatches */ + int flags; /* flags */ + byte[] program; /* regular expression bytecode */ + int classCount; /* count [...] bitmaps */ + RECharSet[] classList; /* list of [...] bitmaps */ + int anchorCh = -1; /* if >= 0, then re starts with this literal char */ +} + +class RENode { + + RENode(byte op) + { + this.op = op; + } + + byte op; /* r.e. op bytecode */ + RENode next; /* next in concatenation order */ + RENode kid; /* first operand */ + + RENode kid2; /* second operand */ + int num; /* could be a number */ + int parenIndex; /* or a parenthesis index */ + + /* or a range */ + int min; + int max; + int parenCount; + boolean greedy; + + /* or a character class */ + int startIndex; + int kidlen; /* length of string at kid, in chars */ + int bmsize; /* bitmap size, based on max char code */ + int index; /* index into class list */ + + /* or a literal sequence */ + char chr; /* of one character */ + int length; /* or many (via the index) */ + int flatIndex; /* which is -1 if not sourced */ + +} + +class CompilerState { + + CompilerState(Context cx, char[] source, int length, int flags) + { + this.cx = cx; + this.cpbegin = source; + this.cp = 0; + this.cpend = length; + this.flags = flags; + this.parenCount = 0; + this.classCount = 0; + this.progLength = 0; + } + + Context cx; + char cpbegin[]; + int cpend; + int cp; + int flags; + int parenCount; + int parenNesting; + int classCount; /* number of [] encountered */ + int progLength; /* estimated bytecode length */ + RENode result; +} + +class REProgState +{ + REProgState(REProgState previous, int min, int max, int index, + REBackTrackData backTrack, + int continuation_pc, int continuation_op) + { + this.previous = previous; + this.min = min; + this.max = max; + this.index = index; + this.continuation_op = continuation_op; + this.continuation_pc = continuation_pc; + this.backTrack = backTrack; + } + + REProgState previous; // previous state in stack + + int min; /* current quantifier min */ + int max; /* current quantifier max */ + int index; /* progress in text */ + int continuation_op; + int continuation_pc; + REBackTrackData backTrack; // used by ASSERT_ to recover state +} + +class REBackTrackData { + + REBackTrackData(REGlobalData gData, int op, int pc) + { + previous = gData.backTrackStackTop; + continuation_op = op; + continuation_pc = pc; + lastParen = gData.lastParen; + if (gData.parens != null) { + parens = gData.parens.clone(); + } + cp = gData.cp; + stateStackTop = gData.stateStackTop; + } + + REBackTrackData previous; + + int continuation_op; /* where to backtrack to */ + int continuation_pc; + int lastParen; + long[] parens; /* parenthesis captures */ + int cp; /* char buffer index */ + REProgState stateStackTop; /* state of op that backtracked */ +} + +class REGlobalData { + boolean multiline; + RECompiled regexp; /* the RE in execution */ + int lastParen; /* highest paren set so far */ + int skipped; /* chars skipped anchoring this r.e. */ + + int cp; /* char buffer index */ + long[] parens; /* parens captures */ + + REProgState stateStackTop; /* stack of state of current ancestors */ + + REBackTrackData backTrackStackTop; /* last matched-so-far position */ + + + /** + * Get start of parenthesis capture contents, -1 for empty. + */ + int parens_index(int i) + { + return (int)(parens[i]); + } + + /** + * Get length of parenthesis capture contents. + */ + int parens_length(int i) + { + return (int)(parens[i] >>> 32); + } + + void set_parens(int i, int index, int length) + { + parens[i] = (index & 0xffffffffL) | ((long)length << 32); + } + +} + +/* + * This struct holds a bitmap representation of a class from a regexp. + * There's a list of these referenced by the classList field in the NativeRegExp + * struct below. The initial state has startIndex set to the offset in the + * original regexp source of the beginning of the class contents. The first + * use of the class converts the source representation into a bitmap. + * + */ +final class RECharSet implements Serializable +{ + static final long serialVersionUID = 7931787979395898394L; + + RECharSet(int length, int startIndex, int strlength) + { + this.length = length; + this.startIndex = startIndex; + this.strlength = strlength; + } + + int length; + int startIndex; + int strlength; + + volatile transient boolean converted; + volatile transient boolean sense; + volatile transient byte[] bits; +} + + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/NativeRegExpCtor.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/NativeRegExpCtor.java new file mode 100644 index 0000000..808d62d --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/NativeRegExpCtor.java @@ -0,0 +1,289 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1998. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Brendan Eich + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.regexp; + +import org.mozilla.javascript.*; + +/** + * This class implements the RegExp constructor native object. + * + * Revision History: + * Implementation in C by Brendan Eich + * Initial port to Java by Norris Boyd from jsregexp.c version 1.36 + * Merged up to version 1.38, which included Unicode support. + * Merged bug fixes in version 1.39. + * Merged JSFUN13_BRANCH changes up to 1.32.2.11 + * + * @author Brendan Eich + * @author Norris Boyd + */ +class NativeRegExpCtor extends BaseFunction +{ + static final long serialVersionUID = -5733330028285400526L; + + NativeRegExpCtor() + { + } + + public String getFunctionName() + { + return "RegExp"; + } + + public Object call(Context cx, Scriptable scope, Scriptable thisObj, + Object[] args) + { + if (args.length > 0 && args[0] instanceof NativeRegExp && + (args.length == 1 || args[1] == Undefined.instance)) + { + return args[0]; + } + return construct(cx, scope, args); + } + + public Scriptable construct(Context cx, Scriptable scope, Object[] args) + { + NativeRegExp re = new NativeRegExp(); + re.compile(cx, scope, args); + ScriptRuntime.setObjectProtoAndParent(re, scope); + return re; + } + + private static RegExpImpl getImpl() + { + Context cx = Context.getCurrentContext(); + return (RegExpImpl) ScriptRuntime.getRegExpProxy(cx); + } + +// #string_id_map# + + private static final int + Id_multiline = 1, + Id_STAR = 2, // #string=$*# + + Id_input = 3, + Id_UNDERSCORE = 4, // #string=$_# + + Id_lastMatch = 5, + Id_AMPERSAND = 6, // #string=$&# + + Id_lastParen = 7, + Id_PLUS = 8, // #string=$+# + + Id_leftContext = 9, + Id_BACK_QUOTE = 10, // #string=$`# + + Id_rightContext = 11, + Id_QUOTE = 12, // #string=$'# + + DOLLAR_ID_BASE = 12; + + private static final int + Id_DOLLAR_1 = DOLLAR_ID_BASE + 1, // #string=$1# + Id_DOLLAR_2 = DOLLAR_ID_BASE + 2, // #string=$2# + Id_DOLLAR_3 = DOLLAR_ID_BASE + 3, // #string=$3# + Id_DOLLAR_4 = DOLLAR_ID_BASE + 4, // #string=$4# + Id_DOLLAR_5 = DOLLAR_ID_BASE + 5, // #string=$5# + Id_DOLLAR_6 = DOLLAR_ID_BASE + 6, // #string=$6# + Id_DOLLAR_7 = DOLLAR_ID_BASE + 7, // #string=$7# + Id_DOLLAR_8 = DOLLAR_ID_BASE + 8, // #string=$8# + Id_DOLLAR_9 = DOLLAR_ID_BASE + 9, // #string=$9# + + MAX_INSTANCE_ID = DOLLAR_ID_BASE + 9; + + protected int getMaxInstanceId() + { + return super.getMaxInstanceId() + MAX_INSTANCE_ID; + } + + protected int findInstanceIdInfo(String s) { + int id; +// #generated# Last update: 2001-05-24 16:09:31 GMT+02:00 + L0: { id = 0; String X = null; int c; + L: switch (s.length()) { + case 2: switch (s.charAt(1)) { + case '&': if (s.charAt(0)=='$') {id=Id_AMPERSAND; break L0;} break L; + case '\'': if (s.charAt(0)=='$') {id=Id_QUOTE; break L0;} break L; + case '*': if (s.charAt(0)=='$') {id=Id_STAR; break L0;} break L; + case '+': if (s.charAt(0)=='$') {id=Id_PLUS; break L0;} break L; + case '1': if (s.charAt(0)=='$') {id=Id_DOLLAR_1; break L0;} break L; + case '2': if (s.charAt(0)=='$') {id=Id_DOLLAR_2; break L0;} break L; + case '3': if (s.charAt(0)=='$') {id=Id_DOLLAR_3; break L0;} break L; + case '4': if (s.charAt(0)=='$') {id=Id_DOLLAR_4; break L0;} break L; + case '5': if (s.charAt(0)=='$') {id=Id_DOLLAR_5; break L0;} break L; + case '6': if (s.charAt(0)=='$') {id=Id_DOLLAR_6; break L0;} break L; + case '7': if (s.charAt(0)=='$') {id=Id_DOLLAR_7; break L0;} break L; + case '8': if (s.charAt(0)=='$') {id=Id_DOLLAR_8; break L0;} break L; + case '9': if (s.charAt(0)=='$') {id=Id_DOLLAR_9; break L0;} break L; + case '_': if (s.charAt(0)=='$') {id=Id_UNDERSCORE; break L0;} break L; + case '`': if (s.charAt(0)=='$') {id=Id_BACK_QUOTE; break L0;} break L; + } break L; + case 5: X="input";id=Id_input; break L; + case 9: c=s.charAt(4); + if (c=='M') { X="lastMatch";id=Id_lastMatch; } + else if (c=='P') { X="lastParen";id=Id_lastParen; } + else if (c=='i') { X="multiline";id=Id_multiline; } + break L; + case 11: X="leftContext";id=Id_leftContext; break L; + case 12: X="rightContext";id=Id_rightContext; break L; + } + if (X!=null && X!=s && !X.equals(s)) id = 0; + } +// #/generated# + + if (id == 0) return super.findInstanceIdInfo(s); + + int attr; + switch (id) { + case Id_multiline: + case Id_STAR: + case Id_input: + case Id_UNDERSCORE: + attr = PERMANENT; + break; + default: + attr = PERMANENT | READONLY; + break; + } + + return instanceIdInfo(attr, super.getMaxInstanceId() + id); + } + +// #/string_id_map# + + protected String getInstanceIdName(int id) + { + int shifted = id - super.getMaxInstanceId(); + if (1 <= shifted && shifted <= MAX_INSTANCE_ID) { + switch (shifted) { + case Id_multiline: return "multiline"; + case Id_STAR: return "$*"; + + case Id_input: return "input"; + case Id_UNDERSCORE: return "$_"; + + case Id_lastMatch: return "lastMatch"; + case Id_AMPERSAND: return "$&"; + + case Id_lastParen: return "lastParen"; + case Id_PLUS: return "$+"; + + case Id_leftContext: return "leftContext"; + case Id_BACK_QUOTE: return "$`"; + + case Id_rightContext: return "rightContext"; + case Id_QUOTE: return "$'"; + } + // Must be one of $1..$9, convert to 0..8 + int substring_number = shifted - DOLLAR_ID_BASE - 1; + char[] buf = { '$', (char)('1' + substring_number) }; + return new String(buf); + } + return super.getInstanceIdName(id); + } + + protected Object getInstanceIdValue(int id) + { + int shifted = id - super.getMaxInstanceId(); + if (1 <= shifted && shifted <= MAX_INSTANCE_ID) { + RegExpImpl impl = getImpl(); + Object stringResult; + switch (shifted) { + case Id_multiline: + case Id_STAR: + return ScriptRuntime.wrapBoolean(impl.multiline); + + case Id_input: + case Id_UNDERSCORE: + stringResult = impl.input; + break; + + case Id_lastMatch: + case Id_AMPERSAND: + stringResult = impl.lastMatch; + break; + + case Id_lastParen: + case Id_PLUS: + stringResult = impl.lastParen; + break; + + case Id_leftContext: + case Id_BACK_QUOTE: + stringResult = impl.leftContext; + break; + + case Id_rightContext: + case Id_QUOTE: + stringResult = impl.rightContext; + break; + + default: + { + // Must be one of $1..$9, convert to 0..8 + int substring_number = shifted - DOLLAR_ID_BASE - 1; + stringResult = impl.getParenSubString(substring_number); + break; + } + } + return (stringResult == null) ? "" : stringResult.toString(); + } + return super.getInstanceIdValue(id); + } + + protected void setInstanceIdValue(int id, Object value) + { + int shifted = id - super.getMaxInstanceId(); + switch (shifted) { + case Id_multiline: + case Id_STAR: + getImpl().multiline = ScriptRuntime.toBoolean(value); + return; + + case Id_input: + case Id_UNDERSCORE: + getImpl().input = ScriptRuntime.toString(value); + return; + } + super.setInstanceIdValue(id, value); + } + +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/RegExpImpl.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/RegExpImpl.java new file mode 100644 index 0000000..4b0a303 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/RegExpImpl.java @@ -0,0 +1,541 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1998. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.regexp; + +import org.mozilla.javascript.*; + +/** + * + */ +public class RegExpImpl implements RegExpProxy { + + public boolean isRegExp(Scriptable obj) { + return obj instanceof NativeRegExp; + } + + public Object compileRegExp(Context cx, String source, String flags) + { + return NativeRegExp.compileRE(cx, source, flags, false); + } + + public Scriptable wrapRegExp(Context cx, Scriptable scope, + Object compiled) + { + return new NativeRegExp(scope, compiled); + } + + public Object action(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args, + int actionType) + { + GlobData data = new GlobData(); + data.mode = actionType; + + switch (actionType) { + case RA_MATCH: + { + Object rval; + data.optarg = 1; + rval = matchOrReplace(cx, scope, thisObj, args, + this, data, false); + return data.arrayobj == null ? rval : data.arrayobj; + } + + case RA_SEARCH: + data.optarg = 1; + return matchOrReplace(cx, scope, thisObj, args, + this, data, false); + + case RA_REPLACE: + { + Object arg1 = args.length < 2 ? Undefined.instance : args[1]; + String repstr = null; + Function lambda = null; + if (arg1 instanceof Function) { + lambda = (Function) arg1; + } else { + repstr = ScriptRuntime.toString(arg1); + } + + data.optarg = 2; + data.lambda = lambda; + data.repstr = repstr; + data.dollar = repstr == null ? -1 : repstr.indexOf('$'); + data.charBuf = null; + data.leftIndex = 0; + Object val = matchOrReplace(cx, scope, thisObj, args, + this, data, true); + SubString rc = this.rightContext; + + if (data.charBuf == null) { + if (data.global || val == null + || !val.equals(Boolean.TRUE)) + { + /* Didn't match even once. */ + return data.str; + } + SubString lc = this.leftContext; + replace_glob(data, cx, scope, this, lc.index, lc.length); + } + data.charBuf.append(rc.charArray, rc.index, rc.length); + return data.charBuf.toString(); + } + + default: + throw Kit.codeBug(); + } + } + + /** + * Analog of C match_or_replace. + */ + private static Object matchOrReplace(Context cx, Scriptable scope, + Scriptable thisObj, Object[] args, + RegExpImpl reImpl, + GlobData data, boolean forceFlat) + { + NativeRegExp re; + + String str = ScriptRuntime.toString(thisObj); + data.str = str; + Scriptable topScope = ScriptableObject.getTopLevelScope(scope); + + if (args.length == 0) { + Object compiled = NativeRegExp.compileRE(cx, "", "", false); + re = new NativeRegExp(topScope, compiled); + } else if (args[0] instanceof NativeRegExp) { + re = (NativeRegExp) args[0]; + } else { + String src = ScriptRuntime.toString(args[0]); + String opt; + if (data.optarg < args.length) { + args[0] = src; + opt = ScriptRuntime.toString(args[data.optarg]); + } else { + opt = null; + } + Object compiled = NativeRegExp.compileRE(cx, src, opt, forceFlat); + re = new NativeRegExp(topScope, compiled); + } + data.regexp = re; + + data.global = (re.getFlags() & NativeRegExp.JSREG_GLOB) != 0; + int[] indexp = { 0 }; + Object result = null; + if (data.mode == RA_SEARCH) { + result = re.executeRegExp(cx, scope, reImpl, + str, indexp, NativeRegExp.TEST); + if (result != null && result.equals(Boolean.TRUE)) + result = new Integer(reImpl.leftContext.length); + else + result = new Integer(-1); + } else if (data.global) { + re.lastIndex = 0; + for (int count = 0; indexp[0] <= str.length(); count++) { + result = re.executeRegExp(cx, scope, reImpl, + str, indexp, NativeRegExp.TEST); + if (result == null || !result.equals(Boolean.TRUE)) + break; + if (data.mode == RA_MATCH) { + match_glob(data, cx, scope, count, reImpl); + } else { + if (data.mode != RA_REPLACE) Kit.codeBug(); + SubString lastMatch = reImpl.lastMatch; + int leftIndex = data.leftIndex; + int leftlen = lastMatch.index - leftIndex; + data.leftIndex = lastMatch.index + lastMatch.length; + replace_glob(data, cx, scope, reImpl, leftIndex, leftlen); + } + if (reImpl.lastMatch.length == 0) { + if (indexp[0] == str.length()) + break; + indexp[0]++; + } + } + } else { + result = re.executeRegExp(cx, scope, reImpl, str, indexp, + ((data.mode == RA_REPLACE) + ? NativeRegExp.TEST + : NativeRegExp.MATCH)); + } + + return result; + } + + + + public int find_split(Context cx, Scriptable scope, String target, + String separator, Scriptable reObj, + int[] ip, int[] matchlen, + boolean[] matched, String[][] parensp) + { + int i = ip[0]; + int length = target.length(); + int result; + + int version = cx.getLanguageVersion(); + NativeRegExp re = (NativeRegExp) reObj; + again: + while (true) { // imitating C label + /* JS1.2 deviated from Perl by never matching at end of string. */ + int ipsave = ip[0]; // reuse ip to save object creation + ip[0] = i; + Object ret = re.executeRegExp(cx, scope, this, target, ip, + NativeRegExp.TEST); + if (ret != Boolean.TRUE) { + // Mismatch: ensure our caller advances i past end of string. + ip[0] = ipsave; + matchlen[0] = 1; + matched[0] = false; + return length; + } + i = ip[0]; + ip[0] = ipsave; + matched[0] = true; + + SubString sep = this.lastMatch; + matchlen[0] = sep.length; + if (matchlen[0] == 0) { + /* + * Empty string match: never split on an empty + * match at the start of a find_split cycle. Same + * rule as for an empty global match in + * match_or_replace. + */ + if (i == ip[0]) { + /* + * "Bump-along" to avoid sticking at an empty + * match, but don't bump past end of string -- + * our caller must do that by adding + * sep->length to our return value. + */ + if (i == length) { + if (version == Context.VERSION_1_2) { + matchlen[0] = 1; + result = i; + } + else + result = -1; + break; + } + i++; + continue again; // imitating C goto + } + } + // PR_ASSERT((size_t)i >= sep->length); + result = i - matchlen[0]; + break; + } + int size = (parens == null) ? 0 : parens.length; + parensp[0] = new String[size]; + for (int num = 0; num < size; num++) { + SubString parsub = getParenSubString(num); + parensp[0][num] = parsub.toString(); + } + return result; + } + + /** + * Analog of REGEXP_PAREN_SUBSTRING in C jsregexp.h. + * Assumes zero-based; i.e., for $3, i==2 + */ + SubString getParenSubString(int i) + { + if (parens != null && i < parens.length) { + SubString parsub = parens[i]; + if (parsub != null) { + return parsub; + } + } + return SubString.emptySubString; + } + + /* + * Analog of match_glob() in jsstr.c + */ + private static void match_glob(GlobData mdata, Context cx, + Scriptable scope, int count, + RegExpImpl reImpl) + { + if (mdata.arrayobj == null) { + Scriptable s = ScriptableObject.getTopLevelScope(scope); + mdata.arrayobj = ScriptRuntime.newObject(cx, s, "Array", null); + } + SubString matchsub = reImpl.lastMatch; + String matchstr = matchsub.toString(); + mdata.arrayobj.put(count, mdata.arrayobj, matchstr); + } + + /* + * Analog of replace_glob() in jsstr.c + */ + private static void replace_glob(GlobData rdata, Context cx, + Scriptable scope, RegExpImpl reImpl, + int leftIndex, int leftlen) + { + int replen; + String lambdaStr; + if (rdata.lambda != null) { + // invoke lambda function with args lastMatch, $1, $2, ... $n, + // leftContext.length, whole string. + SubString[] parens = reImpl.parens; + int parenCount = (parens == null) ? 0 : parens.length; + Object[] args = new Object[parenCount + 3]; + args[0] = reImpl.lastMatch.toString(); + for (int i=0; i < parenCount; i++) { + SubString sub = parens[i]; + if (sub != null) { + args[i+1] = sub.toString(); + } else { + args[i+1] = Undefined.instance; + } + } + args[parenCount+1] = new Integer(reImpl.leftContext.length); + args[parenCount+2] = rdata.str; + // This is a hack to prevent expose of reImpl data to + // JS function which can run new regexps modifing + // regexp that are used later by the engine. + // TODO: redesign is necessary + if (reImpl != ScriptRuntime.getRegExpProxy(cx)) Kit.codeBug(); + RegExpImpl re2 = new RegExpImpl(); + re2.multiline = reImpl.multiline; + re2.input = reImpl.input; + ScriptRuntime.setRegExpProxy(cx, re2); + try { + Scriptable parent = ScriptableObject.getTopLevelScope(scope); + Object result = rdata.lambda.call(cx, parent, parent, args); + lambdaStr = ScriptRuntime.toString(result); + } finally { + ScriptRuntime.setRegExpProxy(cx, reImpl); + } + replen = lambdaStr.length(); + } else { + lambdaStr = null; + replen = rdata.repstr.length(); + if (rdata.dollar >= 0) { + int[] skip = new int[1]; + int dp = rdata.dollar; + do { + SubString sub = interpretDollar(cx, reImpl, rdata.repstr, + dp, skip); + if (sub != null) { + replen += sub.length - skip[0]; + dp += skip[0]; + } else { + ++dp; + } + dp = rdata.repstr.indexOf('$', dp); + } while (dp >= 0); + } + } + + int growth = leftlen + replen + reImpl.rightContext.length; + StringBuffer charBuf = rdata.charBuf; + if (charBuf == null) { + charBuf = new StringBuffer(growth); + rdata.charBuf = charBuf; + } else { + charBuf.ensureCapacity(rdata.charBuf.length() + growth); + } + + charBuf.append(reImpl.leftContext.charArray, leftIndex, leftlen); + if (rdata.lambda != null) { + charBuf.append(lambdaStr); + } else { + do_replace(rdata, cx, reImpl); + } + } + + private static SubString interpretDollar(Context cx, RegExpImpl res, + String da, int dp, int[] skip) + { + char dc; + int num, tmp; + + if (da.charAt(dp) != '$') Kit.codeBug(); + + /* Allow a real backslash (literal "\\") to escape "$1" etc. */ + int version = cx.getLanguageVersion(); + if (version != Context.VERSION_DEFAULT + && version <= Context.VERSION_1_4) + { + if (dp > 0 && da.charAt(dp - 1) == '\\') + return null; + } + int daL = da.length(); + if (dp + 1 >= daL) + return null; + /* Interpret all Perl match-induced dollar variables. */ + dc = da.charAt(dp + 1); + if (NativeRegExp.isDigit(dc)) { + int cp; + if (version != Context.VERSION_DEFAULT + && version <= Context.VERSION_1_4) + { + if (dc == '0') + return null; + /* Check for overflow to avoid gobbling arbitrary decimal digits. */ + num = 0; + cp = dp; + while (++cp < daL && NativeRegExp.isDigit(dc = da.charAt(cp))) + { + tmp = 10 * num + (dc - '0'); + if (tmp < num) + break; + num = tmp; + } + } + else { /* ECMA 3, 1-9 or 01-99 */ + int parenCount = (res.parens == null) ? 0 : res.parens.length; + num = dc - '0'; + if (num > parenCount) + return null; + cp = dp + 2; + if ((dp + 2) < daL) { + dc = da.charAt(dp + 2); + if (NativeRegExp.isDigit(dc)) { + tmp = 10 * num + (dc - '0'); + if (tmp <= parenCount) { + cp++; + num = tmp; + } + } + } + if (num == 0) return null; /* $0 or $00 is not valid */ + } + /* Adjust num from 1 $n-origin to 0 array-index-origin. */ + num--; + skip[0] = cp - dp; + return res.getParenSubString(num); + } + + skip[0] = 2; + switch (dc) { + case '$': + return new SubString("$"); + case '&': + return res.lastMatch; + case '+': + return res.lastParen; + case '`': + if (version == Context.VERSION_1_2) { + /* + * JS1.2 imitated the Perl4 bug where left context at each step + * in an iterative use of a global regexp started from last match, + * not from the start of the target string. But Perl4 does start + * $` at the beginning of the target string when it is used in a + * substitution, so we emulate that special case here. + */ + res.leftContext.index = 0; + res.leftContext.length = res.lastMatch.index; + } + return res.leftContext; + case '\'': + return res.rightContext; + } + return null; + } + + /** + * Analog of do_replace in jsstr.c + */ + private static void do_replace(GlobData rdata, Context cx, + RegExpImpl regExpImpl) + { + StringBuffer charBuf = rdata.charBuf; + int cp = 0; + String da = rdata.repstr; + int dp = rdata.dollar; + if (dp != -1) { + int[] skip = new int[1]; + do { + int len = dp - cp; + charBuf.append(da.substring(cp, dp)); + cp = dp; + SubString sub = interpretDollar(cx, regExpImpl, da, + dp, skip); + if (sub != null) { + len = sub.length; + if (len > 0) { + charBuf.append(sub.charArray, sub.index, len); + } + cp += skip[0]; + dp += skip[0]; + } else { + ++dp; + } + dp = da.indexOf('$', dp); + } while (dp >= 0); + } + int daL = da.length(); + if (daL > cp) { + charBuf.append(da.substring(cp, daL)); + } + } + + String input; /* input string to match (perl $_, GC root) */ + boolean multiline; /* whether input contains newlines (perl $*) */ + SubString[] parens; /* Vector of SubString; last set of parens + matched (perl $1, $2) */ + SubString lastMatch; /* last string matched (perl $&) */ + SubString lastParen; /* last paren matched (perl $+) */ + SubString leftContext; /* input to left of last match (perl $`) */ + SubString rightContext; /* input to right of last match (perl $') */ +} + + +final class GlobData +{ + int mode; /* input: return index, match object, or void */ + int optarg; /* input: index of optional flags argument */ + boolean global; /* output: whether regexp was global */ + String str; /* output: 'this' parameter object as string */ + NativeRegExp regexp;/* output: regexp parameter object private data */ + + // match-specific data + + Scriptable arrayobj; + + // replace-specific data + + Function lambda; /* replacement function object or null */ + String repstr; /* replacement string */ + int dollar = -1; /* -1 or index of first $ in repstr */ + StringBuffer charBuf; /* result characters, null initially */ + int leftIndex; /* leftContext index, always 0 for JS1.2 */ +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/SubString.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/SubString.java new file mode 100644 index 0000000..00905ca --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/regexp/SubString.java @@ -0,0 +1,75 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1998. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.regexp; + +class SubString { + + public SubString() + { + } + + public SubString(String str) + { + index = 0; + charArray = str.toCharArray(); + length = str.length(); + } + + public SubString(char[] source, int start, int len) + { + // there must be a better way of doing this?? + index = 0; + length = len; + charArray = new char[len]; + for (int j = 0; j < len; j++) + charArray[j] = source[start + j]; + } + + public String toString() { + return charArray == null + ? "" + : new String(charArray, index, length); + } + + static final SubString emptySubString = new SubString(); + + char[] charArray; + int index; + int length; +} + diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/resources/Messages.properties b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/resources/Messages.properties new file mode 100644 index 0000000..fd869c1 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/resources/Messages.properties @@ -0,0 +1,778 @@ +# +# Default JavaScript messages file. +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is Rhino code, released +# May 6, 1999. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1997-1999 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Norris Boyd +# Bob Jervis +# +# Alternatively, the contents of this file may be used under the terms of +# the GNU General Public License Version 2 or later (the "GPL"), in which +# case the provisions of the GPL are applicable instead of those above. If +# you wish to allow use of your version of this file only under the terms of +# the GPL and not to allow others to use your version of this file under the +# MPL, indicate your decision by deleting the provisions above and replacing +# them with the notice and other provisions required by the GPL. If you do +# not delete the provisions above, a recipient may use your version of this +# file under either the MPL or the GPL. +# +# ***** END LICENSE BLOCK ***** + +# This is replaced during jar assembly from property string +# and should not be translated +implementation.version = @IMPLEMENTATION.VERSION@ + +# +# To add JavaScript error messages for a particular locale, create a +# new Messages_[locale].properties file, where [locale] is the Java +# string abbreviation for that locale. For example, JavaScript +# messages for the Polish locale should be located in +# Messages_pl.properties, and messages for the Italian Swiss locale +# should be located in Messages_it_CH.properties. Message properties +# files should be accessible through the classpath under +# org.mozilla.javascript.resources +# +# See: +# java.util.ResourceBundle +# java.text.MessageFormat +# + +# SomeJavaClassWhereUsed + +# Codegen +msg.dup.parms =\ + Duplicate parameter name "{0}". + +msg.too.big.jump =\ + Program too complex: too big jump offset. + +msg.too.big.index =\ + Program too complex: internal index exceeds 64K limit. + +msg.while.compiling.fn =\ + Encountered code generation error while compiling function "{0}": {1} + +msg.while.compiling.script =\ + Encountered code generation error while compiling script: {0} + +# Context +msg.ctor.not.found =\ + Constructor for "{0}" not found. + +msg.not.ctor =\ + "{0}" is not a constructor. + +# FunctionObject +msg.varargs.ctor =\ + Method or constructor "{0}" must be static with the signature \ + "(Context cx, Object[] args, Function ctorObj, boolean inNewExpr)" \ + to define a variable arguments constructor. + +msg.varargs.fun =\ + Method "{0}" must be static with the signature \ + "(Context cx, Scriptable thisObj, Object[] args, Function funObj)" \ + to define a variable arguments function. + +msg.incompat.call =\ + Method "{0}" called on incompatible object. + +msg.bad.parms =\ + Unsupported parameter type "{0}" in method "{1}". + +msg.bad.method.return =\ + Unsupported return type "{0}" in method "{1}". + +msg.bad.ctor.return =\ + Construction of objects of type "{0}" is not supported. + +msg.no.overload =\ + Method "{0}" occurs multiple times in class "{1}". + +msg.method.not.found =\ + Method "{0}" not found in "{1}". + +# IRFactory + +msg.bad.for.in.lhs =\ + Invalid left-hand side of for..in loop. + +msg.mult.index =\ + Only one variable allowed in for..in loop. + +msg.bad.for.in.destruct =\ + Left hand side of for..in loop must be an array of length 2 to accept \ + key/value pair. + +msg.cant.convert =\ + Can''t convert to type "{0}". + +msg.bad.assign.left =\ + Invalid assignment left-hand side. + +msg.bad.decr =\ + Invalid decerement operand. + +msg.bad.incr =\ + Invalid increment operand. + +msg.bad.yield =\ + yield must be in a function. + +msg.yield.parenthesized =\ + yield expression must be parenthesized. + +# NativeGlobal +msg.cant.call.indirect =\ + Function "{0}" must be called directly, and not by way of a \ + function of another name. + +msg.eval.nonstring =\ + Calling eval() with anything other than a primitive string value will \ + simply return the value. Is this what you intended? + +msg.eval.nonstring.strict =\ + Calling eval() with anything other than a primitive string value is not \ + allowed in strict mode. + +msg.bad.destruct.op =\ + Invalid destructuring assignment operator + +# NativeCall +msg.only.from.new =\ + "{0}" may only be invoked from a "new" expression. + +msg.deprec.ctor =\ + The "{0}" constructor is deprecated. + +# NativeFunction +msg.no.function.ref.found =\ + no source found to decompile function reference {0} + +msg.arg.isnt.array =\ + second argument to Function.prototype.apply must be an array + +# NativeGlobal +msg.bad.esc.mask =\ + invalid string escape mask + +# NativeJavaClass +msg.cant.instantiate =\ + error instantiating ({0}): class {1} is interface or abstract + +msg.bad.ctor.sig =\ + Found constructor with wrong signature: \ + {0} calling {1} with signature {2} + +msg.not.java.obj =\ + Expected argument to getClass() to be a Java object. + +msg.no.java.ctor =\ + Java constructor for "{0}" with arguments "{1}" not found. + +# NativeJavaMethod +msg.method.ambiguous =\ + The choice of Java method {0}.{1} matching JavaScript argument types ({2}) is ambiguous; \ + candidate methods are: {3} + +msg.constructor.ambiguous =\ + The choice of Java constructor {0} matching JavaScript argument types ({1}) is ambiguous; \ + candidate constructors are: {2} + +# NativeJavaObject +msg.conversion.not.allowed =\ + Cannot convert {0} to {1} + +msg.no.empty.interface.conversion =\ + Cannot convert {0} to interface {1} with no methods + +msg.no.function.interface.conversion =\ + Cannot convert function {0} to interface since it contains methods with \ + different signatures + +# NativeJavaPackage +msg.not.classloader =\ + Constructor for "Packages" expects argument of type java.lang.Classloader + +# NativeRegExp +msg.bad.quant =\ + Invalid quantifier {0} + +msg.overlarge.backref =\ + Overly large back reference {0} + +msg.overlarge.min =\ + Overly large minimum {0} + +msg.overlarge.max =\ + Overly large maximum {0} + +msg.zero.quant =\ + Zero quantifier {0} + +msg.max.lt.min =\ + Maximum {0} less than minimum + +msg.unterm.quant =\ + Unterminated quantifier {0} + +msg.unterm.paren =\ + Unterminated parenthetical {0} + +msg.unterm.class =\ + Unterminated character class {0} + +msg.bad.range =\ + Invalid range in character class. + +msg.trail.backslash =\ + Trailing \\ in regular expression. + +msg.re.unmatched.right.paren =\ + unmatched ) in regular expression. + +msg.no.regexp =\ + Regular expressions are not available. + +msg.bad.backref =\ + back-reference exceeds number of capturing parentheses. + +msg.bad.regexp.compile =\ + Only one argument may be specified if the first argument to \ + RegExp.prototype.compile is a RegExp object. + +# Parser +msg.got.syntax.errors = \ + Compilation produced {0} syntax errors. + +msg.var.redecl =\ + TypeError: redeclaration of var {0}. + +msg.const.redecl =\ + TypeError: redeclaration of const {0}. + +msg.let.redecl =\ + TypeError: redeclaration of variable {0}. + +msg.parm.redecl =\ + TypeError: redeclaration of formal parameter {0}. + +msg.fn.redecl =\ + TypeError: redeclaration of function {0}. + +# NodeTransformer +msg.dup.label =\ + duplicated label + +msg.undef.label =\ + undefined label + +msg.bad.break =\ + unlabelled break must be inside loop or switch + +msg.continue.outside =\ + continue must be inside loop + +msg.continue.nonloop =\ + continue can only use labeles of iteration statements + +msg.bad.throw.eol =\ + Line terminator is not allowed between the throw keyword and throw \ + expression. + +msg.no.paren.parms =\ + missing ( before function parameters. + +msg.no.parm =\ + missing formal parameter + +msg.no.paren.after.parms =\ + missing ) after formal parameters + +msg.no.brace.body =\ + missing '{' before function body + +msg.no.brace.after.body =\ + missing } after function body + +msg.no.paren.cond =\ + missing ( before condition + +msg.no.paren.after.cond =\ + missing ) after condition + +msg.no.semi.stmt =\ + missing ; before statement + +msg.no.name.after.dot =\ + missing name after . operator + +msg.no.name.after.coloncolon =\ + missing name after :: operator + +msg.no.name.after.dotdot =\ + missing name after .. operator + +msg.no.name.after.xmlAttr =\ + missing name after .@ + +msg.no.bracket.index =\ + missing ] in index expression + +msg.no.paren.switch =\ + missing ( before switch expression + +msg.no.paren.after.switch =\ + missing ) after switch expression + +msg.no.brace.switch =\ + missing '{' before switch body + +msg.bad.switch =\ + invalid switch statement + +msg.no.colon.case =\ + missing : after case expression + +msg.double.switch.default =\ + double default label in the switch statement + +msg.no.while.do =\ + missing while after do-loop body + +msg.no.paren.for =\ + missing ( after for + +msg.no.semi.for =\ + missing ; after for-loop initializer + +msg.no.semi.for.cond =\ + missing ; after for-loop condition + +msg.in.after.for.name =\ + missing in after for + +msg.no.paren.for.ctrl =\ + missing ) after for-loop control + +msg.no.paren.with =\ + missing ( before with-statement object + +msg.no.paren.after.with =\ + missing ) after with-statement object + +msg.no.paren.after.let =\ + missing ( after let + +msg.no.paren.let =\ + missing ) after variable list + +msg.no.curly.let =\ + missing } after let statement + +msg.bad.return =\ + invalid return + +msg.no.brace.block =\ + missing } in compound statement + +msg.bad.label =\ + invalid label + +msg.bad.var =\ + missing variable name + +msg.bad.var.init =\ + invalid variable initialization + +msg.no.colon.cond =\ + missing : in conditional expression + +msg.no.paren.arg =\ + missing ) after argument list + +msg.no.bracket.arg =\ + missing ] after element list + +msg.bad.prop =\ + invalid property id + +msg.no.colon.prop =\ + missing : after property id + +msg.no.brace.prop =\ + missing } after property list + +msg.no.paren =\ + missing ) in parenthetical + +msg.reserved.id =\ + identifier is a reserved word + +msg.no.paren.catch =\ + missing ( before catch-block condition + +msg.bad.catchcond =\ + invalid catch block condition + +msg.catch.unreachable =\ + any catch clauses following an unqualified catch are unreachable + +msg.no.brace.try =\ + missing '{' before try block + +msg.no.brace.catchblock =\ + missing '{' before catch-block body + +msg.try.no.catchfinally =\ + ''try'' without ''catch'' or ''finally'' + +msg.no.return.value =\ + function {0} does not always return a value + +msg.anon.no.return.value =\ + anonymous function does not always return a value + +msg.return.inconsistent =\ + return statement is inconsistent with previous usage + +msg.generator.returns =\ + TypeError: generator function {0} returns a value + +msg.anon.generator.returns =\ + TypeError: anonymous generator function returns a value + +msg.syntax =\ + syntax error + +msg.unexpected.eof =\ + Unexpected end of file + +msg.XML.bad.form =\ + illegally formed XML syntax + +msg.XML.not.available =\ + XML runtime not available + +msg.too.deep.parser.recursion =\ + Too deep recursion while parsing + +msg.no.side.effects =\ + Code has no side effects + +msg.extra.trailing.comma =\ + Trailing comma is not legal in an ECMA-262 object initializer + +msg.equal.as.assign =\ + Test for equality (==) mistyped as assignment (=)? + +msg.var.hides.arg =\ + Variable {0} hides argument + +msg.destruct.assign.no.init =\ + Missing = in destructuring declaration + +# ScriptRuntime +msg.no.properties =\ + {0} has no properties. + +msg.invalid.iterator =\ + Invalid iterator value + +msg.iterator.primitive =\ + __iterator__ returned a primitive value + +msg.assn.create.strict =\ + Assignment to undeclared variable {0} + +msg.ref.undefined.prop =\ + Reference to undefined property "{0}" + +msg.prop.not.found =\ + Property {0} not found. + +msg.invalid.type =\ + Invalid JavaScript value of type {0} + +msg.primitive.expected =\ + Primitive type expected (had {0} instead) + +msg.namespace.expected =\ + Namespace object expected to left of :: (found {0} instead) + +msg.null.to.object =\ + Cannot convert null to an object. + +msg.undef.to.object =\ + Cannot convert undefined to an object. + +msg.cyclic.value =\ + Cyclic {0} value not allowed. + +msg.is.not.defined =\ + "{0}" is not defined. + +msg.undef.prop.read =\ + Cannot read property "{1}" from {0} + +msg.undef.prop.write =\ + Cannot set property "{1}" of {0} to "{2}" + +msg.undef.prop.delete =\ + Cannot delete property "{1}" of {0} + +msg.undef.method.call =\ + Cannot call method "{1}" of {0} + +msg.undef.with =\ + Cannot apply "with" to {0} + +msg.isnt.function =\ + {0} is not a function, it is {1}. + +msg.isnt.function.in =\ + Cannot call property {0} in object {1}. It is not a function, it is "{2}". + +msg.function.not.found =\ + Cannot find function {0}. + +msg.function.not.found.in =\ + Cannot find function {0} in object {1}. + +msg.isnt.xml.object =\ + {0} is not an xml object. + +msg.no.ref.to.get =\ + {0} is not a reference to read reference value. + +msg.no.ref.to.set =\ + {0} is not a reference to set reference value to {1}. + +msg.no.ref.from.function =\ + Function {0} can not be used as the left-hand side of assignment \ + or as an operand of ++ or -- operator. + +msg.bad.default.value =\ + Object''s getDefaultValue() method returned an object. + +msg.instanceof.not.object = \ + Can''t use instanceof on a non-object. + +msg.instanceof.bad.prototype = \ + ''prototype'' property of {0} is not an object. + +msg.bad.radix = \ + illegal radix {0}. + +# ScriptableObject +msg.default.value =\ + Cannot find default value for object. + +msg.zero.arg.ctor =\ + Cannot load class "{0}" which has no zero-parameter constructor. + +msg.ctor.multiple.parms =\ + Can''t define constructor or class {0} since more than one \ + constructor has multiple parameters. + +msg.extend.scriptable =\ + {0} must extend ScriptableObject in order to define property {1}. + +msg.bad.getter.parms =\ + In order to define a property, getter {0} must have zero parameters \ + or a single ScriptableObject parameter. + +msg.obj.getter.parms =\ + Expected static or delegated getter {0} to take a ScriptableObject parameter. + +msg.getter.static =\ + Getter and setter must both be static or neither be static. + +msg.setter.return =\ + Setter must have void return type: {0} + +msg.setter2.parms =\ + Two-parameter setter must take a ScriptableObject as its first parameter. + +msg.setter1.parms =\ + Expected single parameter setter for {0} + +msg.setter2.expected =\ + Expected static or delegated setter {0} to take two parameters. + +msg.setter.parms =\ + Expected either one or two parameters for setter. + +msg.setter.bad.type =\ + Unsupported parameter type "{0}" in setter "{1}". + +msg.add.sealed =\ + Cannot add a property to a sealed object: {0}. + +msg.remove.sealed =\ + Cannot remove a property from a sealed object: {0}. + +msg.modify.sealed =\ + Cannot modify a property of a sealed object: {0}. + +msg.modify.readonly =\ + Cannot modify readonly property: {0}. + +# TokenStream +msg.missing.exponent =\ + missing exponent + +msg.caught.nfe =\ + number format error + +msg.unterminated.string.lit =\ + unterminated string literal + +msg.unterminated.mstring.appjet =\ + unterminated multi-line string literal + +msg.unterminated.comment =\ + unterminated comment + +msg.unterminated.re.lit =\ + unterminated regular expression literal + +msg.invalid.re.flag =\ + invalid flag after regular expression + +msg.no.re.input.for =\ + no input for {0} + +msg.illegal.character =\ + illegal character + +msg.illegal.character.appjet =\ + illegal character: {0} + +msg.invalid.escape =\ + invalid Unicode escape sequence + +msg.bad.namespace =\ + not a valid default namespace statement. \ + Syntax is: default xml namespace = EXPRESSION; + +# TokensStream warnings +msg.bad.octal.literal =\ + illegal octal literal digit {0}; interpreting it as a decimal digit + +msg.reserved.keyword =\ + illegal usage of future reserved keyword {0}; interpreting it as ordinary identifier + +# LiveConnect errors +msg.java.internal.field.type =\ + Internal error: type conversion of {0} to assign to {1} on {2} failed. + +msg.java.conversion.implicit_method =\ + Can''t find converter method "{0}" on class {1}. + +msg.java.method.assign =\ + Java method "{0}" cannot be assigned to. + +msg.java.internal.private =\ + Internal error: attempt to access private/protected field "{0}". + +msg.java.no_such_method =\ + Can''t find method {0}. + +msg.script.is.not.constructor =\ + Script objects are not constructors. + +msg.nonjava.method =\ + Java method "{0}" was invoked with {1} as "this" value that can not be converted to Java type {2}. + +msg.java.member.not.found =\ + Java class "{0}" has no public instance field or method named "{1}". + +msg.java.array.index.out.of.bounds =\ + Array index {0} is out of bounds [0..{1}]. + +msg.java.array.member.not.found =\ + Java arrays have no public instance fields or methods named "{0}". + +msg.pkg.int =\ + Java package names may not be numbers. + +msg.access.prohibited =\ + Access to Java class "{0}" is prohibited. + +# ImporterTopLevel +msg.ambig.import =\ + Ambiguous import: "{0}" and and "{1}". + +msg.not.pkg =\ + Function importPackage must be called with a package; had "{0}" instead. + +msg.not.class =\ + Function importClass must be called with a class; had "{0}" instead. + +msg.not.class.not.pkg =\ + "{0}" is neither a class nor a package. + +msg.prop.defined =\ + Cannot import "{0}" since a property by that name is already defined. + +#JavaAdapter +msg.adapter.zero.args =\ + JavaAdapter requires at least one argument. + +msg.not.java.class.arg = \ +Argument {0} is not Java class: {1}. + +#JavaAdapter +msg.only.one.super = \ +Only one class may be extended by a JavaAdapter. Had {0} and {1}. + + +# Arrays +msg.arraylength.bad =\ + Inappropriate array length. + +# Arrays +msg.arraylength.too.big =\ + Array length {0} exceeds supported capacity limit. + +# URI +msg.bad.uri =\ + Malformed URI sequence. + +# Number +msg.bad.precision =\ + Precision {0} out of range. + +# NativeGenerator +msg.send.newborn =\ + Attempt to send value to newborn generator + +msg.already.exec.gen =\ + Already executing generator + +msg.StopIteration.invalid =\ + StopIteration may not be changed to an arbitrary object. + +# Interpreter +msg.yield.closing =\ + Yield from closing generator diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/resources/Messages_fr.properties b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/resources/Messages_fr.properties new file mode 100644 index 0000000..fc87c97 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/resources/Messages_fr.properties @@ -0,0 +1,329 @@ +# +# French JavaScript messages file. +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is Aviva Inc. code, released +# March 5, 2004. +# +# The Initial Developer of the Original Code is +# Aviva Inc. +# Portions created by the Initial Developer are Copyright (C) 2004 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Eugene Aresteanu +# +# Alternatively, the contents of this file may be used under the terms of +# the GNU General Public License Version 2 or later (the "GPL"), in which +# case the provisions of the GPL are applicable instead of those above. If +# you wish to allow use of your version of this file only under the terms of +# the GPL and not to allow others to use your version of this file under the +# MPL, indicate your decision by deleting the provisions above and replacing +# them with the notice and other provisions required by the GPL. If you do +# not delete the provisions above, a recipient may use your version of this +# file under either the MPL or the GPL. +# +# ***** END LICENSE BLOCK ***** + +msg.dup.parms =\ + Le nom de param\u00E8tre "{0}" existe d\u00E9j\u00E0. +msg.too.big.jump =\ + Programme trop complexe : d\u00E9calage de saut trop important +msg.too.big.index =\ + Programme trop complexe : l''indice interne d\u00E9passe la limite de 64 ko +msg.ctor.not.found =\ + Le constructeur de "{0}" est introuvable +msg.not.ctor =\ + {0} n''est pas un constructeur +msg.varargs.ctor =\ + La m\u00E9thode ou le constructeur "{0}" doit \u00EAtre statique avec la signature "(Context cx, arguments Object[], Function ctorObj, boolean inNewExpr)" pour d\u00E9finir un constructeur d''arguments de variable. +msg.varargs.fun =\ + La m\u00E9thode "{0}" doit \u00EAtre statique avec la signature "(Context cx, Scriptable thisObj, arguments Object[], Function funObj)" pour d\u00E9finir une fonction d''arguments de variable +msg.incompat.call =\ + La m\u00E9thode "{0}" a \u00E9t\u00E9 appel\u00E9e dans un objet non compatible +msg.bad.parms =\ + Les param\u00E8tres de la m\u00E9thode sont incorrects pour "{0}" +msg.no.overload =\ + La m\u00E9thode "{0}" appara\u00EEt plusieurs fois dans la classe "{1}" +msg.method.not.found =\ + La m\u00E9thode "{0}" est introuvable dans "{1}" +msg.bad.for.in.lhs =\ + La partie gauche de la boucle for..in est incorrecte +msg.bad.lhs.assign =\ + La partie gauche de l''affectation est incorrecte +msg.mult.index =\ + Une seule variable est autoris\u00E9e dans la boucle for..in +msg.cant.convert =\ + La conversion en type "{0}" est impossible +msg.cant.call.indirect =\ + La fonction "{0}" doit \u00EAtre appel\u00E9e directement et non par l''interm\u00E9diaire d''une fonction portant un autre nom +msg.eval.nonstring =\ + Si vous appelez la fonction eval() avec une valeur qui n''appartient pas \u00E0 une cha\u00EEne primitive, c''est la valeur en question qui est renvoy\u00E9e. \u00E9tait-ce votre intention ? +msg.only.from.new =\ + {0} ne peut \u00EAtre appel\u00E9e qu''\u00E0 partir d''une "nouvelle" expression. +msg.deprec.ctor =\ + Le constructeur "{0}" est d\u00E9conseill\u00E9 +msg.no.function.ref.found =\ + aucune source n''a \u00E9t\u00E9 trouv\u00E9e pour d\u00E9compiler la r\u00E9f\u00E9rence de fonction {0} +msg.arg.isnt.array =\ + le second argument de la m\u00E9thode Function.prototype.apply doit \u00EAtre un tableau +msg.bad.esc.mask =\ + le masque d''\u00E9chappement de cha\u00EEne est incorrect +msg.cant.instantiate =\ + erreur lors de l''instanciation ({0}) : la classe {1} est une classe interface ou abstract +msg.bad.ctor.sig =\ + Un constructeur avec une signature incorrecte a \u00E9t\u00E9 d\u00E9tect\u00E9 : {0} qui appelle {1} avec la signature {2} +msg.not.java.obj =\ + L''argument attendu pour la fonction getClass() doit \u00EAtre un objet Java +msg.no.java.ctor =\ + Le constructeur Java de "{0}" avec les arguments "{1}" est introuvable +msg.method.ambiguous =\ + Le choix de la m\u00E9thode Java {0}.{1} correspondant aux types d''argument JavaScript ({2}) est ambigu. Les m\u00E9thodes propos\u00E9es sont les suivantes : {3} +msg.constructor.ambiguous =\ + Le choix du constructeur Java {0} correspondant aux types d''argument JavaScript ({1}) est ambigu. Les constructeurs propos\u00E9s sont les suivants : {2} +msg.conversion.not.allowed =\ + Impossible de convertir {0} en {1} +msg.not.classloader =\ + Le constructeur de "Packages" attend un argument de type java.lang.Classloader +msg.bad.quant =\ + Le quantificateur {0} est incorrect +msg.overlarge.max =\ + Le maximum {0} est trop important +msg.zero.quant =\ + Le quantificateur {0} est nul +msg.max.lt.min =\ + Le maximum {0} est inf\u00E9rieur au minimum +msg.unterm.quant =\ + Le quantificateur {0} n''a pas de limite +msg.unterm.paren =\ + Les parenth\u00E8ses {0} n''ont pas de limite +msg.unterm.class =\ + La classe de caract\u00E8res {0} n''a pas de limite +msg.bad.range =\ + La classe de caract\u00E8res contient une plage de valeurs incorrecte +msg.trail.backslash =\ + \\ au d\u00E9but d''une expression r\u00E9guli\u00E8re +msg.no.regexp =\ + Les expressions r\u00E9guli\u00E8res ne sont pas disponibles +msg.bad.backref =\ + la r\u00E9f\u00E9rence ant\u00E9rieure d\u00E9passe le nombre de parenth\u00E8ses de capture +msg.dup.label =\ + Le libell\u00E9 {0} existe d\u00E9j\u00E0 +msg.undef.label =\ + Le libell\u00E9 {0} n''est pas d\u00E9fini +msg.bad.break =\ + Le saut non libell\u00E9 doit se trouver dans la boucle ou dans l''aiguillage +msg.continue.outside =\ + continue doit se trouver dans la boucle +msg.continue.nonloop =\ + Il n''est possible de continuer que dans l''instruction d''it\u00E9ration libell\u00E9e +msg.fn.redecl =\ + La fonction "{0}" a \u00E9t\u00E9 de nouveau d\u00E9clar\u00E9e. La d\u00E9finition pr\u00E9c\u00E9dente sera ignor\u00E9e +msg.no.paren.parms =\ + il manque ''('' avant les param\u00E8tres de la fonction +msg.no.parm =\ + il manque un param\u00E8tre de forme +msg.no.paren.after.parms =\ + il manque '')'' apr\u00E8s les param\u00E8tres de forme +msg.no.brace.body =\ + il manque '{' avant le corps d''une fonction +msg.no.brace.after.body =\ + il manque ''}'' apr\u00E8s le corps d''une fonction +msg.no.paren.cond =\ + il manque ''('' avant une condition +msg.no.paren.after.cond =\ + il manque '')'' apr\u00E8s une condition +msg.no.semi.stmt =\ + il manque '';'' avant une instruction +msg.no.name.after.dot =\ + il manque un nom apr\u00E8s un op\u00E9rateur ''.'' +msg.no.bracket.index =\ + il manque '']'' dans l''expression de l''indice +msg.no.paren.switch =\ + il manque ''('' avant l''expression d''un aiguillage +msg.no.paren.after.switch =\ + il manque '')'' apr\u00E8s l''expression d''un aiguillage +msg.no.brace.switch =\ + il manque '{' avant le corps d''un aiguillage +msg.bad.switch =\ + l''instruction d''aiguillage est incorrecte +msg.no.colon.case =\ + il manque '':'' apr\u00E8s l''expression d''un cas +msg.no.while.do =\ + il manque ''while'' apr\u00E8s le corps d''une boucle do-loop +msg.no.paren.for =\ + il manque ''('' apr\u00E8s for +msg.no.semi.for =\ + Il manque '';'' apr\u00E8s l''initialiseur for-loop +msg.no.semi.for.cond =\ + il manque '';'' apr\u00E8s la condition for-loop +msg.no.paren.for.ctrl =\ + il manque '')'' apr\u00E8s le contrôle for-loop +msg.no.paren.with =\ + il manque ''('' avant un objet with-statement +msg.no.paren.after.with =\ + il manque '')'' apr\u00E8s un objet with-statement +msg.bad.return =\ + la valeur renvoy\u00E9e est incorrecte +msg.no.brace.block =\ + il manque ''}'' dans une instruction compos\u00E9e +msg.bad.label =\ + le libell\u00E9 est incorrect +msg.bad.var =\ + il manque un nom de variable +msg.bad.var.init =\ + l''initialisation de la variable est incorrecte +msg.no.colon.cond =\ + il manque '':'' dans une expression conditionnelle +msg.no.paren.arg =\ + il manque '')'' apr\u00E8s une liste d''arguments +msg.no.bracket.arg =\ + il manque '']'' apr\u00E8s une liste d''\u00E9l\u00E9ments +msg.bad.prop =\ + l''identifiant de propri\u00E9t\u00E9 est incorrect +msg.no.colon.prop =\ + il manque '':'' apr\u00E8s un identifiant de propri\u00E9t\u00E9 +msg.no.brace.prop =\ + il manque ''}'' apr\u00E8s une liste de propri\u00E9t\u00E9s +msg.no.paren =\ + il manque '')'' dans des parenth\u00E8ses +msg.reserved.id =\ + l''identifiant est un mot r\u00E9serv\u00E9 +msg.no.paren.catch =\ + il manque ''('' avant une condition catch-block +msg.bad.catchcond =\ + la condition catch-block est incorrecte +msg.catch.unreachable =\ + aucune clause catch suivant une interception non qualifi\u00E9e ne peut \u00EAtre atteinte +msg.no.brace.catchblock =\ + il manque '{' avant le corps catch-block +msg.try.no.catchfinally =\ + ''try'' a \u00E9t\u00E9 d\u00E9tect\u00E9 sans ''catch'' ni ''finally'' +msg.syntax =\ + erreur de syntaxe +msg.assn.create =\ + Une variable va \u00EAtre cr\u00E9\u00E9e en raison de l''affectation \u00E0 un ''{0}'' non d\u00E9fini. Ajoutez une instruction de variable \u00E0 la port\u00E9e sup\u00E9rieure pour que cet avertissement ne soit plus affich\u00E9 +msg.prop.not.found =\ + La propri\u00E9t\u00E9 est introuvable +msg.invalid.type =\ + Valeur JavaScript de type {0} incorrecte +msg.primitive.expected =\ + Un type primitif \u00E9tait attendu (et non {0}) +msg.null.to.object =\ + Il est impossible de convertir la valeur null en objet +msg.undef.to.object =\ + Il est impossible de convertir une valeur non d\u00E9finie en objet +msg.cyclic.value =\ + La valeur cyclique {0} n''est pas autoris\u00E9e +msg.is.not.defined =\ + "{0}" n''est pas d\u00E9fini +msg.isnt.function =\ + {0} n''est pas une fonction, est un {1} +msg.bad.default.value =\ + La m\u00E9thode getDefaultValue() de l''objet a renvoy\u00E9 un objet +msg.instanceof.not.object =\ + Il est impossible d''utiliser une instance d''un \u00E9l\u00E9ment autre qu''un objet +msg.instanceof.bad.prototype =\ + La propri\u00E9t\u00E9 ''prototype'' de {0} n''est pas un objet +msg.bad.radix =\ + la base {0} n''est pas autoris\u00E9e +msg.default.value =\ + La valeur par d\u00E9faut de l''objet est introuvable +msg.zero.arg.ctor =\ + Il est impossible de charger la classe "{0}", qui ne poss\u00E8de pas de constructeur de param\u00E8tre z\u00E9ro +msg.multiple.ctors =\ + Les m\u00E9thodes {0} et {1} ont \u00E9t\u00E9 d\u00E9tect\u00E9es alors qu''il est impossible d''utiliser plusieurs m\u00E9thodes constructor +msg.ctor.multiple.parms =\ + Il est impossible de d\u00E9finir le constructeur ou la classe {0} car plusieurs constructeurs poss\u00E8dent plusieurs param\u00E8tres +msg.extend.scriptable =\ + {0} doit \u00E9tendre ScriptableObject afin de d\u00E9finir la propri\u00E9t\u00E9 {1} +msg.bad.getter.parms =\ + Pour d\u00E9finir une propri\u00E9t\u00E9, la m\u00E9thode d''obtention {0} doit avoir des param\u00E8tres z\u00E9ro ou un seul param\u00E8tre ScriptableObject +msg.obj.getter.parms =\ + La m\u00E9thode d''obtention statique ou d\u00E9l\u00E9gu\u00E9e {0} doit utiliser un param\u00E8tre ScriptableObject +msg.getter.static =\ + La m\u00E9thode d''obtention et la m\u00E9thode de d\u00E9finition doivent toutes deux avoir le m\u00EAme \u00E9tat (statique ou non) +msg.setter2.parms =\ + La m\u00E9thode de d\u00E9finition \u00E0 deux param\u00E8tres doit utiliser un param\u00E8tre ScriptableObject comme premier param\u00E8tre +msg.setter1.parms =\ + Une m\u00E9thode d''obtention \u00E0 param\u00E8tre unique est attendue pour {0} +msg.setter2.expected =\ + La m\u00E9thode de d\u00E9finition statique ou d\u00E9l\u00E9gu\u00E9e {0} doit utiliser deux param\u00E8tres +msg.setter.parms =\ + Un ou deux param\u00E8tres sont attendus pour la m\u00E9thode de d\u00E9finition +msg.add.sealed =\ + Il est impossible d''ajouter une propri\u00E9t\u00E9 \u00E0 un objet ferm\u00E9 +msg.remove.sealed =\ + Il est impossible de supprimer une propri\u00E9t\u00E9 d''un objet ferm\u00E9 +msg.token.replaces.pushback =\ + le jeton de non-obtention {0} remplace le jeton de renvoi {1} +msg.missing.exponent =\ + il manque un exposant +msg.caught.nfe =\ + erreur de format de nombre : {0} +msg.unterminated.string.lit =\ + le litt\u00E9ral de la cha\u00EEne n''a pas de limite +msg.unterminated.comment =\ + le commentaire n''a pas de limite +msg.unterminated.re.lit =\ + le litt\u00E9ral de l''expression r\u00E9guli\u00E8re n''a pas de limite +msg.invalid.re.flag =\ + une expression r\u00E9guli\u00E8re est suivie d''un indicateur incorrect +msg.no.re.input.for =\ + il n''y a pas d''entr\u00E9e pour {0} +msg.illegal.character =\ + caract\u00E8re non autoris\u00E9 +msg.invalid.escape =\ + la s\u00E9quence d''\u00E9chappement Unicode est incorrecte +msg.bad.octal.literal =\ + le chiffre octal du litt\u00E9ral, {0}, n''est pas autoris\u00E9 et sera interpr\u00E9t\u00E9 comme un chiffre d\u00E9cimal +msg.reserved.keyword =\ + l''utilisation du futur mot-cl\u00E9 r\u00E9serv\u00E9 {0} n''est pas autoris\u00E9e et celui-ci sera interpr\u00E9t\u00E9 comme un identifiant ordinaire +msg.undefined =\ + La valeur non d\u00E9finie ne poss\u00E8de pas de propri\u00E9t\u00E9 +msg.java.internal.field.type =\ + Erreur interne : la conversion de type de {0} afin d''affecter {1} \u00E0 {2} a \u00E9chou\u00E9 +msg.java.conversion.implicit_method =\ + La m\u00E9thode de conversion "{0}" est introuvable dans la classe {1} +sg.java.method.assign =\ + La m\u00E9thode Java "{0}" ne peut pas \u00EAtre affect\u00E9e \u00E0 +msg.java.internal.private =\ + Erreur interne : une tentative d''acc\u00E9der \u00E0 un champ "{0}" priv\u00E9/prot\u00E9g\u00E9 a \u00E9t\u00E9 d\u00E9tect\u00E9e +msg.java.no_such_method =\ + La m\u00E9thode ''{0}'' est introuvable +msg.script.is.not.constructor =\ + Les objets Script ne sont pas des constructeurs +msg.nonjava.method =\ + La m\u00E9thode Java "{0}" a \u00E9t\u00E9 appel\u00E9e avec une valeur ''this'' qui n''est pas un objet Java +msg.java.member.not.found =\ + La classe Java "{0}" ne poss\u00E8de aucun champ ou aucune m\u00E9thode d''instance publique appel\u00E9 "{1}" +msg.java.array.index.out.of.bounds =\ + Array index {0} is out of bounds [0..{1}]. +msg.pkg.int =\ + Les noms de package Java ne peuvent pas \u00EAtre des nombres +msg.ambig.import =\ + Importation ambigu\u00EB : "{0}" et "{1}" +msg.not.pkg =\ + La fonction importPackage doit \u00EAtre appel\u00E9e avec un package et non avec "{0}" +msg.not.class =\ + La fonction importClass doit \u00EAtre appel\u00E9e avec une classe et non avec "{0}" +msg.prop.defined =\ + Il est impossible d''importer "{0}" car une propri\u00E9t\u00E9 portant le m\u00EAme nom a d\u00E9j\u00E0 \u00E9t\u00E9 d\u00E9finie +sg.arraylength.bad =\ + La longueur du tableau n''est pas appropri\u00E9e +msg.bad.uri =\ + La s\u00E9quence URI n''est pas form\u00E9e correctement +msg.bad.precision =\ + La pr\u00E9cision {0} ne se trouve pas dans la plage de valeurs diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/serialize/ScriptableInputStream.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/serialize/ScriptableInputStream.java new file mode 100644 index 0000000..476ff69 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/serialize/ScriptableInputStream.java @@ -0,0 +1,112 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino serialization code, released + * Sept. 25, 2001. + * + * The Initial Developer of the Original Code is + * Norris Boyd. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Igor Bukanov + * Attila Szegedi + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +// API class + +package org.mozilla.javascript.serialize; + +import java.io.*; + +import org.mozilla.javascript.*; + +/** + * Class ScriptableInputStream is used to read in a JavaScript + * object or function previously serialized with a ScriptableOutputStream. + * References to names in the exclusion list + * replaced with references to the top-level scope specified during + * creation of the ScriptableInputStream. + * + * @author Norris Boyd + */ + +public class ScriptableInputStream extends ObjectInputStream { + + /** + * Create a ScriptableInputStream. + * @param in the InputStream to read from. + * @param scope the top-level scope to create the object in. + */ + public ScriptableInputStream(InputStream in, Scriptable scope) + throws IOException + { + super(in); + this.scope = scope; + enableResolveObject(true); + Context cx = Context.getCurrentContext(); + if (cx != null) { + this.classLoader = cx.getApplicationClassLoader(); + } + } + + protected Class resolveClass(ObjectStreamClass desc) + throws IOException, ClassNotFoundException + { + String name = desc.getName(); + if (classLoader != null) { + try { + return classLoader.loadClass(name); + } catch (ClassNotFoundException ex) { + // fall through to default loading + } + } + return super.resolveClass(desc); + } + + protected Object resolveObject(Object obj) + throws IOException + { + if (obj instanceof ScriptableOutputStream.PendingLookup) { + String name = ((ScriptableOutputStream.PendingLookup)obj).getName(); + obj = ScriptableOutputStream.lookupQualifiedName(scope, name); + if (obj == Scriptable.NOT_FOUND) { + throw new IOException("Object " + name + " not found upon " + + "deserialization."); + } + }else if (obj instanceof UniqueTag) { + obj = ((UniqueTag)obj).readResolve(); + }else if (obj instanceof Undefined) { + obj = ((Undefined)obj).readResolve(); + } + return obj; + } + + private Scriptable scope; + private ClassLoader classLoader; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/serialize/ScriptableOutputStream.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/serialize/ScriptableOutputStream.java new file mode 100644 index 0000000..5ba0d74 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/serialize/ScriptableOutputStream.java @@ -0,0 +1,207 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino serialization code, released + * Sept. 25, 2001. + * + * The Initial Developer of the Original Code is + * Norris Boyd. + * Portions created by the Initial Developer are Copyright (C) 2001 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Norris Boyd + * Attila Szegedi + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.serialize; + +import java.util.Hashtable; +import java.util.StringTokenizer; +import java.io.*; + +import org.mozilla.javascript.*; + +/** + * Class ScriptableOutputStream is an ObjectOutputStream used + * to serialize JavaScript objects and functions. Note that + * compiled functions currently cannot be serialized, only + * interpreted functions. The top-level scope containing the + * object is not written out, but is instead replaced with + * another top-level object when the ScriptableInputStream + * reads in this object. Also, object corresponding to names + * added to the exclude list are not written out but instead + * are looked up during deserialization. This approach avoids + * the creation of duplicate copies of standard objects + * during deserialization. + * + * @author Norris Boyd + */ + +// API class + +public class ScriptableOutputStream extends ObjectOutputStream { + + /** + * ScriptableOutputStream constructor. + * Creates a ScriptableOutputStream for use in serializing + * JavaScript objects. Calls excludeStandardObjectNames. + * + * @param out the OutputStream to write to. + * @param scope the scope containing the object. + */ + public ScriptableOutputStream(OutputStream out, Scriptable scope) + throws IOException + { + super(out); + this.scope = scope; + table = new Hashtable(31); + table.put(scope, ""); + enableReplaceObject(true); + excludeStandardObjectNames(); + } + + /** + * Adds a qualified name to the list of object to be excluded from + * serialization. Names excluded from serialization are looked up + * in the new scope and replaced upon deserialization. + * @param name a fully qualified name (of the form "a.b.c", where + * "a" must be a property of the top-level object). The object + * need not exist, in which case the name is ignored. + * @throws IllegalArgumentException if the object is not a + * {@link Scriptable}. + */ + public void addOptionalExcludedName(String name) { + Object obj = lookupQualifiedName(scope, name); + if(obj != null && obj != UniqueTag.NOT_FOUND) { + if (!(obj instanceof Scriptable)) { + throw new IllegalArgumentException( + "Object for excluded name " + name + + " is not a Scriptable, it is " + + obj.getClass().getName()); + } + table.put(obj, name); + } + } + + /** + * Adds a qualified name to the list of object to be excluded from + * serialization. Names excluded from serialization are looked up + * in the new scope and replaced upon deserialization. + * @param name a fully qualified name (of the form "a.b.c", where + * "a" must be a property of the top-level object) + * @throws IllegalArgumentException if the object is not found or is not + * a {@link Scriptable}. + */ + public void addExcludedName(String name) { + Object obj = lookupQualifiedName(scope, name); + if (!(obj instanceof Scriptable)) { + throw new IllegalArgumentException("Object for excluded name " + + name + " not found."); + } + table.put(obj, name); + } + + /** + * Returns true if the name is excluded from serialization. + */ + public boolean hasExcludedName(String name) { + return table.get(name) != null; + } + + /** + * Removes a name from the list of names to exclude. + */ + public void removeExcludedName(String name) { + table.remove(name); + } + + /** + * Adds the names of the standard objects and their + * prototypes to the list of excluded names. + */ + public void excludeStandardObjectNames() { + String[] names = { "Object", "Object.prototype", + "Function", "Function.prototype", + "String", "String.prototype", + "Math", // no Math.prototype + "Array", "Array.prototype", + "Error", "Error.prototype", + "Number", "Number.prototype", + "Date", "Date.prototype", + "RegExp", "RegExp.prototype", + "Script", "Script.prototype", + "Continuation", "Continuation.prototype", + }; + for (int i=0; i < names.length; i++) { + addExcludedName(names[i]); + } + + String[] optionalNames = { + "XML", "XML.prototype", + "XMLList", "XMLList.prototype", + }; + for (int i=0; i < optionalNames.length; i++) { + addOptionalExcludedName(optionalNames[i]); + } + } + + static Object lookupQualifiedName(Scriptable scope, + String qualifiedName) + { + StringTokenizer st = new StringTokenizer(qualifiedName, "."); + Object result = scope; + while (st.hasMoreTokens()) { + String s = st.nextToken(); + result = ScriptableObject.getProperty((Scriptable)result, s); + if (result == null || !(result instanceof Scriptable)) + break; + } + return result; + } + + static class PendingLookup implements Serializable + { + static final long serialVersionUID = -2692990309789917727L; + + PendingLookup(String name) { this.name = name; } + + String getName() { return name; } + + private String name; + } + + protected Object replaceObject(Object obj) throws IOException + { + String name = (String) table.get(obj); + if (name == null) + return obj; + return new PendingLookup(name); + } + + private Scriptable scope; + private Hashtable table; +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/xml/XMLLib.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/xml/XMLLib.java new file mode 100644 index 0000000..da57ddf --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/xml/XMLLib.java @@ -0,0 +1,132 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.xml; + +import org.mozilla.javascript.*; + +public abstract class XMLLib +{ + private static final Object XML_LIB_KEY = new Object(); + + /** + An object which specifies an XMLLib implementation to be used at runtime. + + This interface should be considered experimental. It may be better + (and certainly more flexible) to write an interface that returns an + XMLLib object rather than a class name, for example. But that would + cause many more ripple effects in the code, all the way back to + {@link ScriptRuntime}. + */ + public static abstract class Factory { + public static Factory create(final String className) { + return new Factory() { + public String getImplementationClassName() { + return className; + } + }; + } + + public abstract String getImplementationClassName(); + } + + public static XMLLib extractFromScopeOrNull(Scriptable scope) + { + ScriptableObject so = ScriptRuntime.getLibraryScopeOrNull(scope); + if (so == null) { + // If library is not yet initialized, return null + return null; + } + + // Ensure lazily initialization of real XML library instance + // which is done on first access to XML property + ScriptableObject.getProperty(so, "XML"); + + return (XMLLib)so.getAssociatedValue(XML_LIB_KEY); + } + + public static XMLLib extractFromScope(Scriptable scope) + { + XMLLib lib = extractFromScopeOrNull(scope); + if (lib != null) { + return lib; + } + String msg = ScriptRuntime.getMessage0("msg.XML.not.available"); + throw Context.reportRuntimeError(msg); + } + + protected final XMLLib bindToScope(Scriptable scope) + { + ScriptableObject so = ScriptRuntime.getLibraryScopeOrNull(scope); + if (so == null) { + // standard library should be initialized at this point + throw new IllegalStateException(); + } + return (XMLLib)so.associateValue(XML_LIB_KEY, this); + } + + public abstract boolean isXMLName(Context cx, Object name); + + public abstract Ref nameRef(Context cx, Object name, + Scriptable scope, int memberTypeFlags); + + public abstract Ref nameRef(Context cx, Object namespace, Object name, + Scriptable scope, int memberTypeFlags); + + /** + * Escapes the reserved characters in a value of an attribute. + * + * @param value Unescaped text + * @return The escaped text + */ + public abstract String escapeAttributeValue(Object value); + + /** + * Escapes the reserved characters in a value of a text node. + * + * @param value Unescaped text + * @return The escaped text + */ + public abstract String escapeTextValue(Object value); + + + /** + * Construct namespace for default xml statement. + */ + public abstract Object toDefaultXmlNamespace(Context cx, Object uriValue); +} diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/xml/XMLObject.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/xml/XMLObject.java new file mode 100644 index 0000000..5033564 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/xml/XMLObject.java @@ -0,0 +1,128 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-2000 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Igor Bukanov + * Ethan Hugg + * Terry Lucas + * Milen Nankov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.javascript.xml; + +import org.mozilla.javascript.*; + +/** + * This Interface describes what all XML objects (XML, XMLList) should have in common. + * + */ +public abstract class XMLObject extends IdScriptableObject +{ + public XMLObject() + { + } + + public XMLObject(Scriptable scope, Scriptable prototype) + { + super(scope, prototype); + } + + /** + * Implementation of ECMAScript [[Has]]. + */ + public abstract boolean ecmaHas(Context cx, Object id); + + /** + * Implementation of ECMAScript [[Get]]. + */ + public abstract Object ecmaGet(Context cx, Object id); + + /** + * Implementation of ECMAScript [[Put]]. + */ + public abstract void ecmaPut(Context cx, Object id, Object value); + + /** + * Implementation of ECMAScript [[Delete]]. + */ + public abstract boolean ecmaDelete(Context cx, Object id); + + /** + * Return an additional object to look for methods that runtime should + * consider during method search. Return null if no such object available. + */ + public abstract Scriptable getExtraMethodSource(Context cx); + + /** + * Generic reference to implement x.@y, x..y etc. + */ + public abstract Ref memberRef(Context cx, Object elem, + int memberTypeFlags); + + /** + * Generic reference to implement x::ns, x.@ns::y, x..@ns::y etc. + */ + public abstract Ref memberRef(Context cx, Object namespace, Object elem, + int memberTypeFlags); + + /** + * Wrap this object into NativeWith to implement the with statement. + */ + public abstract NativeWith enterWith(Scriptable scope); + + /** + * Wrap this object into NativeWith to implement the .() query. + */ + public abstract NativeWith enterDotQuery(Scriptable scope); + + /** + * Custom <tt>+</tt> operator. + * Should return {@link Scriptable#NOT_FOUND} if this object does not have + * custom addition operator for the given value, + * or the result of the addition operation. + * <p> + * The default implementation returns {@link Scriptable#NOT_FOUND} + * to indicate no custom addition operation. + * + * @param cx the Context object associated with the current thread. + * @param thisIsLeft if true, the object should calculate this + value + * if false, the object should calculate value + this. + * @param value the second argument for addition operation. + */ + public Object addValues(Context cx, boolean thisIsLeft, Object value) + { + return Scriptable.NOT_FOUND; + } + +} |