| products/sources/formale Sprachen/Isabelle/Tools/jEdit/dist/macros/Editing/ |
|
Quellcode-Bibliothek
© Kompilation durch diese Firma
[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]
Datei: AccessorGenerator.java Sprache: Unknown
|
/*
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package jdk.internal.reflect; import java.lang.reflect.*; import jdk.internal.misc.Unsafe; /** Shared functionality for all accessor generators */ class AccessorGenerator implements ClassFileConstants { static final Unsafe unsafe = Unsafe.getUnsafe(); // Constants because there's no way to say "short integer constant", // i.e., "1S" protected static final short S0 = (short) 0; protected static final short S1 = (short) 1; protected static final short S2 = (short) 2; protected static final short S3 = (short) 3; protected static final short S4 = (short) 4; protected static final short S5 = (short) 5; protected static final short S6 = (short) 6; // Instance variables for shared functionality between // FieldAccessorGenerator and MethodAccessorGenerator protected ClassFileAssembler asm; protected int modifiers; protected short thisClass; protected short superClass; protected short targetClass; // Common constant pool entries to FieldAccessor and MethodAccessor protected short throwableClass; protected short classCastClass; protected short nullPointerClass; protected short illegalArgumentClass; protected short invocationTargetClass; protected short initIdx; protected short initNameAndTypeIdx; protected short initStringNameAndTypeIdx; protected short nullPointerCtorIdx; protected short illegalArgumentCtorIdx; protected short illegalArgumentStringCtorIdx; protected short invocationTargetCtorIdx; protected short superCtorIdx; protected short objectClass; protected short toStringIdx; protected short codeIdx; protected short exceptionsIdx; // Boxing protected short valueOfIdx; protected short booleanIdx; protected short booleanBoxIdx; protected short booleanUnboxIdx; protected short byteIdx; protected short byteBoxIdx; protected short byteUnboxIdx; protected short characterIdx; protected short characterBoxIdx; protected short characterUnboxIdx; protected short doubleIdx; protected short doubleBoxIdx; protected short doubleUnboxIdx; protected short floatIdx; protected short floatBoxIdx; protected short floatUnboxIdx; protected short integerIdx; protected short integerBoxIdx; protected short integerUnboxIdx; protected short longIdx; protected short longBoxIdx; protected short longUnboxIdx; protected short shortIdx; protected short shortBoxIdx; protected short shortUnboxIdx; protected final short NUM_COMMON_CPOOL_ENTRIES = (short) 30; protected final short NUM_BOXING_CPOOL_ENTRIES = (short) 73; // Requires that superClass has been set up protected void emitCommonConstantPoolEntries() { // + [UTF-8] "java/lang/Throwable" // + [CONSTANT_Class_info] for above // + [UTF-8] "java/lang/ClassCastException" // + [CONSTANT_Class_info] for above // + [UTF-8] "java/lang/NullPointerException" // + [CONSTANT_Class_info] for above // + [UTF-8] "java/lang/IllegalArgumentException" // + [CONSTANT_Class_info] for above // + [UTF-8] "java/lang/InvocationTargetException" // + [CONSTANT_Class_info] for above // + [UTF-8] "<init>" // + [UTF-8] "()V" // + [CONSTANT_NameAndType_info] for above // + [CONSTANT_Methodref_info] for NullPointerException's constructor // + [CONSTANT_Methodref_info] for IllegalArgumentException's constructor // + [UTF-8] "(Ljava/lang/String;)V" // + [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/String;)V" // + [CONSTANT_Methodref_info] for IllegalArgumentException's constructor taking a Strin // + [UTF-8] "(Ljava/lang/Throwable;)V" // + [CONSTANT_NameAndType_info] for "<init>(Ljava/lang/Throwable;)V" // + [CONSTANT_Methodref_info] for InvocationTargetException's constructor // + [CONSTANT_Methodref_info] for "super()" // + [UTF-8] "java/lang/Object" // + [CONSTANT_Class_info] for above // + [UTF-8] "toString" // + [UTF-8] "()Ljava/lang/String;" // + [CONSTANT_NameAndType_info] for "toString()Ljava/lang/String;" // + [CONSTANT_Methodref_info] for Object's toString method // + [UTF-8] "Code" // + [UTF-8] "Exceptions" asm.emitConstantPoolUTF8("java/lang/Throwable"); asm.emitConstantPoolClass(asm.cpi()); throwableClass = asm.cpi(); asm.emitConstantPoolUTF8("java/lang/ClassCastException"); asm.emitConstantPoolClass(asm.cpi()); classCastClass = asm.cpi(); asm.emitConstantPoolUTF8("java/lang/NullPointerException"); asm.emitConstantPoolClass(asm.cpi()); nullPointerClass = asm.cpi(); asm.emitConstantPoolUTF8("java/lang/IllegalArgumentException"); asm.emitConstantPoolClass(asm.cpi()); illegalArgumentClass = asm.cpi(); asm.emitConstantPoolUTF8("java/lang/reflect/InvocationTargetException"); asm.emitConstantPoolClass(asm.cpi()); invocationTargetClass = asm.cpi(); asm.emitConstantPoolUTF8(" initIdx = asm.cpi(); asm.emitConstantPoolUTF8("()V"); asm.emitConstantPoolNameAndType(initIdx, asm.cpi()); initNameAndTypeIdx = asm.cpi(); asm.emitConstantPoolMethodref(nullPointerClass, initNameAndTypeIdx); nullPointerCtorIdx = asm.cpi(); asm.emitConstantPoolMethodref(illegalArgumentClass, initNameAndTypeIdx); illegalArgumentCtorIdx = asm.cpi(); asm.emitConstantPoolUTF8("(Ljava/lang/String;)V"); asm.emitConstantPoolNameAndType(initIdx, asm.cpi()); initStringNameAndTypeIdx = asm.cpi(); asm.emitConstantPoolMethodref(illegalArgumentClass, initStringNameAndTypeIdx); illegalArgumentStringCtorIdx = asm.cpi(); asm.emitConstantPoolUTF8("(Ljava/lang/Throwable;)V"); asm.emitConstantPoolNameAndType(initIdx, asm.cpi()); asm.emitConstantPoolMethodref(invocationTargetClass, asm.cpi()); invocationTargetCtorIdx = asm.cpi(); asm.emitConstantPoolMethodref(superClass, initNameAndTypeIdx); superCtorIdx = asm.cpi(); asm.emitConstantPoolUTF8("java/lang/Object"); asm.emitConstantPoolClass(asm.cpi()); objectClass = asm.cpi(); asm.emitConstantPoolUTF8("toString"); asm.emitConstantPoolUTF8("()Ljava/lang/String;"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(objectClass, asm.cpi()); toStringIdx = asm.cpi(); asm.emitConstantPoolUTF8("Code"); codeIdx = asm.cpi(); asm.emitConstantPoolUTF8("Exceptions"); exceptionsIdx = asm.cpi(); } /** Constant pool entries required to be able to box/unbox primitive types. Note that we don't emit these if we don't need them. */ protected void emitBoxingContantPoolEntries() { // * [UTF-8] "valueOf" // * [UTF-8] "java/lang/Boolean" // * [CONSTANT_Class_info] for above // * [UTF-8] "(Z)Ljava/lang/Boolean;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "booleanValue" // * [UTF-8] "()Z" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Byte" // * [CONSTANT_Class_info] for above // * [UTF-8] "(B)Ljava/lang/Byte;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "byteValue" // * [UTF-8] "()B" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Character" // * [CONSTANT_Class_info] for above // * [UTF-8] "(C)Ljava/lang/Character;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "charValue" // * [UTF-8] "()C" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Double" // * [CONSTANT_Class_info] for above // * [UTF-8] "(D)Ljava/lang/Double;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "doubleValue" // * [UTF-8] "()D" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Float" // * [CONSTANT_Class_info] for above // * [UTF-8] "(F)Ljava/lang/Float;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "floatValue" // * [UTF-8] "()F" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Integer" // * [CONSTANT_Class_info] for above // * [UTF-8] "(I)Ljava/lang/Integer;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "intValue" // * [UTF-8] "()I" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Long" // * [CONSTANT_Class_info] for above // * [UTF-8] "(J)Ljava/lang/Long;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "longValue" // * [UTF-8] "()J" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "java/lang/Short" // * [CONSTANT_Class_info] for above // * [UTF-8] "(S)Ljava/lang/Short;" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // * [UTF-8] "shortValue" // * [UTF-8] "()S" // * [CONSTANT_NameAndType_info] for above // * [CONSTANT_Methodref_info] for above // valueOf-method name asm.emitConstantPoolUTF8("valueOf"); valueOfIdx = asm.cpi(); // Boolean asm.emitConstantPoolUTF8("java/lang/Boolean"); asm.emitConstantPoolClass(asm.cpi()); booleanIdx = asm.cpi(); asm.emitConstantPoolUTF8("(Z)Ljava/lang/Boolean;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); booleanBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("booleanValue"); asm.emitConstantPoolUTF8("()Z"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); booleanUnboxIdx = asm.cpi(); // Byte asm.emitConstantPoolUTF8("java/lang/Byte"); asm.emitConstantPoolClass(asm.cpi()); byteIdx = asm.cpi(); asm.emitConstantPoolUTF8("(B)Ljava/lang/Byte;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); byteBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("byteValue"); asm.emitConstantPoolUTF8("()B"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); byteUnboxIdx = asm.cpi(); // Character asm.emitConstantPoolUTF8("java/lang/Character"); asm.emitConstantPoolClass(asm.cpi()); characterIdx = asm.cpi(); asm.emitConstantPoolUTF8("(C)Ljava/lang/Character;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); characterBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("charValue"); asm.emitConstantPoolUTF8("()C"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); characterUnboxIdx = asm.cpi(); // Double asm.emitConstantPoolUTF8("java/lang/Double"); asm.emitConstantPoolClass(asm.cpi()); doubleIdx = asm.cpi(); asm.emitConstantPoolUTF8("(D)Ljava/lang/Double;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); doubleBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("doubleValue"); asm.emitConstantPoolUTF8("()D"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); doubleUnboxIdx = asm.cpi(); // Float asm.emitConstantPoolUTF8("java/lang/Float"); asm.emitConstantPoolClass(asm.cpi()); floatIdx = asm.cpi(); asm.emitConstantPoolUTF8("(F)Ljava/lang/Float;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); floatBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("floatValue"); asm.emitConstantPoolUTF8("()F"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); floatUnboxIdx = asm.cpi(); // Integer asm.emitConstantPoolUTF8("java/lang/Integer"); asm.emitConstantPoolClass(asm.cpi()); integerIdx = asm.cpi(); asm.emitConstantPoolUTF8("(I)Ljava/lang/Integer;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); integerBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("intValue"); asm.emitConstantPoolUTF8("()I"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); integerUnboxIdx = asm.cpi(); // Long asm.emitConstantPoolUTF8("java/lang/Long"); asm.emitConstantPoolClass(asm.cpi()); longIdx = asm.cpi(); asm.emitConstantPoolUTF8("(J)Ljava/lang/Long;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); longBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("longValue"); asm.emitConstantPoolUTF8("()J"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); longUnboxIdx = asm.cpi(); // Short asm.emitConstantPoolUTF8("java/lang/Short"); asm.emitConstantPoolClass(asm.cpi()); shortIdx = asm.cpi(); asm.emitConstantPoolUTF8("(S)Ljava/lang/Short;"); asm.emitConstantPoolNameAndType(valueOfIdx, asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S2), asm.cpi()); shortBoxIdx = asm.cpi(); asm.emitConstantPoolUTF8("shortValue"); asm.emitConstantPoolUTF8("()S"); asm.emitConstantPoolNameAndType(sub(asm.cpi(), S1), asm.cpi()); asm.emitConstantPoolMethodref(sub(asm.cpi(), S6), asm.cpi()); shortUnboxIdx = asm.cpi(); } // Necessary because of Java's annoying promotion rules protected static short add(short s1, short s2) { return (short) (s1 + s2); } protected static short sub(short s1, short s2) { return (short) (s1 - s2); } protected boolean isStatic() { return Modifier.isStatic(modifiers); } protected boolean isPrivate() { return Modifier.isPrivate(modifiers); } /** Returns class name in "internal" form (i.e., '/' separators instead of '.') */ protected static String getClassName (Class<?> c, boolean addPrefixAndSuffixForNonPrimitiveTypes) { if (c.isPrimitive()) { if (c == Boolean.TYPE) { return "Z"; } else if (c == Byte.TYPE) { return "B"; } else if (c == Character.TYPE) { return "C"; } else if (c == Double.TYPE) { return "D"; } else if (c == Float.TYPE) { return "F"; } else if (c == Integer.TYPE) { return "I"; } else if (c == Long.TYPE) { return "J"; } else if (c == Short.TYPE) { return "S"; } else if (c == Void.TYPE) { return "V"; } throw new InternalError("Should have found primitive type"); } else if (c.isArray()) { return "[" + getClassName(c.getComponentType(), true); } else { if (addPrefixAndSuffixForNonPrimitiveTypes) { return internalize("L" + c.getName() + ";"); } else { return internalize(c.getName()); } } } private static String internalize(String className) { return className.replace('.', '/'); } protected void emitConstructor() { // Generate code into fresh code buffer ClassFileAssembler cb = new ClassFileAssembler(); // 0 incoming arguments cb.setMaxLocals(1); cb.opc_aload_0(); cb.opc_invokespecial(superCtorIdx, 0, 0); cb.opc_return(); // Emit method emitMethod(initIdx, cb.getMaxLocals(), cb, null, null); } // The descriptor's index in the constant pool must be (1 + // nameIdx). "numArgs" must indicate ALL arguments, including the // implicit "this" argument; double and long arguments each count // as 2 in this count. The code buffer must NOT contain the code // length. The exception table may be null, but if non-null must // NOT contain the exception table's length. The checked exception // indices may be null. protected void emitMethod(short nameIdx, int numArgs, ClassFileAssembler code, ClassFileAssembler exceptionTable, short[] checkedExceptionIndices) { int codeLen = code.getLength(); int excLen = 0; if (exceptionTable != null) { excLen = exceptionTable.getLength(); if ((excLen % 8) != 0) { throw new IllegalArgumentException("Illegal exception table"); } } int attrLen = 12 + codeLen + excLen; excLen = excLen / 8; // No-op if no exception table asm.emitShort(ACC_PUBLIC); asm.emitShort(nameIdx); asm.emitShort(add(nameIdx, S1)); if (checkedExceptionIndices == null) { // Code attribute only asm.emitShort(S1); } else { // Code and Exceptions attributes asm.emitShort(S2); } // Code attribute asm.emitShort(codeIdx); asm.emitInt(attrLen); asm.emitShort(code.getMaxStack()); asm.emitShort((short) Math.max(numArgs, code.getMaxLocals())); asm.emitInt(codeLen); asm.append(code); asm.emitShort((short) excLen); if (exceptionTable != null) { asm.append(exceptionTable); } asm.emitShort(S0); // No additional attributes for Code attribute if (checkedExceptionIndices != null) { // Exceptions attribute asm.emitShort(exceptionsIdx); asm.emitInt(2 + 2 * checkedExceptionIndices.length); asm.emitShort((short) checkedExceptionIndices.length); for (int i = 0; i < checkedExceptionIndices.length; i++) { asm.emitShort(checkedExceptionIndices[i]); } } } protected short indexForPrimitiveType(Class<?> type) { if (type == Boolean.TYPE) { return booleanIdx; } else if (type == Byte.TYPE) { return byteIdx; } else if (type == Character.TYPE) { return characterIdx; } else if (type == Double.TYPE) { return doubleIdx; } else if (type == Float.TYPE) { return floatIdx; } else if (type == Integer.TYPE) { return integerIdx; } else if (type == Long.TYPE) { return longIdx; } else if (type == Short.TYPE) { return shortIdx; } throw new InternalError("Should have found primitive type"); } protected short boxingMethodForPrimitiveType(Class<?> type) { if (type == Boolean.TYPE) { return booleanBoxIdx; } else if (type == Byte.TYPE) { return byteBoxIdx; } else if (type == Character.TYPE) { return characterBoxIdx; } else if (type == Double.TYPE) { return doubleBoxIdx; } else if (type == Float.TYPE) { return floatBoxIdx; } else if (type == Integer.TYPE) { return integerBoxIdx; } else if (type == Long.TYPE) { return longBoxIdx; } else if (type == Short.TYPE) { return shortBoxIdx; } throw new InternalError("Should have found primitive type"); } /** Returns true for widening or identity conversions for primitive types only */ protected static boolean canWidenTo(Class<?> type, Class<?> otherType) { if (!type.isPrimitive()) { return false; } // Widening conversions (from JVM spec): // byte to short, int, long, float, or double // short to int, long, float, or double // char to int, long, float, or double // int to long, float, or double // long to float or double // float to double if (type == Boolean.TYPE) { if (otherType == Boolean.TYPE) { return true; } } else if (type == Byte.TYPE) { if ( otherType == Byte.TYPE || otherType == Short.TYPE || otherType == Integer.TYPE || otherType == Long.TYPE || otherType == Float.TYPE || otherType == Double.TYPE) { return true; } } else if (type == Short.TYPE) { if ( otherType == Short.TYPE || otherType == Integer.TYPE || otherType == Long.TYPE || otherType == Float.TYPE || otherType == Double.TYPE) { return true; } } else if (type == Character.TYPE) { if ( otherType == Character.TYPE || otherType == Integer.TYPE || otherType == Long.TYPE || otherType == Float.TYPE || otherType == Double.TYPE) { return true; } } else if (type == Integer.TYPE) { if ( otherType == Integer.TYPE || otherType == Long.TYPE || otherType == Float.TYPE || otherType == Double.TYPE) { return true; } } else if (type == Long.TYPE) { if ( otherType == Long.TYPE || otherType == Float.TYPE || otherType == Double.TYPE) { return true; } } else if (type == Float.TYPE) { if ( otherType == Float.TYPE || otherType == Double.TYPE) { return true; } } else if (type == Double.TYPE) { if (otherType == Double.TYPE) { return true; } } return false; } /** Emits the widening bytecode for the given primitive conversion (or none if the identity conversion). Requires that a primitive conversion exists; i.e., canWidenTo must have already been called and returned true. */ protected static void emitWideningBytecodeForPrimitiveConversion (ClassFileAssembler cb, Class<?> fromType, Class<?> toType) { // Note that widening conversions for integral types (i.e., "b2s", // "s2i") are no-ops since values on the Java stack are // sign-extended. // Widening conversions (from JVM spec): // byte to short, int, long, float, or double // short to int, long, float, or double // char to int, long, float, or double // int to long, float, or double // long to float or double // float to double if ( fromType == Byte.TYPE || fromType == Short.TYPE || fromType == Character.TYPE || fromType == Integer.TYPE) { if (toType == Long.TYPE) { cb.opc_i2l(); } else if (toType == Float.TYPE) { cb.opc_i2f(); } else if (toType == Double.TYPE) { cb.opc_i2d(); } } else if (fromType == Long.TYPE) { if (toType == Float.TYPE) { cb.opc_l2f(); } else if (toType == Double.TYPE) { cb.opc_l2d(); } } else if (fromType == Float.TYPE) { if (toType == Double.TYPE) { cb.opc_f2d(); } } // Otherwise, was identity or no-op conversion. Fall through. } protected short unboxingMethodForPrimitiveType(Class<?> primType) { if (primType == Boolean.TYPE) { return booleanUnboxIdx; } else if (primType == Byte.TYPE) { return byteUnboxIdx; } else if (primType == Character.TYPE) { return characterUnboxIdx; } else if (primType == Short.TYPE) { return shortUnboxIdx; } else if (primType == Integer.TYPE) { return integerUnboxIdx; } else if (primType == Long.TYPE) { return longUnboxIdx; } else if (primType == Float.TYPE) { return floatUnboxIdx; } else if (primType == Double.TYPE) { return doubleUnboxIdx; } throw new InternalError("Illegal primitive type " + primType.getName()); } protected static final Class<?>[] primitiveTypes = new Class<?>[] { Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE }; /** We don't consider "Void" to be a primitive type */ protected static boolean isPrimitive(Class<?> c) { return (c.isPrimitive() && c != Void.TYPE); } protected int typeSizeInStackSlots(Class<?> c) { if (c == Void.TYPE) { return 0; } if (c == Long.TYPE || c == Double.TYPE) { return 2; } return 1; } private ClassFileAssembler illegalArgumentCodeBuffer; protected ClassFileAssembler illegalArgumentCodeBuffer() { if (illegalArgumentCodeBuffer == null) { illegalArgumentCodeBuffer = new ClassFileAssembler(); illegalArgumentCodeBuffer.opc_new(illegalArgumentClass); illegalArgumentCodeBuffer.opc_dup(); illegalArgumentCodeBuffer.opc_invokespecial(illegalArgumentCtorIdx, 0, 0); illegalArgumentCodeBuffer.opc_athrow(); } return illegalArgumentCodeBuffer; } } [ Dauer der Verarbeitung: 0.9 Sekunden (vorverarbeitet) ] |