diff --git a/.hgtags b/.hgtags
index ebd78b314598934b2c33eb42e62246f65e619750..78d56961133618b6e9b86d0668ecf543d14a77c6 100644
--- a/.hgtags
+++ b/.hgtags
@@ -117,3 +117,4 @@ d80954a89b49fda47c0c5cace65a17f5a758b8bd jdk7-b139
9315c733fb17ddfb9fb44be7e0ffea37bf3c727d jdk7-b140
63eeefe118da18c75ba3d36266768cd1ccaaca6b jdk7-b141
312612e89ece62633f4809706dec00bcd5fe7c2d jdk7-b142
+efbf75c24b0f31847c9c403f6dc07dc80551908d jdk7-b143
diff --git a/make/sun/rmi/rmi/Makefile b/make/sun/rmi/rmi/Makefile
index 35e4163c5a8c46b95b74aedd6556356037566a34..127777229e42a8338f6cda4836e43432b5625f77 100644
--- a/make/sun/rmi/rmi/Makefile
+++ b/make/sun/rmi/rmi/Makefile
@@ -85,16 +85,21 @@ REMOTE_impls = \
sun.rmi.registry.RegistryImpl \
sun.rmi.transport.DGCImpl
-ifeq ($(PLATFORM), windows)
-build: stubs
-else # PLATFORM
-ifneq ($(ARCH_DATA_MODEL), 32)
-build: stubs
-else # ARCH_DATA_MODEL
-build: stubs bin
+#
+# The java-rmi.cgi script in bin/ only gets delivered in certain situations
+#
+BUILD_TARGETS = stubs
+ifeq ($(PLATFORM), linux)
+ BUILD_TARGETS += bin
endif
+ifeq ($(PLATFORM), solaris)
+ ifeq ($(ARCH_DATA_MODEL), 32)
+ BUILD_TARGETS += bin
+ endif
endif
+build: $(BUILD_TARGETS)
+
clean clobber:: bin.clean
diff --git a/make/sun/xawt/mapfile-vers b/make/sun/xawt/mapfile-vers
index 096bfe553264856292e9587fc67e9bb6b81f6398..8a12b69c31494a3c55a960a83f52e49c5371ab16 100644
--- a/make/sun/xawt/mapfile-vers
+++ b/make/sun/xawt/mapfile-vers
@@ -158,7 +158,6 @@ SUNWprivate_1.1 {
Java_sun_awt_X11_XRobotPeer_mouseReleaseImpl;
Java_sun_awt_X11_XRobotPeer_mouseWheelImpl;
Java_sun_awt_X11_XRobotPeer_setup;
- Java_sun_awt_X11_XRobotPeer__1dispose;
Java_sun_awt_X11_XToolkit_getNumberOfButtonsImpl;
Java_java_awt_Component_initIDs;
Java_java_awt_Container_initIDs;
diff --git a/src/share/classes/java/awt/Component.java b/src/share/classes/java/awt/Component.java
index f577887abe67c4caf7831dd385c71e25909a3427..2225633c0db5d6783b57663ae335b14fb7ed52ac 100644
--- a/src/share/classes/java/awt/Component.java
+++ b/src/share/classes/java/awt/Component.java
@@ -2887,11 +2887,12 @@ public abstract class Component implements ImageObserver, MenuContainer,
/**
* Invalidates this component and its ancestors.
*
- * All the ancestors of this component up to the nearest validate root are
- * marked invalid also. If there is no a validate root container for this
- * component, all of its ancestors up to the root of the hierarchy are
- * marked invalid as well. Marking a container invalid indicates
- * that the container needs to be laid out.
+ * By default, all the ancestors of the component up to the top-most
+ * container of the hierarchy are marked invalid. If the {@code
+ * java.awt.smartInvalidate} system property is set to {@code true},
+ * invalidation stops on the nearest validate root of this component.
+ * Marking a container invalid indicates that the container needs to
+ * be laid out.
*
* This method is called automatically when any layout-related information
* changes (e.g. setting the bounds of the component, or adding the
diff --git a/src/share/classes/java/awt/Container.java b/src/share/classes/java/awt/Container.java
index 88f0865b187128a72ef555892d04799f5189e423..c59aa90bc5f238f14ee02d9e7267366e5f4831dc 100644
--- a/src/share/classes/java/awt/Container.java
+++ b/src/share/classes/java/awt/Container.java
@@ -41,6 +41,8 @@ import java.io.ObjectStreamField;
import java.io.PrintStream;
import java.io.PrintWriter;
+import java.security.AccessController;
+
import java.util.Arrays;
import java.util.EventListener;
import java.util.HashSet;
@@ -60,6 +62,8 @@ import sun.awt.dnd.SunDropTargetEvent;
import sun.java2d.pipe.Region;
+import sun.security.action.GetBooleanAction;
+
/**
* A generic Abstract Window Toolkit(AWT) container object is a component
* that can contain other AWT components.
@@ -1506,12 +1510,18 @@ public class Container extends Component {
* Layout-related changes, such as bounds of the validate root descendants,
* do not affect the layout of the validate root parent. This peculiarity
* enables the {@code invalidate()} method to stop invalidating the
- * component hierarchy when the method encounters a validate root.
+ * component hierarchy when the method encounters a validate root. However,
+ * to preserve backward compatibility this new optimized behavior is
+ * enabled only when the {@code java.awt.smartInvalidate} system property
+ * value is set to {@code true}.
*
- * If a component hierarchy contains validate roots, the {@code validate()}
- * method must be invoked on the validate root of a previously invalidated
- * component, rather than on the top-level container (such as a {@code
- * Frame} object) to restore the validity of the hierarchy later.
+ * If a component hierarchy contains validate roots and the new optimized
+ * {@code invalidate()} behavior is enabled, the {@code validate()} method
+ * must be invoked on the validate root of a previously invalidated
+ * component to restore the validity of the hierarchy later. Otherwise,
+ * calling the {@code validate()} method on the top-level container (such
+ * as a {@code Frame} object) should be used to restore the validity of the
+ * component hierarchy.
*
* The {@code Window} class and the {@code Applet} class are the validate
* roots in AWT. Swing introduces more validate roots.
@@ -1527,13 +1537,20 @@ public class Container extends Component {
return false;
}
+ private static final boolean isJavaAwtSmartInvalidate;
+ static {
+ // Don't lazy-read because every app uses invalidate()
+ isJavaAwtSmartInvalidate = AccessController.doPrivileged(
+ new GetBooleanAction("java.awt.smartInvalidate"));
+ }
+
/**
* Invalidates the parent of the container unless the container
* is a validate root.
*/
@Override
void invalidateParent() {
- if (!isValidateRoot()) {
+ if (!isJavaAwtSmartInvalidate || !isValidateRoot()) {
super.invalidateParent();
}
}
@@ -1572,9 +1589,8 @@ public class Container extends Component {
* automatically. Note that the ancestors of the container may be
* invalidated also (see {@link Component#invalidate} for details.)
* Therefore, to restore the validity of the hierarchy, the {@code
- * validate()} method should be invoked on a validate root of an
- * invalidated component, or on the top-most container if the hierarchy
- * does not contain validate roots.
+ * validate()} method should be invoked on the top-most invalid
+ * container of the hierarchy.
*
* Validating the container may be a quite time-consuming operation. For
* performance reasons a developer may postpone the validation of the
diff --git a/src/share/classes/java/awt/Toolkit.java b/src/share/classes/java/awt/Toolkit.java
index 6e00e6afdbf260aba46d82a34b09e98b0be903f1..3ac2714dcef892da3bb4d97a96f61fa2123715bb 100644
--- a/src/share/classes/java/awt/Toolkit.java
+++ b/src/share/classes/java/awt/Toolkit.java
@@ -466,10 +466,7 @@ public abstract class Toolkit {
*/
protected void loadSystemColors(int[] systemColors)
throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
-
+ GraphicsEnvironment.checkHeadless();
}
/**
@@ -504,10 +501,7 @@ public abstract class Toolkit {
*/
public void setDynamicLayout(boolean dynamic)
throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
-
+ GraphicsEnvironment.checkHeadless();
}
/**
@@ -531,9 +525,8 @@ public abstract class Toolkit {
*/
protected boolean isDynamicLayoutSet()
throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().isDynamicLayoutSet();
} else {
@@ -569,9 +562,8 @@ public abstract class Toolkit {
*/
public boolean isDynamicLayoutActive()
throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().isDynamicLayoutActive();
} else {
@@ -615,9 +607,7 @@ public abstract class Toolkit {
*/
public Insets getScreenInsets(GraphicsConfiguration gc)
throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getScreenInsets(gc);
} else {
@@ -1200,10 +1190,7 @@ public abstract class Toolkit {
* security manager's checkPermission method with a
* RuntimePermission("queuePrintJob") permission.
*
- * @param frame the parent of the print dialog. May be null if and only
- * if jobAttributes is not null and jobAttributes.getDialog()
- * returns JobAttributes.DialogType.NONE or
- * JobAttributes.DialogType.COMMON.
+ * @param frame the parent of the print dialog. May not be null.
* @param jobtitle the title of the PrintJob. A null title is equivalent
* to "".
* @param jobAttributes a set of job attributes which will control the
@@ -1359,9 +1346,8 @@ public abstract class Toolkit {
* @since 1.4
*/
public Clipboard getSystemSelection() throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getSystemSelection();
} else {
@@ -1391,9 +1377,7 @@ public abstract class Toolkit {
* @since JDK1.1
*/
public int getMenuShortcutKeyMask() throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
return Event.CTRL_MASK;
}
@@ -1418,7 +1402,10 @@ public abstract class Toolkit {
* @since 1.3
*/
public boolean getLockingKeyState(int keyCode)
- throws UnsupportedOperationException {
+ throws UnsupportedOperationException
+ {
+ GraphicsEnvironment.checkHeadless();
+
if (! (keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
throw new IllegalArgumentException("invalid key for Toolkit.getLockingKeyState");
@@ -1449,7 +1436,10 @@ public abstract class Toolkit {
* @since 1.3
*/
public void setLockingKeyState(int keyCode, boolean on)
- throws UnsupportedOperationException {
+ throws UnsupportedOperationException
+ {
+ GraphicsEnvironment.checkHeadless();
+
if (! (keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
throw new IllegalArgumentException("invalid key for Toolkit.setLockingKeyState");
@@ -1523,9 +1513,8 @@ public abstract class Toolkit {
*/
public Dimension getBestCursorSize(int preferredWidth,
int preferredHeight) throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
// Override to implement custom cursor support.
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().
@@ -1553,9 +1542,8 @@ public abstract class Toolkit {
* @since 1.2
*/
public int getMaximumCursorColors() throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
// Override to implement custom cursor support.
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getMaximumCursorColors();
@@ -1605,9 +1593,8 @@ public abstract class Toolkit {
public boolean isFrameStateSupported(int state)
throws HeadlessException
{
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().
isFrameStateSupported(state);
@@ -2614,9 +2601,8 @@ public abstract class Toolkit {
* @since 1.7
*/
public boolean areExtraMouseButtonsEnabled() throws HeadlessException {
- if (GraphicsEnvironment.isHeadless()){
- throw new HeadlessException();
- }
+ GraphicsEnvironment.checkHeadless();
+
return Toolkit.getDefaultToolkit().areExtraMouseButtonsEnabled();
}
}
diff --git a/src/share/classes/java/lang/Throwable.java b/src/share/classes/java/lang/Throwable.java
index a42306f41ae162407e4125aa53afe4d9baf06a6d..2319aafd00fa2fab3f70b889a2f879da451f473b 100644
--- a/src/share/classes/java/lang/Throwable.java
+++ b/src/share/classes/java/lang/Throwable.java
@@ -777,7 +777,8 @@ public class Throwable implements Serializable {
* @see java.lang.Throwable#printStackTrace()
*/
public synchronized Throwable fillInStackTrace() {
- if (stackTrace != null) {
+ if (stackTrace != null ||
+ backtrace != null /* Out of protocol state */ ) {
fillInStackTrace(0);
stackTrace = UNASSIGNED_STACK;
}
@@ -817,7 +818,8 @@ public class Throwable implements Serializable {
private synchronized StackTraceElement[] getOurStackTrace() {
// Initialize stack trace field with information from
// backtrace if this is the first call to this method
- if (stackTrace == UNASSIGNED_STACK) {
+ if (stackTrace == UNASSIGNED_STACK ||
+ (stackTrace == null && backtrace != null) /* Out of protocol state */) {
int depth = getStackTraceDepth();
stackTrace = new StackTraceElement[depth];
for (int i=0; i < depth; i++)
@@ -865,7 +867,8 @@ public class Throwable implements Serializable {
}
synchronized (this) {
- if (this.stackTrace == null) // Immutable stack
+ if (this.stackTrace == null && // Immutable stack
+ backtrace == null) // Test for out of protocol state
return;
this.stackTrace = defensiveCopy;
}
diff --git a/src/share/classes/java/lang/invoke/AdapterMethodHandle.java b/src/share/classes/java/lang/invoke/AdapterMethodHandle.java
index a47b38f8bb3ec50a791ea014e37896bda8117878..a77c904eb0e94bb3b41967ecaf32171d7beac85a 100644
--- a/src/share/classes/java/lang/invoke/AdapterMethodHandle.java
+++ b/src/share/classes/java/lang/invoke/AdapterMethodHandle.java
@@ -27,6 +27,7 @@ package java.lang.invoke;
import sun.invoke.util.VerifyType;
import sun.invoke.util.Wrapper;
+import sun.invoke.util.ValueConversions;
import java.util.Arrays;
import static java.lang.invoke.MethodHandleNatives.Constants.*;
import static java.lang.invoke.MethodHandleStatics.*;
@@ -55,29 +56,35 @@ class AdapterMethodHandle extends BoundMethodHandle {
this(target, newType, conv, null);
}
+ int getConversion() { return conversion; }
+
// TO DO: When adapting another MH with a null conversion, clone
// the target and change its type, instead of adding another layer.
/** Can a JVM-level adapter directly implement the proposed
* argument conversions, as if by MethodHandles.convertArguments?
*/
- static boolean canPairwiseConvert(MethodType newType, MethodType oldType) {
+ static boolean canPairwiseConvert(MethodType newType, MethodType oldType, int level) {
// same number of args, of course
int len = newType.parameterCount();
if (len != oldType.parameterCount())
return false;
- // Check return type. (Not much can be done with it.)
+ // Check return type.
Class exp = newType.returnType();
Class ret = oldType.returnType();
- if (!VerifyType.isNullConversion(ret, exp))
- return false;
+ if (!VerifyType.isNullConversion(ret, exp)) {
+ if (!convOpSupported(OP_COLLECT_ARGS))
+ return false;
+ if (!canConvertArgument(ret, exp, level))
+ return false;
+ }
// Check args pairwise.
for (int i = 0; i < len; i++) {
Class src = newType.parameterType(i); // source type
Class dst = oldType.parameterType(i); // destination type
- if (!canConvertArgument(src, dst))
+ if (!canConvertArgument(src, dst, level))
return false;
}
@@ -87,11 +94,14 @@ class AdapterMethodHandle extends BoundMethodHandle {
/** Can a JVM-level adapter directly implement the proposed
* argument conversion, as if by MethodHandles.convertArguments?
*/
- static boolean canConvertArgument(Class src, Class dst) {
+ static boolean canConvertArgument(Class src, Class dst, int level) {
// ? Retool this logic to use RETYPE_ONLY, CHECK_CAST, etc., as opcodes,
// so we don't need to repeat so much decision making.
if (VerifyType.isNullConversion(src, dst)) {
return true;
+ } else if (convOpSupported(OP_COLLECT_ARGS)) {
+ // If we can build filters, we can convert anything to anything.
+ return true;
} else if (src.isPrimitive()) {
if (dst.isPrimitive())
return canPrimCast(src, dst);
@@ -99,7 +109,7 @@ class AdapterMethodHandle extends BoundMethodHandle {
return canBoxArgument(src, dst);
} else {
if (dst.isPrimitive())
- return canUnboxArgument(src, dst);
+ return canUnboxArgument(src, dst, level);
else
return true; // any two refs can be interconverted
}
@@ -109,21 +119,20 @@ class AdapterMethodHandle extends BoundMethodHandle {
* Create a JVM-level adapter method handle to conform the given method
* handle to the similar newType, using only pairwise argument conversions.
* For each argument, convert incoming argument to the exact type needed.
- * Only null conversions are allowed on the return value (until
- * the JVM supports ricochet adapters).
- * The argument conversions allowed are casting, unboxing,
+ * The argument conversions allowed are casting, boxing and unboxing,
* integral widening or narrowing, and floating point widening or narrowing.
* @param newType required call type
* @param target original method handle
+ * @param level which strength of conversion is allowed
* @return an adapter to the original handle with the desired new type,
* or the original target if the types are already identical
* or null if the adaptation cannot be made
*/
- static MethodHandle makePairwiseConvert(MethodType newType, MethodHandle target) {
+ static MethodHandle makePairwiseConvert(MethodType newType, MethodHandle target, int level) {
MethodType oldType = target.type();
if (newType == oldType) return target;
- if (!canPairwiseConvert(newType, oldType))
+ if (!canPairwiseConvert(newType, oldType, level))
return null;
// (after this point, it is an assertion error to fail to convert)
@@ -138,9 +147,14 @@ class AdapterMethodHandle extends BoundMethodHandle {
break;
}
}
+
+ Class needReturn = newType.returnType();
+ Class haveReturn = oldType.returnType();
+ boolean retConv = !VerifyType.isNullConversion(haveReturn, needReturn);
+
// Now build a chain of one or more adapters.
- MethodHandle adapter = target;
- MethodType midType = oldType.changeReturnType(newType.returnType());
+ MethodHandle adapter = target, adapter2;
+ MethodType midType = oldType;
for (int i = 0; i <= lastConv; i++) {
Class src = newType.parameterType(i); // source type
Class dst = midType.parameterType(i); // destination type
@@ -149,22 +163,23 @@ class AdapterMethodHandle extends BoundMethodHandle {
continue;
}
// Work the current type backward toward the desired caller type:
- if (i != lastConv) {
- midType = midType.changeParameterType(i, src);
- } else {
+ midType = midType.changeParameterType(i, src);
+ if (i == lastConv) {
// When doing the last (or only) real conversion,
// force all remaining null conversions to happen also.
- assert(VerifyType.isNullConversion(newType, midType.changeParameterType(i, src)));
- midType = newType;
+ MethodType lastMidType = newType;
+ if (retConv) lastMidType = lastMidType.changeReturnType(haveReturn);
+ assert(VerifyType.isNullConversion(lastMidType, midType));
+ midType = lastMidType;
}
// Tricky case analysis follows.
// It parallels canConvertArgument() above.
if (src.isPrimitive()) {
if (dst.isPrimitive()) {
- adapter = makePrimCast(midType, adapter, i, dst);
+ adapter2 = makePrimCast(midType, adapter, i, dst);
} else {
- adapter = makeBoxArgument(midType, adapter, i, dst);
+ adapter2 = makeBoxArgument(midType, adapter, i, src);
}
} else {
if (dst.isPrimitive()) {
@@ -174,29 +189,53 @@ class AdapterMethodHandle extends BoundMethodHandle {
// conversions supported by reflect.Method.invoke.
// Those conversions require a big nest of if/then/else logic,
// which we prefer to make a user responsibility.
- adapter = makeUnboxArgument(midType, adapter, i, dst);
+ adapter2 = makeUnboxArgument(midType, adapter, i, dst, level);
} else {
// Simple reference conversion.
// Note: Do not check for a class hierarchy relation
// between src and dst. In all cases a 'null' argument
// will pass the cast conversion.
- adapter = makeCheckCast(midType, adapter, i, dst);
+ adapter2 = makeCheckCast(midType, adapter, i, dst);
}
}
- assert(adapter != null);
- assert(adapter.type() == midType);
+ assert(adapter2 != null) : Arrays.asList(src, dst, midType, adapter, i, target, newType);
+ assert(adapter2.type() == midType);
+ adapter = adapter2;
+ }
+ if (retConv) {
+ adapter2 = makeReturnConversion(adapter, haveReturn, needReturn);
+ assert(adapter2 != null);
+ adapter = adapter2;
}
if (adapter.type() != newType) {
// Only trivial conversions remain.
- adapter = makeRetypeOnly(newType, adapter);
- assert(adapter != null);
+ adapter2 = makeRetypeOnly(newType, adapter);
+ assert(adapter2 != null);
+ adapter = adapter2;
// Actually, that's because there were no non-trivial ones:
- assert(lastConv == -1);
+ assert(lastConv == -1 || retConv);
}
assert(adapter.type() == newType);
return adapter;
}
+ private static MethodHandle makeReturnConversion(MethodHandle target, Class haveReturn, Class needReturn) {
+ MethodHandle adjustReturn;
+ if (haveReturn == void.class) {
+ // synthesize a zero value for the given void
+ Object zero = Wrapper.forBasicType(needReturn).zero();
+ adjustReturn = MethodHandles.constant(needReturn, zero);
+ } else {
+ MethodType needConversion = MethodType.methodType(needReturn, haveReturn);
+ adjustReturn = MethodHandles.identity(needReturn).asType(needConversion);
+ }
+ if (!canCollectArguments(adjustReturn.type(), target.type(), 0, false)) {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated
+ throw new InternalError("NYI");
+ }
+ return makeCollectArguments(adjustReturn, target, 0, false);
+ }
+
/**
* Create a JVM-level adapter method handle to permute the arguments
* of the given method.
@@ -224,7 +263,7 @@ class AdapterMethodHandle extends BoundMethodHandle {
if (argumentMap.length != oldType.parameterCount())
throw newIllegalArgumentException("bad permutation: "+Arrays.toString(argumentMap));
if (nullPermutation) {
- MethodHandle res = makePairwiseConvert(newType, target);
+ MethodHandle res = makePairwiseConvert(newType, target, 0);
// well, that was easy
if (res == null)
throw newIllegalArgumentException("cannot convert pairwise: "+newType);
@@ -310,11 +349,25 @@ class AdapterMethodHandle extends BoundMethodHandle {
return (spChange & CONV_STACK_MOVE_MASK) << CONV_STACK_MOVE_SHIFT;
}
+ static int extractStackMove(int convOp) {
+ int spChange = convOp >> CONV_STACK_MOVE_SHIFT;
+ return spChange / MethodHandleNatives.JVM_STACK_MOVE_UNIT;
+ }
+
+ static int extractStackMove(MethodHandle target) {
+ if (target instanceof AdapterMethodHandle) {
+ AdapterMethodHandle amh = (AdapterMethodHandle) target;
+ return extractStackMove(amh.getConversion());
+ } else {
+ return 0;
+ }
+ }
+
/** Construct an adapter conversion descriptor for a single-argument conversion. */
private static long makeConv(int convOp, int argnum, int src, int dest) {
- assert(src == (src & 0xF));
- assert(dest == (dest & 0xF));
- assert(convOp >= OP_CHECK_CAST && convOp <= OP_PRIM_TO_REF);
+ assert(src == (src & CONV_TYPE_MASK));
+ assert(dest == (dest & CONV_TYPE_MASK));
+ assert(convOp >= OP_CHECK_CAST && convOp <= OP_PRIM_TO_REF || convOp == OP_COLLECT_ARGS);
int stackMove = type2size(dest) - type2size(src);
return ((long) argnum << 32 |
(long) convOp << CONV_OP_SHIFT |
@@ -323,11 +376,10 @@ class AdapterMethodHandle extends BoundMethodHandle {
insertStackMove(stackMove)
);
}
- private static long makeConv(int convOp, int argnum, int stackMove) {
- assert(convOp >= OP_DUP_ARGS && convOp <= OP_SPREAD_ARGS);
+ private static long makeDupConv(int convOp, int argnum, int stackMove) {
+ // simple argument motion, requiring one slot to specify
+ assert(convOp == OP_DUP_ARGS || convOp == OP_DROP_ARGS);
byte src = 0, dest = 0;
- if (convOp >= OP_COLLECT_ARGS && convOp <= OP_SPREAD_ARGS)
- src = dest = T_OBJECT;
return ((long) argnum << 32 |
(long) convOp << CONV_OP_SHIFT |
(int) src << CONV_SRC_TYPE_SHIFT |
@@ -336,7 +388,8 @@ class AdapterMethodHandle extends BoundMethodHandle {
);
}
private static long makeSwapConv(int convOp, int srcArg, byte type, int destSlot) {
- assert(convOp >= OP_SWAP_ARGS && convOp <= OP_ROT_ARGS);
+ // more complex argument motion, requiring two slots to specify
+ assert(convOp == OP_SWAP_ARGS || convOp == OP_ROT_ARGS);
return ((long) srcArg << 32 |
(long) convOp << CONV_OP_SHIFT |
(int) type << CONV_SRC_TYPE_SHIFT |
@@ -344,6 +397,18 @@ class AdapterMethodHandle extends BoundMethodHandle {
(int) destSlot << CONV_VMINFO_SHIFT
);
}
+ private static long makeSpreadConv(int convOp, int argnum, int src, int dest, int stackMove) {
+ // spreading or collecting, at a particular slot location
+ assert(convOp == OP_SPREAD_ARGS || convOp == OP_COLLECT_ARGS || convOp == OP_FOLD_ARGS);
+ // src = spread ? T_OBJECT (for array) : common type of collected args (else void)
+ // dest = spread ? element type of array : result type of collector (can be void)
+ return ((long) argnum << 32 |
+ (long) convOp << CONV_OP_SHIFT |
+ (int) src << CONV_SRC_TYPE_SHIFT |
+ (int) dest << CONV_DEST_TYPE_SHIFT |
+ insertStackMove(stackMove)
+ );
+ }
private static long makeConv(int convOp) {
assert(convOp == OP_RETYPE_ONLY || convOp == OP_RETYPE_RAW);
return ((long)-1 << 32) | (convOp << CONV_OP_SHIFT); // stackMove, src, dst all zero
@@ -570,14 +635,10 @@ class AdapterMethodHandle extends BoundMethodHandle {
static boolean canPrimCast(Class src, Class dst) {
if (src == dst || !src.isPrimitive() || !dst.isPrimitive()) {
return false;
- } else if (Wrapper.forPrimitiveType(dst).isFloating()) {
- // both must be floating types
- return Wrapper.forPrimitiveType(src).isFloating();
} else {
- // both are integral, and all combinations work fine
- assert(Wrapper.forPrimitiveType(src).isIntegral() &&
- Wrapper.forPrimitiveType(dst).isIntegral());
- return true;
+ boolean sflt = Wrapper.forPrimitiveType(src).isFloating();
+ boolean dflt = Wrapper.forPrimitiveType(dst).isFloating();
+ return !(sflt | dflt); // no float support at present
}
}
@@ -589,6 +650,29 @@ class AdapterMethodHandle extends BoundMethodHandle {
*/
static MethodHandle makePrimCast(MethodType newType, MethodHandle target,
int arg, Class convType) {
+ Class src = newType.parameterType(arg);
+ if (canPrimCast(src, convType))
+ return makePrimCastOnly(newType, target, arg, convType);
+ Class dst = convType;
+ boolean sflt = Wrapper.forPrimitiveType(src).isFloating();
+ boolean dflt = Wrapper.forPrimitiveType(dst).isFloating();
+ if (sflt | dflt) {
+ MethodHandle convMethod;
+ if (sflt)
+ convMethod = ((src == double.class)
+ ? ValueConversions.convertFromDouble(dst)
+ : ValueConversions.convertFromFloat(dst));
+ else
+ convMethod = ((dst == double.class)
+ ? ValueConversions.convertToDouble(src)
+ : ValueConversions.convertToFloat(src));
+ long conv = makeConv(OP_COLLECT_ARGS, arg, basicType(src), basicType(dst));
+ return new AdapterMethodHandle(target, newType, conv, convMethod);
+ }
+ throw new InternalError("makePrimCast");
+ }
+ static MethodHandle makePrimCastOnly(MethodType newType, MethodHandle target,
+ int arg, Class convType) {
MethodType oldType = target.type();
if (!canPrimCast(newType, oldType, arg, convType))
return null;
@@ -602,7 +686,7 @@ class AdapterMethodHandle extends BoundMethodHandle {
* The convType is the unboxed type; it can be either a primitive or wrapper.
*/
static boolean canUnboxArgument(MethodType newType, MethodType targetType,
- int arg, Class convType) {
+ int arg, Class convType, int level) {
if (!convOpSupported(OP_REF_TO_PRIM)) return false;
Class src = newType.parameterType(arg);
Class dst = targetType.parameterType(arg);
@@ -616,21 +700,31 @@ class AdapterMethodHandle extends BoundMethodHandle {
return (diff == arg+1); // arg is sole non-trivial diff
}
/** Can an primitive unboxing adapter validly convert src to dst? */
- static boolean canUnboxArgument(Class src, Class dst) {
- return (!src.isPrimitive() && Wrapper.asPrimitiveType(dst).isPrimitive());
+ static boolean canUnboxArgument(Class src, Class dst, int level) {
+ assert(dst.isPrimitive());
+ // if we have JVM support for boxing, we can also do complex unboxing
+ if (convOpSupported(OP_PRIM_TO_REF)) return true;
+ Wrapper dw = Wrapper.forPrimitiveType(dst);
+ // Level 0 means cast and unbox. This works on any reference.
+ if (level == 0) return !src.isPrimitive();
+ assert(level >= 0 && level <= 2);
+ // Levels 1 and 2 allow widening and/or narrowing conversions.
+ // These are not supported directly by the JVM.
+ // But if the input reference is monomorphic, we can do it.
+ return dw.wrapperType() == src;
}
/** Factory method: Unbox the given argument.
* Return null if this cannot be done.
*/
static MethodHandle makeUnboxArgument(MethodType newType, MethodHandle target,
- int arg, Class convType) {
+ int arg, Class convType, int level) {
MethodType oldType = target.type();
Class src = newType.parameterType(arg);
Class dst = oldType.parameterType(arg);
Class boxType = Wrapper.asWrapperType(convType);
Class primType = Wrapper.asPrimitiveType(convType);
- if (!canUnboxArgument(newType, oldType, arg, convType))
+ if (!canUnboxArgument(newType, oldType, arg, convType, level))
return null;
MethodType castDone = newType;
if (!VerifyType.isNullConversion(src, boxType))
@@ -642,19 +736,46 @@ class AdapterMethodHandle extends BoundMethodHandle {
return makeCheckCast(newType, adapter, arg, boxType);
}
+ /** Can a boxing conversion validly convert src to dst? */
+ static boolean canBoxArgument(MethodType newType, MethodType targetType,
+ int arg, Class convType) {
+ if (!convOpSupported(OP_PRIM_TO_REF)) return false;
+ Class src = newType.parameterType(arg);
+ Class dst = targetType.parameterType(arg);
+ Class boxType = Wrapper.asWrapperType(convType);
+ convType = Wrapper.asPrimitiveType(convType);
+ if (!canCheckCast(boxType, dst)
+ || boxType == convType
+ || !VerifyType.isNullConversion(src, convType))
+ return false;
+ int diff = diffTypes(newType, targetType, false);
+ return (diff == arg+1); // arg is sole non-trivial diff
+ }
+
/** Can an primitive boxing adapter validly convert src to dst? */
static boolean canBoxArgument(Class src, Class dst) {
if (!convOpSupported(OP_PRIM_TO_REF)) return false;
- throw new UnsupportedOperationException("NYI");
+ return (src.isPrimitive() && !dst.isPrimitive());
}
- /** Factory method: Unbox the given argument.
+ /** Factory method: Box the given argument.
* Return null if this cannot be done.
*/
static MethodHandle makeBoxArgument(MethodType newType, MethodHandle target,
int arg, Class convType) {
- // this is difficult to do in the JVM because it must GC
- return null;
+ MethodType oldType = target.type();
+ Class src = newType.parameterType(arg);
+ Class dst = oldType.parameterType(arg);
+ Class boxType = Wrapper.asWrapperType(convType);
+ Class primType = Wrapper.asPrimitiveType(convType);
+ if (!canBoxArgument(newType, oldType, arg, convType)) {
+ return null;
+ }
+ if (!VerifyType.isNullConversion(boxType, dst))
+ target = makeCheckCast(oldType.changeParameterType(arg, boxType), target, arg, dst);
+ MethodHandle boxerMethod = ValueConversions.box(Wrapper.forPrimitiveType(primType));
+ long conv = makeConv(OP_PRIM_TO_REF, arg, basicType(primType), T_OBJECT);
+ return new AdapterMethodHandle(target, newType, conv, boxerMethod);
}
/** Can an adapter simply drop arguments to convert the target to newType? */
@@ -699,7 +820,7 @@ class AdapterMethodHandle extends BoundMethodHandle {
int slotCount = keep1InSlot - dropSlot;
assert(slotCount >= dropArgCount);
assert(target.type().parameterSlotCount() + slotCount == newType.parameterSlotCount());
- long conv = makeConv(OP_DROP_ARGS, dropArgPos + dropArgCount - 1, -slotCount);
+ long conv = makeDupConv(OP_DROP_ARGS, dropArgPos + dropArgCount - 1, -slotCount);
return new AdapterMethodHandle(target, newType, conv);
}
@@ -739,7 +860,7 @@ class AdapterMethodHandle extends BoundMethodHandle {
int keep1InSlot = newType.parameterSlotDepth(dupArgPos);
int slotCount = keep1InSlot - dupSlot;
assert(target.type().parameterSlotCount() - slotCount == newType.parameterSlotCount());
- long conv = makeConv(OP_DUP_ARGS, dupArgPos + dupArgCount - 1, slotCount);
+ long conv = makeDupConv(OP_DUP_ARGS, dupArgPos + dupArgCount - 1, slotCount);
return new AdapterMethodHandle(target, newType, conv);
}
@@ -900,7 +1021,7 @@ class AdapterMethodHandle extends BoundMethodHandle {
for (int i = 0; i < spreadArgCount; i++) {
Class src = VerifyType.spreadArgElementType(spreadArgType, i);
Class dst = targetType.parameterType(spreadArgPos + i);
- if (src == null || !VerifyType.isNullConversion(src, dst))
+ if (src == null || !canConvertArgument(src, dst, 1))
return false;
}
return true;
@@ -910,24 +1031,100 @@ class AdapterMethodHandle extends BoundMethodHandle {
/** Factory method: Spread selected argument. */
static MethodHandle makeSpreadArguments(MethodType newType, MethodHandle target,
Class spreadArgType, int spreadArgPos, int spreadArgCount) {
+ // FIXME: Get rid of newType; derive new arguments from structure of spreadArgType
MethodType targetType = target.type();
if (!canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount))
return null;
+ // dest is not significant; remove?
+ int dest = T_VOID;
+ for (int i = 0; i < spreadArgCount; i++) {
+ Class arg = VerifyType.spreadArgElementType(spreadArgType, i);
+ if (arg == null) arg = Object.class;
+ int dest2 = basicType(arg);
+ if (dest == T_VOID) dest = dest2;
+ else if (dest != dest2) dest = T_VOID;
+ if (dest == T_VOID) break;
+ targetType = targetType.changeParameterType(spreadArgPos + i, arg);
+ }
+ target = target.asType(targetType);
+ int arrayArgSize = 1; // always a reference
// in arglist: [0: ...keep1 | spos: spreadArg | spos+1: keep2... ]
// out arglist: [0: ...keep1 | spos: spread... | spos+scount: keep2... ]
int keep2OutPos = spreadArgPos + spreadArgCount;
- int spreadSlot = targetType.parameterSlotDepth(keep2OutPos);
- int keep1OutSlot = targetType.parameterSlotDepth(spreadArgPos);
- int slotCount = keep1OutSlot - spreadSlot;
- assert(spreadSlot == newType.parameterSlotDepth(spreadArgPos+1));
+ int keep1OutSlot = targetType.parameterSlotDepth(spreadArgPos); // leading edge of |spread...|
+ int spreadSlot = targetType.parameterSlotDepth(keep2OutPos); // trailing edge of |spread...|
+ assert(spreadSlot == newType.parameterSlotDepth(spreadArgPos+arrayArgSize));
+ int slotCount = keep1OutSlot - spreadSlot; // slots in |spread...|
assert(slotCount >= spreadArgCount);
- long conv = makeConv(OP_SPREAD_ARGS, spreadArgPos, slotCount-1);
+ int stackMove = - arrayArgSize + slotCount; // pop array, push N slots
+ long conv = makeSpreadConv(OP_SPREAD_ARGS, spreadArgPos, T_OBJECT, dest, stackMove);
MethodHandle res = new AdapterMethodHandle(target, newType, conv, spreadArgType);
assert(res.type().parameterType(spreadArgPos) == spreadArgType);
return res;
}
- // TO DO: makeCollectArguments, makeFlyby, makeRicochet
+ /** Can an adapter collect a series of arguments, replacing them by zero or one results? */
+ static boolean canCollectArguments(MethodType targetType,
+ MethodType collectorType, int collectArgPos, boolean retainOriginalArgs) {
+ if (!convOpSupported(retainOriginalArgs ? OP_FOLD_ARGS : OP_COLLECT_ARGS)) return false;
+ int collectArgCount = collectorType.parameterCount();
+ Class rtype = collectorType.returnType();
+ assert(rtype == void.class || targetType.parameterType(collectArgPos) == rtype)
+ // [(Object)Object[], (Object[])Object[], 0, 1]
+ : Arrays.asList(targetType, collectorType, collectArgPos, collectArgCount)
+ ;
+ return true;
+ }
+
+ /** Factory method: Collect or filter selected argument(s). */
+ static MethodHandle makeCollectArguments(MethodHandle target,
+ MethodHandle collector, int collectArgPos, boolean retainOriginalArgs) {
+ assert(canCollectArguments(target.type(), collector.type(), collectArgPos, retainOriginalArgs));
+ MethodType targetType = target.type();
+ MethodType collectorType = collector.type();
+ int collectArgCount = collectorType.parameterCount();
+ Class collectValType = collectorType.returnType();
+ int collectValCount = (collectValType == void.class ? 0 : 1);
+ int collectValSlots = collectorType.returnSlotCount();
+ MethodType newType = targetType
+ .dropParameterTypes(collectArgPos, collectArgPos+collectValCount);
+ if (!retainOriginalArgs) {
+ newType = newType
+ .insertParameterTypes(collectArgPos, collectorType.parameterList());
+ } else {
+ // parameter types at the fold point must be the same
+ assert(diffParamTypes(newType, collectArgPos, targetType, collectValCount, collectArgCount, false) == 0)
+ : Arrays.asList(target, collector, collectArgPos, retainOriginalArgs);
+ }
+ // in arglist: [0: ...keep1 | cpos: collect... | cpos+cacount: keep2... ]
+ // out arglist: [0: ...keep1 | cpos: collectVal? | cpos+cvcount: keep2... ]
+ // out(retain): [0: ...keep1 | cpos: cV? coll... | cpos+cvc+cac: keep2... ]
+ int keep2InPos = collectArgPos + collectArgCount;
+ int keep1InSlot = newType.parameterSlotDepth(collectArgPos); // leading edge of |collect...|
+ int collectSlot = newType.parameterSlotDepth(keep2InPos); // trailing edge of |collect...|
+ int slotCount = keep1InSlot - collectSlot; // slots in |collect...|
+ assert(slotCount >= collectArgCount);
+ assert(collectSlot == targetType.parameterSlotDepth(
+ collectArgPos + collectValCount + (retainOriginalArgs ? collectArgCount : 0) ));
+ int dest = basicType(collectValType);
+ int src = T_VOID;
+ // src is not significant; remove?
+ for (int i = 0; i < collectArgCount; i++) {
+ int src2 = basicType(collectorType.parameterType(i));
+ if (src == T_VOID) src = src2;
+ else if (src != src2) src = T_VOID;
+ if (src == T_VOID) break;
+ }
+ int stackMove = collectValSlots; // push 0..2 results
+ if (!retainOriginalArgs) stackMove -= slotCount; // pop N arguments
+ int lastCollectArg = keep2InPos-1;
+ long conv = makeSpreadConv(retainOriginalArgs ? OP_FOLD_ARGS : OP_COLLECT_ARGS,
+ lastCollectArg, src, dest, stackMove);
+ MethodHandle res = new AdapterMethodHandle(target, newType, conv, collector);
+ assert(res.type().parameterList().subList(collectArgPos, collectArgPos+collectArgCount)
+ .equals(collector.type().parameterList()));
+ return res;
+ }
@Override
public String toString() {
diff --git a/src/share/classes/java/lang/invoke/CallSite.java b/src/share/classes/java/lang/invoke/CallSite.java
index b2da146d2618c926a43a2408cae21f8a14bf5315..0924a438c8062d72db2f1122f9f8759539ccdd2e 100644
--- a/src/share/classes/java/lang/invoke/CallSite.java
+++ b/src/share/classes/java/lang/invoke/CallSite.java
@@ -273,9 +273,9 @@ public class CallSite {
Object binding;
info = maybeReBox(info);
if (info == null) {
- binding = bootstrapMethod.invokeGeneric(caller, name, type);
+ binding = bootstrapMethod.invoke(caller, name, type);
} else if (!info.getClass().isArray()) {
- binding = bootstrapMethod.invokeGeneric(caller, name, type, info);
+ binding = bootstrapMethod.invoke(caller, name, type, info);
} else {
Object[] argv = (Object[]) info;
maybeReBoxElements(argv);
@@ -283,10 +283,10 @@ public class CallSite {
throw new BootstrapMethodError("too many bootstrap method arguments");
MethodType bsmType = bootstrapMethod.type();
if (bsmType.parameterCount() == 4 && bsmType.parameterType(3) == Object[].class)
- binding = bootstrapMethod.invokeGeneric(caller, name, type, argv);
+ binding = bootstrapMethod.invoke(caller, name, type, argv);
else
binding = MethodHandles.spreadInvoker(bsmType, 3)
- .invokeGeneric(bootstrapMethod, caller, name, type, argv);
+ .invoke(bootstrapMethod, caller, name, type, argv);
}
//System.out.println("BSM for "+name+type+" => "+binding);
if (binding instanceof CallSite) {
diff --git a/src/share/classes/java/lang/invoke/FilterGeneric.java b/src/share/classes/java/lang/invoke/FilterGeneric.java
index 6c3395002f5bb37e58d8616667dbe612d5c355c9..769289710d98f63397259ec4d620e1631db7112e 100644
--- a/src/share/classes/java/lang/invoke/FilterGeneric.java
+++ b/src/share/classes/java/lang/invoke/FilterGeneric.java
@@ -61,6 +61,10 @@ class FilterGeneric {
return ad;
}
+ static {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
+ }
+
Adapter makeInstance(Kind kind, int pos, MethodHandle filter, MethodHandle target) {
Adapter ad = getAdapter(kind, pos);
return ad.makeInstance(ad.prototypeEntryPoint(), filter, target);
diff --git a/src/share/classes/java/lang/invoke/FilterOneArgument.java b/src/share/classes/java/lang/invoke/FilterOneArgument.java
index 64a9f072797c717ff4d804fa7347e564058b2534..f52c8c06f0a87bb4064e8ff1c4a7a88ededf410f 100644
--- a/src/share/classes/java/lang/invoke/FilterOneArgument.java
+++ b/src/share/classes/java/lang/invoke/FilterOneArgument.java
@@ -67,6 +67,10 @@ class FilterOneArgument extends BoundMethodHandle {
this.target = target;
}
+ static {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
+ }
+
public static MethodHandle make(MethodHandle filter, MethodHandle target) {
if (filter == null) return target;
if (target == null) return filter;
diff --git a/src/share/classes/java/lang/invoke/FromGeneric.java b/src/share/classes/java/lang/invoke/FromGeneric.java
index 1c0523a4a3668addb6b58944281ba7b245dd5a80..1e035a46fb1dfc15655e42945872c5da795796d5 100644
--- a/src/share/classes/java/lang/invoke/FromGeneric.java
+++ b/src/share/classes/java/lang/invoke/FromGeneric.java
@@ -98,6 +98,10 @@ class FromGeneric {
this.unboxingInvoker = computeUnboxingInvoker(targetType, internalType0);
}
+ static {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
+ }
+
/**
* The typed target will be called according to targetType.
* The adapter code will in fact see the raw result from internalType,
@@ -112,10 +116,10 @@ class FromGeneric {
assert(iret == Object.class);
return ValueConversions.identity();
} else if (wrap.primitiveType() == iret) {
- return ValueConversions.box(wrap, false);
+ return ValueConversions.box(wrap);
} else {
assert(tret == double.class ? iret == long.class : iret == int.class);
- return ValueConversions.boxRaw(wrap, false);
+ return ValueConversions.boxRaw(wrap);
}
}
@@ -135,7 +139,7 @@ class FromGeneric {
MethodType fixArgsType = internalType.changeReturnType(targetType.returnType());
MethodHandle fixArgs = MethodHandleImpl.convertArguments(
invoker, Invokers.invokerType(fixArgsType),
- invoker.type(), null);
+ invoker.type(), 0);
if (fixArgs == null)
throw new InternalError("bad fixArgs");
// reinterpret the calling sequence as raw:
@@ -160,7 +164,6 @@ class FromGeneric {
/** Build an adapter of the given generic type, which invokes typedTarget
* on the incoming arguments, after unboxing as necessary.
* The return value is boxed if necessary.
- * @param genericType the required type of the result
* @param typedTarget the target
* @return an adapter method handle
*/
@@ -231,7 +234,7 @@ class FromGeneric {
}
static Adapter buildAdapterFromBytecodes(MethodType internalType) {
- throw new UnsupportedOperationException("NYI");
+ throw new UnsupportedOperationException("NYI "+internalType);
}
/**
diff --git a/src/share/classes/java/lang/invoke/InvokeGeneric.java b/src/share/classes/java/lang/invoke/InvokeGeneric.java
index a235e7318da58638412e7e2ffee8782a168f99be..a747090b9a177573fbf244b25f3d5d0131e8bea1 100644
--- a/src/share/classes/java/lang/invoke/InvokeGeneric.java
+++ b/src/share/classes/java/lang/invoke/InvokeGeneric.java
@@ -29,12 +29,12 @@ import sun.invoke.util.*;
import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
/**
- * Adapters which manage MethodHandle.invokeGeneric calls.
+ * Adapters which manage inexact MethodHandle.invoke calls.
* The JVM calls one of these when the exact type match fails.
* @author jrose
*/
class InvokeGeneric {
- // erased type for the call, which originates from an invokeGeneric site
+ // erased type for the call, which originates from an inexact invoke site
private final MethodType erasedCallerType;
// an invoker of type (MT, MH; A...) -> R
private final MethodHandle initialInvoker;
@@ -56,7 +56,7 @@ class InvokeGeneric {
}
/** Return the adapter information for this type's erasure. */
- /*non-public*/ static MethodHandle genericInvokerOf(MethodType erasedCallerType) throws ReflectiveOperationException {
+ /*non-public*/ static MethodHandle generalInvokerOf(MethodType erasedCallerType) throws ReflectiveOperationException {
InvokeGeneric gen = new InvokeGeneric(erasedCallerType);
return gen.initialInvoker;
}
diff --git a/src/share/classes/java/lang/invoke/Invokers.java b/src/share/classes/java/lang/invoke/Invokers.java
index 4eeb36f76b767da10d3171c79ba9d949141cd0c5..7bf134cc8581117bf3ed9a2d413fa593bb752778 100644
--- a/src/share/classes/java/lang/invoke/Invokers.java
+++ b/src/share/classes/java/lang/invoke/Invokers.java
@@ -43,10 +43,10 @@ class Invokers {
private /*lazy*/ MethodHandle erasedInvoker;
/*lazy*/ MethodHandle erasedInvokerWithDrops; // for InvokeGeneric
- // generic (untyped) invoker for the outgoing call
- private /*lazy*/ MethodHandle genericInvoker;
+ // general invoker for the outgoing call
+ private /*lazy*/ MethodHandle generalInvoker;
- // generic (untyped) invoker for the outgoing call; accepts a single Object[]
+ // general invoker for the outgoing call; accepts a single Object[]
private final /*lazy*/ MethodHandle[] spreadInvokers;
// invoker for an unbound callsite
@@ -77,13 +77,13 @@ class Invokers {
return invoker;
}
- /*non-public*/ MethodHandle genericInvoker() {
+ /*non-public*/ MethodHandle generalInvoker() {
MethodHandle invoker1 = exactInvoker();
- MethodHandle invoker = genericInvoker;
+ MethodHandle invoker = generalInvoker;
if (invoker != null) return invoker;
- MethodType genericType = targetType.generic();
- invoker = MethodHandles.convertArguments(invoker1, invokerType(genericType));
- genericInvoker = invoker;
+ MethodType generalType = targetType.generic();
+ invoker = invoker1.asType(invokerType(generalType));
+ generalInvoker = invoker;
return invoker;
}
@@ -93,9 +93,9 @@ class Invokers {
if (invoker != null) return invoker;
MethodType erasedType = targetType.erase();
if (erasedType == targetType.generic())
- invoker = genericInvoker();
+ invoker = generalInvoker();
else
- invoker = MethodHandles.convertArguments(invoker1, invokerType(erasedType));
+ invoker = invoker1.asType(invokerType(erasedType));
erasedInvoker = invoker;
return invoker;
}
@@ -103,7 +103,7 @@ class Invokers {
/*non-public*/ MethodHandle spreadInvoker(int objectArgCount) {
MethodHandle vaInvoker = spreadInvokers[objectArgCount];
if (vaInvoker != null) return vaInvoker;
- MethodHandle gInvoker = genericInvoker();
+ MethodHandle gInvoker = generalInvoker();
vaInvoker = gInvoker.asSpreader(Object[].class, targetType.parameterCount() - objectArgCount);
spreadInvokers[objectArgCount] = vaInvoker;
return vaInvoker;
diff --git a/src/share/classes/java/lang/invoke/MemberName.java b/src/share/classes/java/lang/invoke/MemberName.java
index 0300fe758cc301c43f10e5ebe9d008d821ffc0c8..c61336d2af155f686b9abd797e3d52b111e5c87f 100644
--- a/src/share/classes/java/lang/invoke/MemberName.java
+++ b/src/share/classes/java/lang/invoke/MemberName.java
@@ -525,7 +525,7 @@ import static java.lang.invoke.MethodHandleStatics.*;
/** A factory type for resolving member names with the help of the VM.
* TBD: Define access-safe public constructors for this factory.
*/
- public static class Factory {
+ /*non-public*/ static class Factory {
private Factory() { } // singleton pattern
static Factory INSTANCE = new Factory();
diff --git a/src/share/classes/java/lang/invoke/MethodHandle.java b/src/share/classes/java/lang/invoke/MethodHandle.java
index 8165915c7bb7ece633bab771c5ad92c5f5d5d56c..e6424f1516f82128ad6ecfa5cfb268073dc7491d 100644
--- a/src/share/classes/java/lang/invoke/MethodHandle.java
+++ b/src/share/classes/java/lang/invoke/MethodHandle.java
@@ -26,6 +26,7 @@
package java.lang.invoke;
+import sun.invoke.util.ValueConversions;
import static java.lang.invoke.MethodHandleStatics.*;
/**
@@ -53,12 +54,12 @@ import static java.lang.invoke.MethodHandleStatics.*;
* and the kinds of transformations that apply to it.
*
* A method handle contains a pair of special invoker methods
- * called {@link #invokeExact invokeExact} and {@link #invokeGeneric invokeGeneric}.
+ * called {@link #invokeExact invokeExact} and {@link #invoke invoke}.
* Both invoker methods provide direct access to the method handle's
* underlying method, constructor, field, or other operation,
* as modified by transformations of arguments and return values.
* Both invokers accept calls which exactly match the method handle's own type.
- * The {@code invokeGeneric} invoker also accepts a range of other call types.
+ * The plain, inexact invoker also accepts a range of other call types.
*
* Method handles are immutable and have no visible state.
* Of course, they can be bound to underlying methods or data which exhibit state.
@@ -76,7 +77,7 @@ import static java.lang.invoke.MethodHandleStatics.*;
* may change from time to time or across implementations from different vendors.
*
*
Method handle compilation
- * A Java method call expression naming {@code invokeExact} or {@code invokeGeneric}
+ * A Java method call expression naming {@code invokeExact} or {@code invoke}
* can invoke a method handle from Java source code.
* From the viewpoint of source code, these methods can take any arguments
* and their result can be cast to any return type.
@@ -86,7 +87,7 @@ import static java.lang.invoke.MethodHandleStatics.*;
* which connects this freedom of invocation directly to the JVM execution stack.
*
* As is usual with virtual methods, source-level calls to {@code invokeExact}
- * and {@code invokeGeneric} compile to an {@code invokevirtual} instruction.
+ * and {@code invoke} compile to an {@code invokevirtual} instruction.
* More unusually, the compiler must record the actual argument types,
* and may not perform method invocation conversions on the arguments.
* Instead, it must push them on the stack according to their own unconverted types.
@@ -109,7 +110,7 @@ import static java.lang.invoke.MethodHandleStatics.*;
* The first time a {@code invokevirtual} instruction is executed
* it is linked, by symbolically resolving the names in the instruction
* and verifying that the method call is statically legal.
- * This is true of calls to {@code invokeExact} and {@code invokeGeneric}.
+ * This is true of calls to {@code invokeExact} and {@code invoke}.
* In this case, the type descriptor emitted by the compiler is checked for
* correct syntax and names it contains are resolved.
* Thus, an {@code invokevirtual} instruction which invokes
@@ -127,18 +128,18 @@ import static java.lang.invoke.MethodHandleStatics.*;
* In the case of {@code invokeExact}, the type descriptor of the invocation
* (after resolving symbolic type names) must exactly match the method type
* of the receiving method handle.
- * In the case of {@code invokeGeneric}, the resolved type descriptor
+ * In the case of plain, inexact {@code invoke}, the resolved type descriptor
* must be a valid argument to the receiver's {@link #asType asType} method.
- * Thus, {@code invokeGeneric} is more permissive than {@code invokeExact}.
+ * Thus, plain {@code invoke} is more permissive than {@code invokeExact}.
*
* After type matching, a call to {@code invokeExact} directly
* and immediately invoke the method handle's underlying method
* (or other behavior, as the case may be).
*
- * A call to {@code invokeGeneric} works the same as a call to
+ * A call to plain {@code invoke} works the same as a call to
* {@code invokeExact}, if the type descriptor specified by the caller
* exactly matches the method handle's own type.
- * If there is a type mismatch, {@code invokeGeneric} attempts
+ * If there is a type mismatch, {@code invoke} attempts
* to adjust the type of the receiving method handle,
* as if by a call to {@link #asType asType},
* to obtain an exactly invokable method handle {@code M2}.
@@ -152,7 +153,7 @@ import static java.lang.invoke.MethodHandleStatics.*;
* In typical programs, method handle type matching will usually succeed.
* But if a match fails, the JVM will throw a {@link WrongMethodTypeException},
* either directly (in the case of {@code invokeExact}) or indirectly as if
- * by a failed call to {@code asType} (in the case of {@code invokeGeneric}).
+ * by a failed call to {@code asType} (in the case of {@code invoke}).
*
* Thus, a method type mismatch which might show up as a linkage error
* in a statically typed program can show up as
@@ -249,8 +250,8 @@ assert(s.equals("savvy"));
mt = MethodType.methodType(java.util.List.class, Object[].class);
mh = lookup.findStatic(java.util.Arrays.class, "asList", mt);
assert(mh.isVarargsCollector());
-x = mh.invokeGeneric("one", "two");
-// invokeGeneric(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
+x = mh.invoke("one", "two");
+// invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
assert(x.equals(java.util.Arrays.asList("one","two")));
// mt is (Object,Object,Object)Object
mt = MethodType.genericMethodType(3);
@@ -269,12 +270,12 @@ mh = lookup.findVirtual(java.io.PrintStream.class, "println", mt);
mh.invokeExact(System.out, "Hello, world.");
// invokeExact(Ljava/io/PrintStream;Ljava/lang/String;)V
*
- * Each of the above calls to {@code invokeExact} or {@code invokeGeneric}
+ * Each of the above calls to {@code invokeExact} or plain {@code invoke}
* generates a single invokevirtual instruction with
* the type descriptor indicated in the following comment.
*
*
Exceptions
- * The methods {@code invokeExact} and {@code invokeGeneric} are declared
+ * The methods {@code invokeExact} and {@code invoke} are declared
* to throw {@link java.lang.Throwable Throwable},
* which is to say that there is no static restriction on what a method handle
* can throw. Since the JVM does not distinguish between checked
@@ -288,7 +289,7 @@ mh.invokeExact(System.out, "Hello, world.");
*
*
Signature polymorphism
* The unusual compilation and linkage behavior of
- * {@code invokeExact} and {@code invokeGeneric}
+ * {@code invokeExact} and plain {@code invoke}
* is referenced by the term signature polymorphism.
* A signature polymorphic method is one which can operate with
* any of a wide range of call signatures and return types.
@@ -322,7 +323,7 @@ mh.invokeExact(System.out, "Hello, world.");
* The following methods (and no others) are signature polymorphic:
*
* A signature polymorphic method will be declared with the following properties:
@@ -374,24 +375,34 @@ mh.invokeExact(System.out, "Hello, world.");
*
* As a special case,
* when the Core Reflection API is used to view the signature polymorphic
- * methods {@code invokeExact} or {@code invokeGeneric} in this class,
- * they appear as single, non-polymorphic native methods.
- * Calls to these native methods do not result in method handle invocations.
+ * methods {@code invokeExact} or plain {@code invoke} in this class,
+ * they appear as ordinary non-polymorphic methods.
+ * Their reflective appearance, as viewed by
+ * {@link java.lang.Class#getDeclaredMethod Class.getDeclaredMethod},
+ * is unaffected by their special status in this API.
+ * For example, {@link java.lang.reflect.Method#getModifiers Method.getModifiers}
+ * will report exactly those modifier bits required for any similarly
+ * declared method, including in this case {@code native} and {@code varargs} bits.
+ *
+ * As with any reflected method, these methods (when reflected) may be
+ * invoked via {@link java.lang.reflect.Method#invoke Method.invoke}.
+ * However, such reflective calls do not result in method handle invocations.
+ * Such a call, if passed the required argument
+ * (a single one, of type {@code Object[]}), will ignore the argument and
+ * will throw an {@code UnsupportedOperationException}.
+ *
* Since {@code invokevirtual} instructions can natively
* invoke method handles under any type descriptor, this reflective view conflicts
- * with the normal presentation via bytecodes.
- * Thus, these two native methods, as viewed by
- * {@link java.lang.Class#getDeclaredMethod Class.getDeclaredMethod},
- * are placeholders only.
- * If invoked via {@link java.lang.reflect.Method#invoke Method.invoke},
- * they will throw {@code UnsupportedOperationException}.
+ * with the normal presentation of these methods via bytecodes.
+ * Thus, these two native methods, when reflectively viewed by
+ * {@code Class.getDeclaredMethod}, may be regarded as placeholders only.
*
* In order to obtain an invoker method for a particular type descriptor,
* use {@link java.lang.invoke.MethodHandles#exactInvoker MethodHandles.exactInvoker},
- * or {@link java.lang.invoke.MethodHandles#genericInvoker MethodHandles.genericInvoker}.
+ * or {@link java.lang.invoke.MethodHandles#invoker MethodHandles.invoker}.
* The {@link java.lang.invoke.MethodHandles.Lookup#findVirtual Lookup.findVirtual}
* API is also able to return a method handle
- * to call {@code invokeExact} or {@code invokeGeneric},
+ * to call {@code invokeExact} or plain {@code invoke},
* for any specified type descriptor .
*
*
Interoperation between method handles and Java generics
@@ -523,7 +534,7 @@ public abstract class MethodHandle {
* adaptations directly on the caller's arguments,
* and call the target method handle according to its own exact type.
*
- * The type descriptor at the call site of {@code invokeGeneric} must
+ * The type descriptor at the call site of {@code invoke} must
* be a valid argument to the receivers {@code asType} method.
* In particular, the caller must specify the same argument arity
* as the callee's type,
@@ -539,11 +550,18 @@ public abstract class MethodHandle {
* @throws ClassCastException if the target's type can be adjusted to the caller, but a reference cast fails
* @throws Throwable anything thrown by the underlying method propagates unchanged through the method handle call
*/
+ public final native @PolymorphicSignature Object invoke(Object... args) throws Throwable;
+
+ /**
+ * Temporary alias for {@link #invoke}, for backward compatibility with some versions of JSR 292.
+ * On some JVMs, support can be excluded by the flags {@code -XX:+UnlockExperimentalVMOptions -XX:-AllowInvokeGeneric}.
+ * @deprecated Will be removed for JSR 292 Proposed Final Draft.
+ */
public final native @PolymorphicSignature Object invokeGeneric(Object... args) throws Throwable;
/**
* Performs a varargs invocation, passing the arguments in the given array
- * to the method handle, as if via {@link #invokeGeneric invokeGeneric} from a call site
+ * to the method handle, as if via an inexact {@link #invoke invoke} from a call site
* which mentions only the type {@code Object}, and whose arity is the length
* of the argument array.
*
@@ -553,7 +571,7 @@ public abstract class MethodHandle {
*
*
Determine the length of the argument array as {@code N}.
* For a null reference, {@code N=0}.
- *
Determine the generic type {@code TN} of {@code N} arguments as
+ *
Determine the general type {@code TN} of {@code N} arguments as
* as {@code TN=MethodType.genericMethodType(N)}.
*
Force the original target method handle {@code MH0} to the
* required type, as {@code MH1 = MH0.asType(TN)}.
@@ -580,7 +598,7 @@ public abstract class MethodHandle {
* Object result = invoker.invokeExact(this, arguments);
*
*
- * Unlike the signature polymorphic methods {@code invokeExact} and {@code invokeGeneric},
+ * Unlike the signature polymorphic methods {@code invokeExact} and {@code invoke},
* {@code invokeWithArguments} can be accessed normally via the Core Reflection API and JNI.
* It can therefore be used as a bridge between native or reflective code and method handles.
*
@@ -595,11 +613,11 @@ public abstract class MethodHandle {
int argc = arguments == null ? 0 : arguments.length;
MethodType type = type();
if (type.parameterCount() != argc) {
- // simulate invokeGeneric
+ // simulate invoke
return asType(MethodType.genericMethodType(argc)).invokeWithArguments(arguments);
}
if (argc <= 10) {
- MethodHandle invoker = type.invokers().genericInvoker();
+ MethodHandle invoker = type.invokers().generalInvoker();
switch (argc) {
case 0: return invoker.invokeExact(this);
case 1: return invoker.invokeExact(this,
@@ -644,7 +662,7 @@ public abstract class MethodHandle {
/**
* Performs a varargs invocation, passing the arguments in the given array
- * to the method handle, as if via {@link #invokeGeneric invokeGeneric} from a call site
+ * to the method handle, as if via an inexact {@link #invoke invoke} from a call site
* which mentions only the type {@code Object}, and whose arity is the length
* of the argument array.
*
@@ -672,9 +690,9 @@ public abstract class MethodHandle {
* If the original type and new type are equal, returns {@code this}.
*
* This method provides the crucial behavioral difference between
- * {@link #invokeExact invokeExact} and {@link #invokeGeneric invokeGeneric}. The two methods
+ * {@link #invokeExact invokeExact} and plain, inexact {@link #invoke invoke}. The two methods
* perform the same steps when the caller's type descriptor is identical
- * with the callee's, but when the types differ, {@link #invokeGeneric invokeGeneric}
+ * with the callee's, but when the types differ, plain {@link #invoke invoke}
* also calls {@code asType} (or some internal equivalent) in order
* to match up the caller's and callee's types.
*
@@ -689,6 +707,9 @@ public abstract class MethodHandle {
* @see MethodHandles#convertArguments
*/
public MethodHandle asType(MethodType newType) {
+ if (!type.isConvertibleTo(newType)) {
+ throw new WrongMethodTypeException("cannot convert "+type+" to "+newType);
+ }
return MethodHandles.convertArguments(this, newType);
}
@@ -731,13 +752,9 @@ public abstract class MethodHandle {
public MethodHandle asSpreader(Class arrayType, int arrayLength) {
Class arrayElement = arrayType.getComponentType();
if (arrayElement == null) throw newIllegalArgumentException("not an array type");
- MethodType oldType = type();
- int nargs = oldType.parameterCount();
+ int nargs = type().parameterCount();
if (nargs < arrayLength) throw newIllegalArgumentException("bad spread array length");
- int keepPosArgs = nargs - arrayLength;
- MethodType newType = oldType.dropParameterTypes(keepPosArgs, nargs);
- newType = newType.insertParameterTypes(keepPosArgs, arrayType);
- return MethodHandles.spreadArguments(this, newType);
+ return MethodHandleImpl.spreadArguments(this, arrayType, arrayLength);
}
/**
@@ -780,15 +797,18 @@ public abstract class MethodHandle {
* @see #asVarargsCollector
*/
public MethodHandle asCollector(Class arrayType, int arrayLength) {
+ asCollectorChecks(arrayType, arrayLength);
+ MethodHandle collector = ValueConversions.varargsArray(arrayType, arrayLength);
+ return MethodHandleImpl.collectArguments(this, type.parameterCount()-1, collector);
+ }
+
+ private void asCollectorChecks(Class arrayType, int arrayLength) {
Class arrayElement = arrayType.getComponentType();
- if (arrayElement == null) throw newIllegalArgumentException("not an array type");
- MethodType oldType = type();
- int nargs = oldType.parameterCount();
- if (nargs == 0) throw newIllegalArgumentException("no trailing argument");
- MethodType newType = oldType.dropParameterTypes(nargs-1, nargs);
- newType = newType.insertParameterTypes(nargs-1,
- java.util.Collections.>nCopies(arrayLength, arrayElement));
- return MethodHandles.collectArguments(this, newType);
+ if (arrayElement == null)
+ throw newIllegalArgumentException("not an array type", arrayType);
+ int nargs = type().parameterCount();
+ if (nargs == 0 || !type().parameterType(nargs-1).isAssignableFrom(arrayType))
+ throw newIllegalArgumentException("array type not assignable to trailing argument", this, arrayType);
}
/**
@@ -798,7 +818,7 @@ public abstract class MethodHandle {
*
* The type and behavior of the adapter will be the same as
* the type and behavior of the target, except that certain
- * {@code invokeGeneric} and {@code asType} requests can lead to
+ * {@code invoke} and {@code asType} requests can lead to
* trailing positional arguments being collected into target's
* trailing parameter.
* Also, the last parameter type of the adapter will be
@@ -812,17 +832,17 @@ public abstract class MethodHandle {
* since it accepts a whole array of indeterminate length,
* rather than a fixed number of arguments.)
*
- * When called with {@link #invokeGeneric invokeGeneric}, if the caller
+ * When called with plain, inexact {@link #invoke invoke}, if the caller
* type is the same as the adapter, the adapter invokes the target as with
* {@code invokeExact}.
- * (This is the normal behavior for {@code invokeGeneric} when types match.)
+ * (This is the normal behavior for {@code invoke} when types match.)
*
* Otherwise, if the caller and adapter arity are the same, and the
* trailing parameter type of the caller is a reference type identical to
* or assignable to the trailing parameter type of the adapter,
* the arguments and return values are converted pairwise,
* as if by {@link MethodHandles#convertArguments convertArguments}.
- * (This is also normal behavior for {@code invokeGeneric} in such a case.)
+ * (This is also normal behavior for {@code invoke} in such a case.)
*
* Otherwise, the arities differ, or the adapter's trailing parameter
* type is not assignable from the corresponding caller type.
@@ -838,7 +858,7 @@ public abstract class MethodHandle {
* where {@code N} is the arity of the target.
* Also, there must exist conversions from the incoming arguments
* to the target's arguments.
- * As with other uses of {@code invokeGeneric}, if these basic
+ * As with other uses of plain {@code invoke}, if these basic
* requirements are not fulfilled, a {@code WrongMethodTypeException}
* may be thrown.
*
@@ -856,7 +876,7 @@ public abstract class MethodHandle {
*
* The behavior of {@link #asType asType} is also specialized for
* variable arity adapters, to maintain the invariant that
- * {@code invokeGeneric} is always equivalent to an {@code asType}
+ * plain, inexact {@code invoke} is always equivalent to an {@code asType}
* call to adjust the target type, followed by {@code invokeExact}.
* Therefore, a variable arity adapter responds
* to an {@code asType} request by building a fixed arity collector,
@@ -893,12 +913,12 @@ public abstract class MethodHandle {
MethodHandle asList = publicLookup()
.findStatic(Arrays.class, "asList", methodType(List.class, Object[].class))
.asVarargsCollector(Object[].class);
-assertEquals("[]", asList.invokeGeneric().toString());
-assertEquals("[1]", asList.invokeGeneric(1).toString());
-assertEquals("[two, too]", asList.invokeGeneric("two", "too").toString());
+assertEquals("[]", asList.invoke().toString());
+assertEquals("[1]", asList.invoke(1).toString());
+assertEquals("[two, too]", asList.invoke("two", "too").toString());
Object[] argv = { "three", "thee", "tee" };
-assertEquals("[three, thee, tee]", asList.invokeGeneric(argv).toString());
-List ls = (List) asList.invokeGeneric((Object)argv);
+assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
+List ls = (List) asList.invoke((Object)argv);
assertEquals(1, ls.size());
assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));
*
@@ -926,9 +946,9 @@ MethodHandle vamh = publicLookup()
.asVarargsCollector(Object[].class);
MethodHandle mh = MethodHandles.exactInvoker(vamh.type()).bindTo(vamh);
assert(vamh.type().equals(mh.type()));
-assertEquals("[1, 2, 3]", vamh.invokeGeneric(1,2,3).toString());
+assertEquals("[1, 2, 3]", vamh.invoke(1,2,3).toString());
boolean failed = false;
-try { mh.invokeGeneric(1,2,3); }
+try { mh.invoke(1,2,3); }
catch (WrongMethodTypeException ex) { failed = true; }
assert(failed);
*
@@ -960,7 +980,7 @@ assert(failed);
*
an {@code ldc} instruction of a {@code CONSTANT_MethodHandle}
* which resolves to a variable arity Java method or constructor
*
- * @return true if this method handle accepts more than one arity of {@code invokeGeneric} calls
+ * @return true if this method handle accepts more than one arity of plain, inexact {@code invoke} calls
* @see #asVarargsCollector
*/
public boolean isVarargsCollector() {
diff --git a/src/share/classes/java/lang/invoke/MethodHandleImpl.java b/src/share/classes/java/lang/invoke/MethodHandleImpl.java
index e82442092fe0b42001167fd36cb003eb0be45fa5..b17251e47992417eb85deb209b24ce93da49c055 100644
--- a/src/share/classes/java/lang/invoke/MethodHandleImpl.java
+++ b/src/share/classes/java/lang/invoke/MethodHandleImpl.java
@@ -121,11 +121,11 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
if (nargs < INVOKES.length) {
MethodHandle invoke = INVOKES[nargs];
MethodType conType = CON_TYPES[nargs];
- MethodHandle gcon = convertArguments(rawConstructor, conType, rawConType, null);
+ MethodHandle gcon = convertArguments(rawConstructor, conType, rawConType, 0);
if (gcon == null) return null;
MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);
assert(galloc.type() == newType.generic());
- return convertArguments(galloc, newType, galloc.type(), null);
+ return convertArguments(galloc, newType, galloc.type(), 0);
} else {
MethodHandle invoke = VARARGS_INVOKE;
MethodType conType = CON_TYPES[nargs];
@@ -256,8 +256,8 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
FieldAccessor.ahandle(arrayClass, true)
};
if (mhs[0].type().parameterType(0) == Class.class) {
- mhs[0] = MethodHandles.insertArguments(mhs[0], 0, elemClass);
- mhs[1] = MethodHandles.insertArguments(mhs[1], 0, elemClass);
+ mhs[0] = mhs[0].bindTo(elemClass);
+ mhs[1] = mhs[1].bindTo(elemClass);
}
synchronized (FieldAccessor.ARRAY_CACHE) {} // memory barrier
FieldAccessor.ARRAY_CACHE.put(elemClass, mhs);
@@ -372,7 +372,7 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
if (evclass != vclass || (!isStatic && ecclass != cclass)) {
MethodType strongType = FieldAccessor.ftype(cclass, vclass, isSetter, isStatic);
strongType = strongType.insertParameterTypes(0, FieldAccessor.class);
- mh = MethodHandles.convertArguments(mh, strongType);
+ mh = convertArguments(mh, strongType, 0);
}
return mh;
}
@@ -439,8 +439,8 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
}
if (caclass != null) {
MethodType strongType = FieldAccessor.atype(caclass, isSetter);
- mh = MethodHandles.insertArguments(mh, 0, caclass);
- mh = MethodHandles.convertArguments(mh, strongType);
+ mh = mh.bindTo(caclass);
+ mh = convertArguments(mh, strongType, 0);
}
return mh;
}
@@ -465,7 +465,7 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) {
MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0);
MethodType newType = target.type().dropParameterTypes(0, 1);
- return convertArguments(bmh, newType, bmh.type(), null);
+ return convertArguments(bmh, newType, bmh.type(), 0);
}
}
}
@@ -486,301 +486,378 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
return new BoundMethodHandle(target, receiver, argnum);
}
- static MethodHandle convertArguments(MethodHandle target,
+ static MethodHandle permuteArguments(MethodHandle target,
MethodType newType,
MethodType oldType,
int[] permutationOrNull) {
assert(oldType.parameterCount() == target.type().parameterCount());
- if (permutationOrNull != null) {
- int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
- if (permutationOrNull.length != outargs)
- throw newIllegalArgumentException("wrong number of arguments in permutation");
- // Make the individual outgoing argument types match up first.
- Class[] callTypeArgs = new Class[outargs];
- for (int i = 0; i < outargs; i++)
- callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
- MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
- target = convertArguments(target, callType, oldType, null);
- assert(target != null);
- oldType = target.type();
- List goal = new ArrayList(); // i*TOKEN
- List state = new ArrayList(); // i*TOKEN
- List drops = new ArrayList(); // not tokens
- List dups = new ArrayList(); // not tokens
- final int TOKEN = 10; // to mark items which are symbolic only
- // state represents the argument values coming into target
- for (int i = 0; i < outargs; i++) {
- state.add(permutationOrNull[i] * TOKEN);
+ int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
+ if (permutationOrNull.length != outargs)
+ throw newIllegalArgumentException("wrong number of arguments in permutation");
+ // Make the individual outgoing argument types match up first.
+ Class[] callTypeArgs = new Class[outargs];
+ for (int i = 0; i < outargs; i++)
+ callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
+ MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
+ target = convertArguments(target, callType, oldType, 0);
+ assert(target != null);
+ oldType = target.type();
+ List goal = new ArrayList(); // i*TOKEN
+ List state = new ArrayList(); // i*TOKEN
+ List drops = new ArrayList(); // not tokens
+ List dups = new ArrayList(); // not tokens
+ final int TOKEN = 10; // to mark items which are symbolic only
+ // state represents the argument values coming into target
+ for (int i = 0; i < outargs; i++) {
+ state.add(permutationOrNull[i] * TOKEN);
+ }
+ // goal represents the desired state
+ for (int i = 0; i < inargs; i++) {
+ if (state.contains(i * TOKEN)) {
+ goal.add(i * TOKEN);
+ } else {
+ // adapter must initially drop all unused arguments
+ drops.add(i);
}
- // goal represents the desired state
- for (int i = 0; i < inargs; i++) {
- if (state.contains(i * TOKEN)) {
- goal.add(i * TOKEN);
- } else {
- // adapter must initially drop all unused arguments
- drops.add(i);
+ }
+ // detect duplications
+ while (state.size() > goal.size()) {
+ for (int i2 = 0; i2 < state.size(); i2++) {
+ int arg1 = state.get(i2);
+ int i1 = state.indexOf(arg1);
+ if (i1 != i2) {
+ // found duplicate occurrence at i2
+ int arg2 = (inargs++) * TOKEN;
+ state.set(i2, arg2);
+ dups.add(goal.indexOf(arg1));
+ goal.add(arg2);
}
}
- // detect duplications
- while (state.size() > goal.size()) {
- for (int i2 = 0; i2 < state.size(); i2++) {
- int arg1 = state.get(i2);
- int i1 = state.indexOf(arg1);
- if (i1 != i2) {
- // found duplicate occurrence at i2
- int arg2 = (inargs++) * TOKEN;
- state.set(i2, arg2);
- dups.add(goal.indexOf(arg1));
- goal.add(arg2);
+ }
+ assert(state.size() == goal.size());
+ int size = goal.size();
+ while (!state.equals(goal)) {
+ // Look for a maximal sequence of adjacent misplaced arguments,
+ // and try to rotate them into place.
+ int bestRotArg = -10 * TOKEN, bestRotLen = 0;
+ int thisRotArg = -10 * TOKEN, thisRotLen = 0;
+ for (int i = 0; i < size; i++) {
+ int arg = state.get(i);
+ // Does this argument match the current run?
+ if (arg == thisRotArg + TOKEN) {
+ thisRotArg = arg;
+ thisRotLen += 1;
+ if (bestRotLen < thisRotLen) {
+ bestRotLen = thisRotLen;
+ bestRotArg = thisRotArg;
}
- }
- }
- assert(state.size() == goal.size());
- int size = goal.size();
- while (!state.equals(goal)) {
- // Look for a maximal sequence of adjacent misplaced arguments,
- // and try to rotate them into place.
- int bestRotArg = -10 * TOKEN, bestRotLen = 0;
- int thisRotArg = -10 * TOKEN, thisRotLen = 0;
- for (int i = 0; i < size; i++) {
- int arg = state.get(i);
- // Does this argument match the current run?
- if (arg == thisRotArg + TOKEN) {
+ } else {
+ // The old sequence (if any) stops here.
+ thisRotLen = 0;
+ thisRotArg = -10 * TOKEN;
+ // But maybe a new one starts here also.
+ int wantArg = goal.get(i);
+ final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
+ if (arg != wantArg &&
+ arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
+ arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
thisRotArg = arg;
- thisRotLen += 1;
- if (bestRotLen < thisRotLen) {
- bestRotLen = thisRotLen;
- bestRotArg = thisRotArg;
- }
- } else {
- // The old sequence (if any) stops here.
- thisRotLen = 0;
- thisRotArg = -10 * TOKEN;
- // But maybe a new one starts here also.
- int wantArg = goal.get(i);
- final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
- if (arg != wantArg &&
- arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
- arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
- thisRotArg = arg;
- thisRotLen = 1;
- }
+ thisRotLen = 1;
}
}
- if (bestRotLen >= 2) {
- // Do a rotation if it can improve argument positioning
- // by at least 2 arguments. This is not always optimal,
- // but it seems to catch common cases.
- int dstEnd = state.indexOf(bestRotArg);
- int srcEnd = goal.indexOf(bestRotArg);
- int rotBy = dstEnd - srcEnd;
- int dstBeg = dstEnd - (bestRotLen - 1);
- int srcBeg = srcEnd - (bestRotLen - 1);
- assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
- // Make a span which covers both source and destination.
- int rotBeg = Math.min(dstBeg, srcBeg);
- int rotEnd = Math.max(dstEnd, srcEnd);
- int score = 0;
- for (int i = rotBeg; i <= rotEnd; i++) {
- if ((int)state.get(i) != (int)goal.get(i))
- score += 1;
- }
- List rotSpan = state.subList(rotBeg, rotEnd+1);
- Collections.rotate(rotSpan, -rotBy); // reverse direction
- for (int i = rotBeg; i <= rotEnd; i++) {
- if ((int)state.get(i) != (int)goal.get(i))
- score -= 1;
- }
- if (score >= 2) {
- // Improved at least two argument positions. Do it.
- List> ptypes = Arrays.asList(oldType.parameterArray());
- Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
- MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
- MethodHandle nextTarget
- = AdapterMethodHandle.makeRotateArguments(rotType, target,
- rotBeg, rotSpan.size(), rotBy);
- if (nextTarget != null) {
- //System.out.println("Rot: "+rotSpan+" by "+rotBy);
- target = nextTarget;
- oldType = rotType;
- continue;
- }
- }
- // Else de-rotate, and drop through to the swap-fest.
- Collections.rotate(rotSpan, rotBy);
+ }
+ if (bestRotLen >= 2) {
+ // Do a rotation if it can improve argument positioning
+ // by at least 2 arguments. This is not always optimal,
+ // but it seems to catch common cases.
+ int dstEnd = state.indexOf(bestRotArg);
+ int srcEnd = goal.indexOf(bestRotArg);
+ int rotBy = dstEnd - srcEnd;
+ int dstBeg = dstEnd - (bestRotLen - 1);
+ int srcBeg = srcEnd - (bestRotLen - 1);
+ assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
+ // Make a span which covers both source and destination.
+ int rotBeg = Math.min(dstBeg, srcBeg);
+ int rotEnd = Math.max(dstEnd, srcEnd);
+ int score = 0;
+ for (int i = rotBeg; i <= rotEnd; i++) {
+ if ((int)state.get(i) != (int)goal.get(i))
+ score += 1;
}
-
- // Now swap like the wind!
- List> ptypes = Arrays.asList(oldType.parameterArray());
- for (int i = 0; i < size; i++) {
- // What argument do I want here?
- int arg = goal.get(i);
- if (arg != state.get(i)) {
- // Where is it now?
- int j = state.indexOf(arg);
- Collections.swap(ptypes, i, j);
- MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
- target = AdapterMethodHandle.makeSwapArguments(swapType, target, i, j);
- if (target == null) throw newIllegalArgumentException("cannot swap");
- assert(target.type() == swapType);
- oldType = swapType;
- Collections.swap(state, i, j);
+ List rotSpan = state.subList(rotBeg, rotEnd+1);
+ Collections.rotate(rotSpan, -rotBy); // reverse direction
+ for (int i = rotBeg; i <= rotEnd; i++) {
+ if ((int)state.get(i) != (int)goal.get(i))
+ score -= 1;
+ }
+ if (score >= 2) {
+ // Improved at least two argument positions. Do it.
+ List> ptypes = Arrays.asList(oldType.parameterArray());
+ Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
+ MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
+ MethodHandle nextTarget
+ = AdapterMethodHandle.makeRotateArguments(rotType, target,
+ rotBeg, rotSpan.size(), rotBy);
+ if (nextTarget != null) {
+ //System.out.println("Rot: "+rotSpan+" by "+rotBy);
+ target = nextTarget;
+ oldType = rotType;
+ continue;
}
}
- // One pass of swapping must finish the job.
- assert(state.equals(goal));
+ // Else de-rotate, and drop through to the swap-fest.
+ Collections.rotate(rotSpan, rotBy);
}
- while (!dups.isEmpty()) {
- // Grab a contiguous trailing sequence of dups.
- int grab = dups.size() - 1;
- int dupArgPos = dups.get(grab), dupArgCount = 1;
- while (grab - 1 >= 0) {
- int dup0 = dups.get(grab - 1);
- if (dup0 != dupArgPos - 1) break;
- dupArgPos -= 1;
- dupArgCount += 1;
- grab -= 1;
+
+ // Now swap like the wind!
+ List> ptypes = Arrays.asList(oldType.parameterArray());
+ for (int i = 0; i < size; i++) {
+ // What argument do I want here?
+ int arg = goal.get(i);
+ if (arg != state.get(i)) {
+ // Where is it now?
+ int j = state.indexOf(arg);
+ Collections.swap(ptypes, i, j);
+ MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
+ target = AdapterMethodHandle.makeSwapArguments(swapType, target, i, j);
+ if (target == null) throw newIllegalArgumentException("cannot swap");
+ assert(target.type() == swapType);
+ oldType = swapType;
+ Collections.swap(state, i, j);
}
- //if (dupArgCount > 1) System.out.println("Dup: "+dups.subList(grab, dups.size()));
- dups.subList(grab, dups.size()).clear();
- // In the new target type drop that many args from the tail:
- List> ptypes = oldType.parameterList();
- ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
- MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
- target = AdapterMethodHandle.makeDupArguments(dupType, target, dupArgPos, dupArgCount);
- if (target == null)
- throw newIllegalArgumentException("cannot dup");
- oldType = target.type();
}
- while (!drops.isEmpty()) {
- // Grab a contiguous initial sequence of drops.
- int dropArgPos = drops.get(0), dropArgCount = 1;
- while (dropArgCount < drops.size()) {
- int drop1 = drops.get(dropArgCount);
- if (drop1 != dropArgPos + dropArgCount) break;
- dropArgCount += 1;
- }
- //if (dropArgCount > 1) System.out.println("Drop: "+drops.subList(0, dropArgCount));
- drops.subList(0, dropArgCount).clear();
- List> dropTypes = newType.parameterList()
- .subList(dropArgPos, dropArgPos + dropArgCount);
- MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
- target = AdapterMethodHandle.makeDropArguments(dropType, target, dropArgPos, dropArgCount);
- if (target == null) throw newIllegalArgumentException("cannot drop");
- oldType = target.type();
+ // One pass of swapping must finish the job.
+ assert(state.equals(goal));
+ }
+ while (!dups.isEmpty()) {
+ // Grab a contiguous trailing sequence of dups.
+ int grab = dups.size() - 1;
+ int dupArgPos = dups.get(grab), dupArgCount = 1;
+ while (grab - 1 >= 0) {
+ int dup0 = dups.get(grab - 1);
+ if (dup0 != dupArgPos - 1) break;
+ dupArgPos -= 1;
+ dupArgCount += 1;
+ grab -= 1;
+ }
+ //if (dupArgCount > 1) System.out.println("Dup: "+dups.subList(grab, dups.size()));
+ dups.subList(grab, dups.size()).clear();
+ // In the new target type drop that many args from the tail:
+ List> ptypes = oldType.parameterList();
+ ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
+ MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
+ target = AdapterMethodHandle.makeDupArguments(dupType, target, dupArgPos, dupArgCount);
+ if (target == null)
+ throw newIllegalArgumentException("cannot dup");
+ oldType = target.type();
+ }
+ while (!drops.isEmpty()) {
+ // Grab a contiguous initial sequence of drops.
+ int dropArgPos = drops.get(0), dropArgCount = 1;
+ while (dropArgCount < drops.size()) {
+ int drop1 = drops.get(dropArgCount);
+ if (drop1 != dropArgPos + dropArgCount) break;
+ dropArgCount += 1;
}
+ //if (dropArgCount > 1) System.out.println("Drop: "+drops.subList(0, dropArgCount));
+ drops.subList(0, dropArgCount).clear();
+ List> dropTypes = newType.parameterList()
+ .subList(dropArgPos, dropArgPos + dropArgCount);
+ MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
+ target = AdapterMethodHandle.makeDropArguments(dropType, target, dropArgPos, dropArgCount);
+ if (target == null) throw newIllegalArgumentException("cannot drop");
+ oldType = target.type();
+ }
+ return convertArguments(target, newType, oldType, 0);
+ }
+
+ /*non-public*/ static
+ MethodHandle convertArguments(MethodHandle target, MethodType newType, int level) {
+ MethodType oldType = target.type();
+ if (oldType.equals(newType))
+ return target;
+ assert(level > 1 || oldType.isConvertibleTo(newType));
+ MethodHandle retFilter = null;
+ Class oldRT = oldType.returnType();
+ Class newRT = newType.returnType();
+ if (!VerifyType.isNullConversion(oldRT, newRT)) {
+ if (oldRT == void.class) {
+ Wrapper wrap = newRT.isPrimitive() ? Wrapper.forPrimitiveType(newRT) : Wrapper.OBJECT;
+ retFilter = ValueConversions.zeroConstantFunction(wrap);
+ } else {
+ retFilter = MethodHandles.identity(newRT);
+ retFilter = convertArguments(retFilter, retFilter.type().changeParameterType(0, oldRT), level);
+ }
+ newType = newType.changeReturnType(oldRT);
+ }
+ MethodHandle res = null;
+ Exception ex = null;
+ try {
+ res = convertArguments(target, newType, oldType, level);
+ } catch (IllegalArgumentException ex1) {
+ ex = ex1;
}
+ if (res == null) {
+ WrongMethodTypeException wmt = new WrongMethodTypeException("cannot convert to "+newType+": "+target);
+ wmt.initCause(ex);
+ throw wmt;
+ }
+ if (retFilter != null)
+ res = MethodHandles.filterReturnValue(res, retFilter);
+ return res;
+ }
+
+ static MethodHandle convertArguments(MethodHandle target,
+ MethodType newType,
+ MethodType oldType,
+ int level) {
+ assert(oldType.parameterCount() == target.type().parameterCount());
if (newType == oldType)
return target;
if (oldType.parameterCount() != newType.parameterCount())
- throw newIllegalArgumentException("mismatched parameter count");
- MethodHandle res = AdapterMethodHandle.makePairwiseConvert(newType, target);
+ throw newIllegalArgumentException("mismatched parameter count", oldType, newType);
+ MethodHandle res = AdapterMethodHandle.makePairwiseConvert(newType, target, level);
if (res != null)
return res;
+ // We can come here in the case of target(int)void => (Object)void,
+ // because the unboxing logic for Object => int is complex.
int argc = oldType.parameterCount();
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated
// The JVM can't do it directly, so fill in the gap with a Java adapter.
// TO DO: figure out what to put here from case-by-case experience
// Use a heavier method: Convert all the arguments to Object,
// then back to the desired types. We might have to use Java-based
// method handles to do this.
MethodType objType = MethodType.genericMethodType(argc);
- MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(objType, target);
+ MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(objType, target, level);
if (objTarget == null)
objTarget = FromGeneric.make(target);
- res = AdapterMethodHandle.makePairwiseConvert(newType, objTarget);
+ res = AdapterMethodHandle.makePairwiseConvert(newType, objTarget, level);
if (res != null)
return res;
return ToGeneric.make(newType, objTarget);
}
+ static MethodHandle spreadArguments(MethodHandle target, Class arrayType, int arrayLength) {
+ MethodType oldType = target.type();
+ int nargs = oldType.parameterCount();
+ int keepPosArgs = nargs - arrayLength;
+ MethodType newType = oldType
+ .dropParameterTypes(keepPosArgs, nargs)
+ .insertParameterTypes(keepPosArgs, arrayType);
+ return spreadArguments(target, newType, keepPosArgs, arrayType, arrayLength);
+ }
+ static MethodHandle spreadArguments(MethodHandle target, MethodType newType, int spreadArgPos) {
+ int arrayLength = target.type().parameterCount() - spreadArgPos;
+ return spreadArguments(target, newType, spreadArgPos, Object[].class, arrayLength);
+ }
static MethodHandle spreadArguments(MethodHandle target,
MethodType newType,
- int spreadArg) {
+ int spreadArgPos,
+ Class arrayType,
+ int arrayLength) {
// TO DO: maybe allow the restarg to be Object and implicitly cast to Object[]
MethodType oldType = target.type();
// spread the last argument of newType to oldType
- int spreadCount = oldType.parameterCount() - spreadArg;
- Class spreadArgType = Object[].class;
- MethodHandle res = AdapterMethodHandle.makeSpreadArguments(newType, target, spreadArgType, spreadArg, spreadCount);
- if (res != null)
- return res;
- // try an intermediate adapter
- Class spreadType = null;
- if (spreadArg < 0 || spreadArg >= newType.parameterCount()
- || !VerifyType.isSpreadArgType(spreadType = newType.parameterType(spreadArg)))
- throw newIllegalArgumentException("no restarg in "+newType);
- Class[] ptypes = oldType.parameterArray();
- for (int i = 0; i < spreadCount; i++)
- ptypes[spreadArg + i] = VerifyType.spreadArgElementType(spreadType, i);
- MethodType midType = MethodType.methodType(newType.returnType(), ptypes);
- // after spreading, some arguments may need further conversion
- MethodHandle target2 = convertArguments(target, midType, oldType, null);
- if (target2 == null)
- throw new UnsupportedOperationException("NYI: convert "+midType+" =calls=> "+oldType);
- res = AdapterMethodHandle.makeSpreadArguments(newType, target2, spreadArgType, spreadArg, spreadCount);
- if (res != null)
- return res;
- res = SpreadGeneric.make(target2, spreadCount);
- if (res != null)
- res = convertArguments(res, newType, res.type(), null);
+ assert(arrayLength == oldType.parameterCount() - spreadArgPos);
+ assert(newType.parameterType(spreadArgPos) == arrayType);
+ MethodHandle res = AdapterMethodHandle.makeSpreadArguments(newType, target, arrayType, spreadArgPos, arrayLength);
+ if (res == null) throw new IllegalArgumentException("spread on "+target+" with "+arrayType.getSimpleName());
return res;
}
+ static MethodHandle collectArguments(MethodHandle target,
+ int collectArg,
+ MethodHandle collector) {
+ MethodType type = target.type();
+ Class collectType = collector.type().returnType();
+ if (collectType != type.parameterType(collectArg))
+ target = target.asType(type.changeParameterType(collectArg, collectType));
+ MethodType newType = type
+ .dropParameterTypes(collectArg, collectArg+1)
+ .insertParameterTypes(collectArg, collector.type().parameterArray());
+ return collectArguments(target, newType, collectArg, collector);
+ }
static MethodHandle collectArguments(MethodHandle target,
MethodType newType,
int collectArg,
MethodHandle collector) {
MethodType oldType = target.type(); // (a...,c)=>r
- if (collector == null) {
- int numCollect = newType.parameterCount() - oldType.parameterCount() + 1;
- collector = ValueConversions.varargsArray(numCollect);
- }
// newType // (a..., b...)=>r
MethodType colType = collector.type(); // (b...)=>c
// oldType // (a..., b...)=>r
assert(newType.parameterCount() == collectArg + colType.parameterCount());
assert(oldType.parameterCount() == collectArg + 1);
- MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, null);
- MethodHandle gcollector = convertArguments(collector, colType.generic(), colType, null);
- if (gtarget == null || gcollector == null) return null;
- MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
- MethodHandle result = convertArguments(gresult, newType, gresult.type(), null);
+ MethodHandle result = null;
+ if (AdapterMethodHandle.canCollectArguments(oldType, colType, collectArg, false)) {
+ result = AdapterMethodHandle.makeCollectArguments(target, collector, collectArg, false);
+ }
+ if (result == null) {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated
+ MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, 0);
+ MethodHandle gcollector = convertArguments(collector, colType.generic(), colType, 0);
+ if (gtarget == null || gcollector == null) return null;
+ MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
+ result = convertArguments(gresult, newType, gresult.type(), 0);
+ }
return result;
}
static MethodHandle filterArgument(MethodHandle target,
- int pos,
- MethodHandle filter) {
- MethodType ttype = target.type(), gttype = ttype.generic();
+ int pos,
+ MethodHandle filter) {
+ MethodType ttype = target.type();
+ MethodType ftype = filter.type();
+ assert(ftype.parameterCount() == 1);
+ MethodType rtype = ttype.changeParameterType(pos, ftype.parameterType(0));
+ MethodType gttype = ttype.generic();
if (ttype != gttype) {
- target = convertArguments(target, gttype, ttype, null);
+ target = convertArguments(target, gttype, ttype, 0);
ttype = gttype;
}
- MethodType ftype = filter.type(), gftype = ftype.generic();
- if (ftype.parameterCount() != 1)
- throw new InternalError();
+ MethodType gftype = ftype.generic();
if (ftype != gftype) {
- filter = convertArguments(filter, gftype, ftype, null);
+ filter = convertArguments(filter, gftype, ftype, 0);
ftype = gftype;
}
- if (ftype == ttype) {
+ MethodHandle result = null;
+ if (AdapterMethodHandle.canCollectArguments(ttype, ftype, pos, false)) {
+ result = AdapterMethodHandle.makeCollectArguments(target, filter, pos, false);
+ }
+ if (result == null) {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated
+ if (ftype == ttype) {
// simple unary case
- return FilterOneArgument.make(filter, target);
+ result = FilterOneArgument.make(filter, target);
+ } else {
+ result = FilterGeneric.makeArgumentFilter(pos, filter, target);
+ }
}
- return FilterGeneric.makeArgumentFilter(pos, filter, target);
+ if (result.type() != rtype)
+ result = result.asType(rtype);
+ return result;
}
static MethodHandle foldArguments(MethodHandle target,
- MethodType newType,
- MethodHandle combiner) {
+ MethodType newType,
+ int foldPos,
+ MethodHandle combiner) {
MethodType oldType = target.type();
MethodType ctype = combiner.type();
- MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, null);
- MethodHandle gcombiner = convertArguments(combiner, ctype.generic(), ctype, null);
+ if (AdapterMethodHandle.canCollectArguments(oldType, ctype, foldPos, true)) {
+ MethodHandle res = AdapterMethodHandle.makeCollectArguments(target, combiner, foldPos, true);
+ if (res != null) return res;
+ }
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated
+ if (foldPos != 0) return null;
+ MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, 0);
+ MethodHandle gcombiner = convertArguments(combiner, ctype.generic(), ctype, 0);
+ if (ctype.returnType() == void.class) {
+ gtarget = dropArguments(gtarget, oldType.generic().insertParameterTypes(foldPos, Object.class), foldPos);
+ }
if (gtarget == null || gcombiner == null) return null;
MethodHandle gresult = FilterGeneric.makeArgumentFolder(gcombiner, gtarget);
- MethodHandle result = convertArguments(gresult, newType, gresult.type(), null);
- return result;
+ return convertArguments(gresult, newType, gresult.type(), 0);
}
static
@@ -802,6 +879,7 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
this.target = target;
this.fallback = fallback;
}
+ // FIXME: Build the control flow out of foldArguments.
static MethodHandle make(MethodHandle test, MethodHandle target, MethodHandle fallback) {
MethodType type = target.type();
int nargs = type.parameterCount();
@@ -809,12 +887,12 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
MethodHandle invoke = INVOKES[nargs];
MethodType gtype = type.generic();
assert(invoke.type().dropParameterTypes(0,1) == gtype);
- MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), null);
- MethodHandle gtarget = convertArguments(target, gtype, type, null);
- MethodHandle gfallback = convertArguments(fallback, gtype, type, null);
+ MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), 0);
+ MethodHandle gtarget = convertArguments(target, gtype, type, 0);
+ MethodHandle gfallback = convertArguments(fallback, gtype, type, 0);
if (gtest == null || gtarget == null || gfallback == null) return null;
MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback);
- return convertArguments(gguard, type, gtype, null);
+ return convertArguments(gguard, type, gtype, 0);
} else {
MethodHandle invoke = VARARGS_INVOKE;
MethodType gtype = MethodType.genericMethodType(1);
@@ -925,8 +1003,9 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
GuardWithCatch(MethodHandle target, Class exType, MethodHandle catcher) {
this(INVOKES[target.type().parameterCount()], target, exType, catcher);
}
- GuardWithCatch(MethodHandle invoker,
- MethodHandle target, Class exType, MethodHandle catcher) {
+ // FIXME: Build the control flow out of foldArguments.
+ GuardWithCatch(MethodHandle invoker,
+ MethodHandle target, Class exType, MethodHandle catcher) {
super(invoker);
this.target = target;
this.exType = exType;
@@ -1057,11 +1136,11 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
if (nargs < GuardWithCatch.INVOKES.length) {
MethodType gtype = type.generic();
MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
- MethodHandle gtarget = convertArguments(target, gtype, type, null);
- MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, null);
+ MethodHandle gtarget = convertArguments(target, gtype, type, 0);
+ MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, 0);
MethodHandle gguard = new GuardWithCatch(gtarget, exType, gcatcher);
if (gtarget == null || gcatcher == null || gguard == null) return null;
- return convertArguments(gguard, type, gtype, null);
+ return convertArguments(gguard, type, gtype, 0);
} else {
MethodType gtype = MethodType.genericMethodType(0, true);
MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
diff --git a/src/share/classes/java/lang/invoke/MethodHandleNatives.java b/src/share/classes/java/lang/invoke/MethodHandleNatives.java
index 82d5d898638f7e4a3a6969fbae7857b973bdc460..40272644e286f1f7d039f8bb28a9191db6a42097 100644
--- a/src/share/classes/java/lang/invoke/MethodHandleNatives.java
+++ b/src/share/classes/java/lang/invoke/MethodHandleNatives.java
@@ -115,6 +115,8 @@ class MethodHandleNatives {
/** Which conv-ops are implemented by the JVM? */
static final int CONV_OP_IMPLEMENTED_MASK;
+ /** Derived mode flag. Only false on some old JVM implementations. */
+ static final boolean HAVE_RICOCHET_FRAMES;
private static native void registerNatives();
static {
@@ -141,6 +143,7 @@ class MethodHandleNatives {
if (CONV_OP_IMPLEMENTED_MASK_ == 0)
CONV_OP_IMPLEMENTED_MASK_ = DEFAULT_CONV_OP_IMPLEMENTED_MASK;
CONV_OP_IMPLEMENTED_MASK = CONV_OP_IMPLEMENTED_MASK_;
+ HAVE_RICOCHET_FRAMES = (CONV_OP_IMPLEMENTED_MASK & (1<int, Object->T)
OP_CHECK_CAST = 0x2, // ref-to-ref conversion; requires a Class argument
OP_PRIM_TO_PRIM = 0x3, // converts from one primitive to another
OP_REF_TO_PRIM = 0x4, // unboxes a wrapper to produce a primitive
- OP_PRIM_TO_REF = 0x5, // boxes a primitive into a wrapper (NYI)
+ OP_PRIM_TO_REF = 0x5, // boxes a primitive into a wrapper
OP_SWAP_ARGS = 0x6, // swap arguments (vminfo is 2nd arg)
OP_ROT_ARGS = 0x7, // rotate arguments (vminfo is displaced arg)
OP_DUP_ARGS = 0x8, // duplicates one or more arguments (at TOS)
OP_DROP_ARGS = 0x9, // remove one or more argument slots
- OP_COLLECT_ARGS = 0xA, // combine one or more arguments into a varargs (NYI)
+ OP_COLLECT_ARGS = 0xA, // combine arguments using an auxiliary function
OP_SPREAD_ARGS = 0xB, // expand in place a varargs array (of known size)
- OP_FLYBY = 0xC, // operate first on reified argument list (NYI)
- OP_RICOCHET = 0xD, // run an adapter chain on the return value (NYI)
+ OP_FOLD_ARGS = 0xC, // combine but do not remove arguments; prepend result
+ //OP_UNUSED_13 = 0xD, // unused code, perhaps for reified argument lists
CONV_OP_LIMIT = 0xE; // limit of CONV_OP enumeration
/** Shift and mask values for decoding the AMH.conversion field.
* These numbers are shared with the JVM for creating AMHs.
*/
static final int
CONV_OP_MASK = 0xF00, // this nybble contains the conversion op field
+ CONV_TYPE_MASK = 0x0F, // fits T_ADDRESS and below
CONV_VMINFO_MASK = 0x0FF, // LSB is reserved for JVM use
CONV_VMINFO_SHIFT = 0, // position of bits in CONV_VMINFO_MASK
CONV_OP_SHIFT = 8, // position of bits in CONV_OP_MASK
@@ -244,8 +248,9 @@ class MethodHandleNatives {
T_LONG = 11,
T_OBJECT = 12,
//T_ARRAY = 13
- T_VOID = 14;
+ T_VOID = 14,
//T_ADDRESS = 15
+ T_ILLEGAL = 99;
/**
* Constant pool reference-kind codes, as used by CONSTANT_MethodHandle CP entries.
@@ -273,16 +278,29 @@ class MethodHandleNatives {
try {
Field con = Constants.class.getDeclaredField(name);
int jval = con.getInt(null);
- if (jval != vmval)
- throw new InternalError(name+": JVM has "+vmval+" while Java has "+jval);
+ if (jval == vmval) continue;
+ String err = (name+": JVM has "+vmval+" while Java has "+jval);
+ if (name.equals("CONV_OP_LIMIT")) {
+ System.err.println("warning: "+err);
+ continue;
+ }
+ throw new InternalError(err);
} catch (Exception ex) {
+ if (ex instanceof NoSuchFieldException) {
+ String err = (name+": JVM has "+vmval+" which Java does not define");
+ // ignore exotic ops the JVM cares about; we just wont issue them
+ if (name.startsWith("OP_") || name.startsWith("GC_")) {
+ System.err.println("warning: "+err);
+ continue;
+ }
+ }
throw new InternalError(name+": access failed, got "+ex);
}
}
return true;
}
static {
- verifyConstants();
+ assert(verifyConstants());
}
// Up-calls from the JVM.
@@ -313,7 +331,7 @@ class MethodHandleNatives {
}
/**
- * The JVM wants to use a MethodType with invokeGeneric. Give the runtime fair warning.
+ * The JVM wants to use a MethodType with inexact invoke. Give the runtime fair warning.
*/
static void notifyGenericMethodType(MethodType type) {
type.form().notifyGenericMethodType();
@@ -323,15 +341,39 @@ class MethodHandleNatives {
* The JVM wants to raise an exception. Here's the path.
*/
static void raiseException(int code, Object actual, Object required) {
- String message;
+ String message = null;
+ switch (code) {
+ case 190: // arraylength
+ try {
+ String reqLength = "";
+ if (required instanceof AdapterMethodHandle) {
+ int conv = ((AdapterMethodHandle)required).getConversion();
+ int spChange = AdapterMethodHandle.extractStackMove(conv);
+ reqLength = " of length "+(spChange+1);
+ }
+ int actualLength = actual == null ? 0 : java.lang.reflect.Array.getLength(actual);
+ message = "required array"+reqLength+", but encountered wrong length "+actualLength;
+ break;
+ } catch (IllegalArgumentException ex) {
+ }
+ required = Object[].class; // should have been an array
+ code = 192; // checkcast
+ break;
+ }
// disregard the identity of the actual object, if it is not a class:
- if (!(actual instanceof Class) && !(actual instanceof MethodType))
- actual = actual.getClass();
- if (actual != null)
- message = "required "+required+" but encountered "+actual;
- else
- message = "required "+required;
+ if (message == null) {
+ if (!(actual instanceof Class) && !(actual instanceof MethodType))
+ actual = actual.getClass();
+ if (actual != null)
+ message = "required "+required+" but encountered "+actual;
+ else
+ message = "required "+required;
+ }
switch (code) {
+ case 190: // arraylength
+ throw new ArrayIndexOutOfBoundsException(message);
+ case 50: //_aaload
+ throw new ClassCastException(message);
case 192: // checkcast
throw new ClassCastException(message);
default:
@@ -365,4 +407,13 @@ class MethodHandleNatives {
throw err;
}
}
+
+ /**
+ * This assertion marks code which was written before ricochet frames were implemented.
+ * Such code will go away when the ports catch up.
+ */
+ static boolean workaroundWithoutRicochetFrames() {
+ assert(!HAVE_RICOCHET_FRAMES) : "this code should not be executed if `-XX:+UseRicochetFrames is enabled";
+ return true;
+ }
}
diff --git a/src/share/classes/java/lang/invoke/MethodHandleStatics.java b/src/share/classes/java/lang/invoke/MethodHandleStatics.java
index 6ea8f978b63f1c4b22cd3f74b3e61d40ca8ef073..3eeeec71ac354ee93acb02b3030b78821e8c0e83 100644
--- a/src/share/classes/java/lang/invoke/MethodHandleStatics.java
+++ b/src/share/classes/java/lang/invoke/MethodHandleStatics.java
@@ -63,8 +63,17 @@ package java.lang.invoke;
}
static void checkSpreadArgument(Object av, int n) {
- if (av == null ? n != 0 : ((Object[])av).length != n)
- throw newIllegalArgumentException("Array is not of length "+n);
+ if (av == null) {
+ if (n == 0) return;
+ } else if (av instanceof Object[]) {
+ int len = ((Object[])av).length;
+ if (len == n) return;
+ } else {
+ int len = java.lang.reflect.Array.getLength(av);
+ if (len == n) return;
+ }
+ // fall through to error:
+ throw newIllegalArgumentException("Array is not of length "+n);
}
// handy shared exception makers (they simplify the common case code)
@@ -80,6 +89,9 @@ package java.lang.invoke;
/*non-public*/ static RuntimeException newIllegalArgumentException(String message, Object obj) {
return new IllegalArgumentException(message(message, obj));
}
+ /*non-public*/ static RuntimeException newIllegalArgumentException(String message, Object obj, Object obj2) {
+ return new IllegalArgumentException(message(message, obj, obj2));
+ }
/*non-public*/ static Error uncaughtException(Exception ex) {
Error err = new InternalError("uncaught exception");
err.initCause(ex);
@@ -89,4 +101,8 @@ package java.lang.invoke;
if (obj != null) message = message + ": " + obj;
return message;
}
+ private static String message(String message, Object obj, Object obj2) {
+ if (obj != null || obj2 != null) message = message + ": " + obj + ", " + obj2;
+ return message;
+ }
}
diff --git a/src/share/classes/java/lang/invoke/MethodHandles.java b/src/share/classes/java/lang/invoke/MethodHandles.java
index 12e36da623a4c47bf59289f74e8f49bc1e642996..99985a09feec3aa5c6498b2a7f9080354252df19 100644
--- a/src/share/classes/java/lang/invoke/MethodHandles.java
+++ b/src/share/classes/java/lang/invoke/MethodHandles.java
@@ -190,7 +190,7 @@ public class MethodHandles {
* is not symbolically accessible from the lookup class's loader,
* the lookup can still succeed.
* For example, lookups for {@code MethodHandle.invokeExact} and
- * {@code MethodHandle.invokeGeneric} will always succeed, regardless of requested type.
+ * {@code MethodHandle.invoke} will always succeed, regardless of requested type.
*
If there is a security manager installed, it can forbid the lookup
* on various grounds (see below).
* By contrast, the {@code ldc} instruction is not subject to
@@ -590,10 +590,10 @@ public class MethodHandles {
* Because of the general equivalence between {@code invokevirtual}
* instructions and method handles produced by {@code findVirtual},
* if the class is {@code MethodHandle} and the name string is
- * {@code invokeExact} or {@code invokeGeneric}, the resulting
+ * {@code invokeExact} or {@code invoke}, the resulting
* method handle is equivalent to one produced by
* {@link java.lang.invoke.MethodHandles#exactInvoker MethodHandles.exactInvoker} or
- * {@link java.lang.invoke.MethodHandles#genericInvoker MethodHandles.genericInvoker}
+ * {@link java.lang.invoke.MethodHandles#invoker MethodHandles.invoker}
* with the same {@code type} argument.
*
* @param refc the class or interface from which the method is accessed
@@ -1080,7 +1080,7 @@ return mh1;
MethodType rawType = mh.type();
if (rawType.parameterType(0) == caller) return mh;
MethodType narrowType = rawType.changeParameterType(0, caller);
- MethodHandle narrowMH = MethodHandleImpl.convertArguments(mh, narrowType, rawType, null);
+ MethodHandle narrowMH = MethodHandleImpl.convertArguments(mh, narrowType, rawType, 0);
return fixVarargs(narrowMH, mh);
}
@@ -1148,7 +1148,7 @@ return mh1;
*
an {@code Object[]} array containing more arguments
*
*
- * The invoker will behave like a call to {@link MethodHandle#invokeGeneric invokeGeneric} with
+ * The invoker will behave like a call to {@link MethodHandle#invoke invoke} with
* the indicated {@code type}.
* That is, if the target is exactly of the given {@code type}, it will behave
* like {@code invokeExact}; otherwise it behave as if {@link MethodHandle#asType asType}
@@ -1166,7 +1166,7 @@ return mh1;
*
* This method is equivalent to the following code (though it may be more efficient):
*
-MethodHandle invoker = MethodHandles.genericInvoker(type);
+MethodHandle invoker = MethodHandles.invoker(type);
int spreadArgCount = type.parameterCount - objectArgCount;
invoker = invoker.asSpreader(Object[].class, spreadArgCount);
return invoker;
@@ -1186,7 +1186,7 @@ return invoker;
/**
* Produces a special invoker method handle which can be used to
- * invoke any method handle of the given type, as if by {@code invokeExact}.
+ * invoke any method handle of the given type, as if by {@link MethodHandle#invokeExact invokeExact}.
* The resulting invoker will have a type which is
* exactly equal to the desired type, except that it will accept
* an additional leading argument of type {@code MethodHandle}.
@@ -1203,7 +1203,7 @@ publicLookup().findVirtual(MethodHandle.class, "invokeExact", type)
* For example, to emulate an {@code invokeExact} call to a variable method
* handle {@code M}, extract its type {@code T},
* look up the invoker method {@code X} for {@code T},
- * and call the invoker method, as {@code X.invokeGeneric(T, A...)}.
+ * and call the invoker method, as {@code X.invoke(T, A...)}.
* (It would not work to call {@code X.invokeExact}, since the type {@code T}
* is unknown.)
* If spreading, collecting, or other argument transformations are required,
@@ -1212,7 +1212,7 @@ publicLookup().findVirtual(MethodHandle.class, "invokeExact", type)
*
* (Note: The invoker method is not available via the Core Reflection API.
* An attempt to call {@linkplain java.lang.reflect.Method#invoke Method.invoke}
- * on the declared {@code invokeExact} or {@code invokeGeneric} method will raise an
+ * on the declared {@code invokeExact} or {@code invoke} method will raise an
* {@link java.lang.UnsupportedOperationException UnsupportedOperationException}.)
*
* This method throws no reflective or security exceptions.
@@ -1226,20 +1226,20 @@ publicLookup().findVirtual(MethodHandle.class, "invokeExact", type)
/**
* Produces a special invoker method handle which can be used to
- * invoke any method handle of the given type, as if by {@code invokeGeneric}.
+ * invoke any method handle compatible with the given type, as if by {@link MethodHandle#invoke invoke}.
* The resulting invoker will have a type which is
* exactly equal to the desired type, except that it will accept
* an additional leading argument of type {@code MethodHandle}.
*
* Before invoking its target, the invoker will apply reference casts as
- * necessary and unbox and widen primitive arguments, as if by {@link #convertArguments convertArguments}.
- * The return value of the invoker will be an {@code Object} reference,
- * boxing a primitive value if the original type returns a primitive,
- * and always null if the original type returns void.
+ * necessary and box, unbox, or widen primitive values, as if by {@link MethodHandle#asType asType}.
+ * Similarly, the return value will be converted as necessary.
+ * If the target is a {@linkplain MethodHandle#asVarargsCollector variable arity method handle},
+ * the required arity conversion will be made, again as if by {@link MethodHandle#asType asType}.
*
* This method is equivalent to the following code (though it may be more efficient):
*
* This method throws no reflective or security exceptions.
@@ -1247,8 +1247,17 @@ publicLookup().findVirtual(MethodHandle.class, "invokeGeneric", type)
* @return a method handle suitable for invoking any method handle convertible to the given type
*/
static public
+ MethodHandle invoker(MethodType type) {
+ return type.invokers().generalInvoker();
+ }
+
+ /**
+ * Temporary alias for {@link #invoker}, for backward compatibility with some versions of JSR 292.
+ * @deprecated Will be removed for JSR 292 Proposed Final Draft.
+ */
+ public static
MethodHandle genericInvoker(MethodType type) {
- return type.invokers().genericInvoker();
+ return invoker(type);
}
/**
@@ -1368,18 +1377,7 @@ publicLookup().findVirtual(MethodHandle.class, "invokeGeneric", type)
*/
public static
MethodHandle convertArguments(MethodHandle target, MethodType newType) {
- MethodType oldType = target.type();
- if (oldType.equals(newType))
- return target;
- MethodHandle res = null;
- try {
- res = MethodHandleImpl.convertArguments(target,
- newType, oldType, null);
- } catch (IllegalArgumentException ex) {
- }
- if (res == null)
- throw new WrongMethodTypeException("cannot convert to "+newType+": "+target);
- return res;
+ return MethodHandleImpl.convertArguments(target, newType, 1);
}
/**
@@ -1422,7 +1420,7 @@ publicLookup().findVirtual(MethodHandle.class, "invokeGeneric", type)
*/
public static
MethodHandle explicitCastArguments(MethodHandle target, MethodType newType) {
- return convertArguments(target, newType); // FIXME!
+ return MethodHandleImpl.convertArguments(target, newType, 2);
}
/*
@@ -1517,23 +1515,32 @@ assert((int)twice.invokeExact(21) == 42);
MethodHandle permuteArguments(MethodHandle target, MethodType newType, int... reorder) {
MethodType oldType = target.type();
checkReorder(reorder, newType, oldType);
- return MethodHandleImpl.convertArguments(target,
+ return MethodHandleImpl.permuteArguments(target,
newType, oldType,
reorder);
}
private static void checkReorder(int[] reorder, MethodType newType, MethodType oldType) {
+ if (newType.returnType() != oldType.returnType())
+ throw newIllegalArgumentException("return types do not match",
+ oldType, newType);
if (reorder.length == oldType.parameterCount()) {
int limit = newType.parameterCount();
boolean bad = false;
- for (int i : reorder) {
+ for (int j = 0; j < reorder.length; j++) {
+ int i = reorder[j];
if (i < 0 || i >= limit) {
bad = true; break;
}
+ Class src = newType.parameterType(i);
+ Class dst = oldType.parameterType(j);
+ if (src != dst)
+ throw newIllegalArgumentException("parameter types do not match after reorder",
+ oldType, newType);
}
if (!bad) return;
}
- throw newIllegalArgumentException("bad reorder array");
+ throw newIllegalArgumentException("bad reorder array: "+Arrays.toString(reorder));
}
/**
@@ -1622,7 +1629,7 @@ assert((int)twice.invokeExact(21) == 42);
if (type == void.class)
throw newIllegalArgumentException("void type");
Wrapper w = Wrapper.forPrimitiveType(type);
- return identity(type).bindTo(w.convert(value, type));
+ return insertArguments(identity(type), 0, w.convert(value, type));
} else {
return identity(type).bindTo(type.cast(value));
}
@@ -1857,7 +1864,8 @@ assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY
MethodHandle filterArguments(MethodHandle target, int pos, MethodHandle... filters) {
MethodType targetType = target.type();
MethodHandle adapter = target;
- MethodType adapterType = targetType;
+ MethodType adapterType = null;
+ assert((adapterType = targetType) != null);
int maxPos = targetType.parameterCount();
if (pos + filters.length > maxPos)
throw newIllegalArgumentException("too many filters");
@@ -1865,19 +1873,23 @@ assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY
for (MethodHandle filter : filters) {
curPos += 1;
if (filter == null) continue; // ignore null elements of filters
- MethodType filterType = filter.type();
- if (filterType.parameterCount() != 1
- || filterType.returnType() != targetType.parameterType(curPos))
- throw newIllegalArgumentException("target and filter types do not match");
- adapterType = adapterType.changeParameterType(curPos, filterType.parameterType(0));
- adapter = MethodHandleImpl.filterArgument(adapter, curPos, filter);
+ adapter = filterArgument(adapter, curPos, filter);
+ assert((adapterType = adapterType.changeParameterType(curPos, filter.type().parameterType(0))) != null);
}
- MethodType midType = adapter.type();
- if (midType != adapterType)
- adapter = MethodHandleImpl.convertArguments(adapter, adapterType, midType, null);
+ assert(adapterType.equals(adapter.type()));
return adapter;
}
+ /*non-public*/ static
+ MethodHandle filterArgument(MethodHandle target, int pos, MethodHandle filter) {
+ MethodType targetType = target.type();
+ MethodType filterType = filter.type();
+ if (filterType.parameterCount() != 1
+ || filterType.returnType() != targetType.parameterType(pos))
+ throw newIllegalArgumentException("target and filter types do not match", targetType, filterType);
+ return MethodHandleImpl.filterArgument(target, pos, filter);
+ }
+
/**
* Adapts a target method handle {@code target} by post-processing
* its return value with a unary filter function.
@@ -1913,14 +1925,26 @@ System.out.println((int) f0.invokeExact("x", "y")); // 2
MethodHandle filterReturnValue(MethodHandle target, MethodHandle filter) {
MethodType targetType = target.type();
MethodType filterType = filter.type();
- if (filterType.parameterCount() != 1
- || filterType.parameterType(0) != targetType.returnType())
- throw newIllegalArgumentException("target and filter types do not match");
+ Class rtype = targetType.returnType();
+ int filterValues = filterType.parameterCount();
+ if (filterValues == 0
+ ? (rtype != void.class)
+ : (rtype != filterType.parameterType(0)))
+ throw newIllegalArgumentException("target and filter types do not match", target, filter);
// result = fold( lambda(retval, arg...) { filter(retval) },
// lambda( arg...) { target(arg...) } )
+ MethodType newType = targetType.changeReturnType(filterType.returnType());
+ MethodHandle result = null;
+ if (AdapterMethodHandle.canCollectArguments(filterType, targetType, 0, false)) {
+ result = AdapterMethodHandle.makeCollectArguments(filter, target, 0, false);
+ if (result != null) return result;
+ }
// FIXME: Too many nodes here.
- MethodHandle returner = dropArguments(filter, 1, targetType.parameterList());
- return foldArguments(returner, target);
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
+ MethodHandle returner = dropArguments(filter, filterValues, targetType.parameterList());
+ result = foldArguments(returner, target);
+ assert(result.type().equals(newType));
+ return result;
}
/**
@@ -1972,16 +1996,23 @@ System.out.println((int) f0.invokeExact("x", "y")); // 2
MethodHandle foldArguments(MethodHandle target, MethodHandle combiner) {
MethodType targetType = target.type();
MethodType combinerType = combiner.type();
+ int foldPos = 0; // always at the head, at present
int foldArgs = combinerType.parameterCount();
- boolean ok = (targetType.parameterCount() >= 1 + foldArgs);
- if (ok && !combinerType.parameterList().equals(targetType.parameterList().subList(1, foldArgs+1)))
+ int foldVals = combinerType.returnType() == void.class ? 0 : 1;
+ int afterInsertPos = foldPos + foldVals;
+ boolean ok = (targetType.parameterCount() >= afterInsertPos + foldArgs);
+ if (ok && !(combinerType.parameterList()
+ .equals(targetType.parameterList().subList(afterInsertPos,
+ afterInsertPos + foldArgs))))
ok = false;
- if (ok && !combinerType.returnType().equals(targetType.parameterType(0)))
+ if (ok && foldVals != 0 && !combinerType.returnType().equals(targetType.parameterType(0)))
ok = false;
if (!ok)
throw misMatchedTypes("target and combiner types", targetType, combinerType);
- MethodType newType = targetType.dropParameterTypes(0, 1);
- return MethodHandleImpl.foldArguments(target, newType, combiner);
+ MethodType newType = targetType.dropParameterTypes(foldPos, afterInsertPos);
+ MethodHandle res = MethodHandleImpl.foldArguments(target, newType, foldPos, combiner);
+ if (res == null) throw newIllegalArgumentException("cannot fold from "+newType+" to " +targetType);
+ return res;
}
/**
@@ -2142,7 +2173,7 @@ System.out.println((int) f0.invokeExact("x", "y")); // 2
* the given {@code target} on the incoming arguments,
* and returning or throwing whatever the {@code target}
* returns or throws. The invocation will be as if by
- * {@code target.invokeGeneric}.
+ * {@code target.invoke}.
* The target's type will be checked before the
* instance is created, as if by a call to {@code asType},
* which may result in a {@code WrongMethodTypeException}.
diff --git a/src/share/classes/java/lang/invoke/MethodType.java b/src/share/classes/java/lang/invoke/MethodType.java
index a7fa147fa3296a195e49b6cd8f81f9580dcec100..02c12c69aad61c037576bbb92e4458dd2e43eff8 100644
--- a/src/share/classes/java/lang/invoke/MethodType.java
+++ b/src/share/classes/java/lang/invoke/MethodType.java
@@ -25,6 +25,7 @@
package java.lang.invoke;
+import sun.invoke.util.Wrapper;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
@@ -39,7 +40,7 @@ import static java.lang.invoke.MethodHandleStatics.*;
* matched between a method handle and all its callers,
* and the JVM's operations enforce this matching at, specifically
* during calls to {@link MethodHandle#invokeExact MethodHandle.invokeExact}
- * and {@link MethodHandle#invokeGeneric MethodHandle.invokeGeneric}, and during execution
+ * and {@link MethodHandle#invoke MethodHandle.invoke}, and during execution
* of {@code invokedynamic} instructions.
*
* The structure is a return type accompanied by any number of parameter types.
@@ -262,18 +263,18 @@ class MethodType implements java.io.Serializable {
* Finds or creates a method type whose components are {@code Object} with an optional trailing {@code Object[]} array.
* Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[]) methodType}.
* All parameters and the return type will be {@code Object},
- * except the final varargs parameter if any, which will be {@code Object[]}.
- * @param objectArgCount number of parameters (excluding the varargs parameter if any)
- * @param varargs whether there will be a varargs parameter, of type {@code Object[]}
- * @return a totally generic method type, given only its count of parameters and varargs
- * @throws IllegalArgumentException if {@code objectArgCount} is negative or greater than 255
+ * except the final array parameter if any, which will be {@code Object[]}.
+ * @param objectArgCount number of parameters (excluding the final array parameter if any)
+ * @param finalArray whether there will be a trailing array parameter, of type {@code Object[]}
+ * @return a generally applicable method type, for all calls of the given fixed argument count and a collected array of further arguments
+ * @throws IllegalArgumentException if {@code objectArgCount} is negative or greater than 255 (or 254, if {@code finalArray})
* @see #genericMethodType(int)
*/
public static
- MethodType genericMethodType(int objectArgCount, boolean varargs) {
+ MethodType genericMethodType(int objectArgCount, boolean finalArray) {
MethodType mt;
checkSlotCount(objectArgCount);
- int ivarargs = (!varargs ? 0 : 1);
+ int ivarargs = (!finalArray ? 0 : 1);
int ootIndex = objectArgCount*2 + ivarargs;
if (ootIndex < objectOnlyTypes.length) {
mt = objectOnlyTypes[ootIndex];
@@ -294,7 +295,7 @@ class MethodType implements java.io.Serializable {
* Convenience method for {@link #methodType(java.lang.Class, java.lang.Class[]) methodType}.
* All parameters and the return type will be Object.
* @param objectArgCount number of parameters
- * @return a totally generic method type, given only its count of parameters
+ * @return a generally applicable method type, for all calls of the given argument count
* @throws IllegalArgumentException if {@code objectArgCount} is negative or greater than 255
* @see #genericMethodType(int, boolean)
*/
@@ -626,6 +627,30 @@ class MethodType implements java.io.Serializable {
return sb.toString();
}
+
+ /*non-public*/
+ boolean isConvertibleTo(MethodType newType) {
+ if (!canConvert(returnType(), newType.returnType()))
+ return false;
+ int argc = parameterCount();
+ if (argc != newType.parameterCount())
+ return false;
+ for (int i = 0; i < argc; i++) {
+ if (!canConvert(newType.parameterType(i), parameterType(i)))
+ return false;
+ }
+ return true;
+ }
+ private static boolean canConvert(Class src, Class dst) {
+ if (src == dst || dst == void.class) return true;
+ if (src.isPrimitive() && dst.isPrimitive()) {
+ if (!Wrapper.forPrimitiveType(dst)
+ .isConvertibleFrom(Wrapper.forPrimitiveType(src)))
+ return false;
+ }
+ return true;
+ }
+
/// Queries which have to do with the bytecode architecture
/** Reports the number of JVM stack slots required to invoke a method
diff --git a/src/share/classes/java/lang/invoke/MethodTypeForm.java b/src/share/classes/java/lang/invoke/MethodTypeForm.java
index db73b24d06759f937e4ca3102c4bfcfaa46ef4e1..6ad4a5a8eead889f155d34e134ebb2ac9c8849b9 100644
--- a/src/share/classes/java/lang/invoke/MethodTypeForm.java
+++ b/src/share/classes/java/lang/invoke/MethodTypeForm.java
@@ -46,6 +46,7 @@ class MethodTypeForm {
final long argCounts; // packed slot & value counts
final long primCounts; // packed prim & double counts
final int vmslots; // total number of parameter slots
+ private Object vmlayout; // vm-specific information for calls
final MethodType erasedType; // the canonical erasure
/*lazy*/ MethodType primsAsBoxes; // replace prims by wrappers
@@ -59,7 +60,7 @@ class MethodTypeForm {
/*lazy*/ FromGeneric fromGeneric; // convert cs. w/o prims to with
/*lazy*/ SpreadGeneric[] spreadGeneric; // expand one argument to many
/*lazy*/ FilterGeneric filterGeneric; // convert argument(s) on the fly
- /*lazy*/ MethodHandle genericInvoker; // hook for invokeGeneric
+ /*lazy*/ MethodHandle genericInvoker; // hook for inexact invoke
public MethodType erasedType() {
return erasedType;
@@ -460,9 +461,9 @@ class MethodTypeForm {
if (genericInvoker != null) return;
try {
// Trigger adapter creation.
- genericInvoker = InvokeGeneric.genericInvokerOf(erasedType);
+ genericInvoker = InvokeGeneric.generalInvokerOf(erasedType);
} catch (Exception ex) {
- Error err = new InternalError("Exception while resolving invokeGeneric");
+ Error err = new InternalError("Exception while resolving inexact invoke");
err.initCause(ex);
throw err;
}
diff --git a/src/share/classes/java/lang/invoke/SpreadGeneric.java b/src/share/classes/java/lang/invoke/SpreadGeneric.java
index a862723e0250d8aa1322e77a9c742dd3a271b4eb..be1606673815e8cc0e16c3042ac80e02705e0a97 100644
--- a/src/share/classes/java/lang/invoke/SpreadGeneric.java
+++ b/src/share/classes/java/lang/invoke/SpreadGeneric.java
@@ -66,6 +66,10 @@ class SpreadGeneric {
this.entryPoint = ep[0];
}
+ static {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
+ }
+
/** From targetType remove the last spreadCount arguments, and instead
* append a simple Object argument.
*/
diff --git a/src/share/classes/java/lang/invoke/ToGeneric.java b/src/share/classes/java/lang/invoke/ToGeneric.java
index 22723975d5bfbe158fa08407d9bb5f573c9e1d5c..2d46a3910e1c44aea329f7ed6bcd4bc4e9590cb3 100644
--- a/src/share/classes/java/lang/invoke/ToGeneric.java
+++ b/src/share/classes/java/lang/invoke/ToGeneric.java
@@ -96,7 +96,7 @@ class ToGeneric {
ToGeneric va2 = ToGeneric.of(primsAtEnd);
this.adapter = va2.adapter;
if (true) throw new UnsupportedOperationException("NYI: primitive parameters must follow references; entryType = "+entryType);
- this.entryPoint = MethodHandleImpl.convertArguments(
+ this.entryPoint = MethodHandleImpl.permuteArguments(
va2.entryPoint, primsAtEnd, entryType, primsAtEndOrder);
// example: for entryType of (int,Object,Object), the reordered
// type is (Object,Object,int) and the order is {1,2,0},
@@ -128,7 +128,7 @@ class ToGeneric {
assert(eptWithInts.parameterType(i) == int.class);
MethodType nextType = midType.changeParameterType(i, int.class);
rawEntryPoint = MethodHandleImpl.convertArguments(
- rawEntryPoint, nextType, midType, null);
+ rawEntryPoint, nextType, midType, 0);
midType = nextType;
}
}
@@ -152,6 +152,10 @@ class ToGeneric {
this.invoker = makeRawArgumentFilter(invoker0, rawEntryTypeInit, entryType);
}
+ static {
+ assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this class is deprecated
+ }
+
/** A generic argument list will be created by a call of type 'raw'.
* The values need to be reboxed for to match 'cooked'.
* Do this on the fly.
@@ -171,7 +175,7 @@ class ToGeneric {
invoker.type().generic(), invoker, 0, MethodHandle.class);
if (filteredInvoker == null) throw new UnsupportedOperationException("NYI");
}
- MethodHandle reboxer = ValueConversions.rebox(dst, false);
+ MethodHandle reboxer = ValueConversions.rebox(dst);
filteredInvoker = FilterGeneric.makeArgumentFilter(1+i, reboxer, filteredInvoker);
if (filteredInvoker == null) throw new InternalError();
}
@@ -199,13 +203,13 @@ class ToGeneric {
assert(!rret.isPrimitive());
if (rret == Object.class && !mustCast)
return null;
- return ValueConversions.cast(tret, false);
+ return ValueConversions.cast(tret);
} else if (tret == rret) {
- return ValueConversions.unbox(tret, false);
+ return ValueConversions.unbox(tret);
} else {
assert(rret.isPrimitive());
assert(tret == double.class ? rret == long.class : rret == int.class);
- return ValueConversions.unboxRaw(tret, false);
+ return ValueConversions.unboxRaw(tret);
}
}
@@ -311,7 +315,7 @@ class ToGeneric {
}
static Adapter buildAdapterFromBytecodes(MethodType entryPointType) {
- throw new UnsupportedOperationException("NYI");
+ throw new UnsupportedOperationException("NYI: "+entryPointType);
}
/**
diff --git a/src/share/classes/java/lang/invoke/package-info.java b/src/share/classes/java/lang/invoke/package-info.java
index b6a1992dca874c6f6ad1bb25eb4ddc25a43e253d..8ec18c461febdb3cea6287cbefaccedb630db7f8 100644
--- a/src/share/classes/java/lang/invoke/package-info.java
+++ b/src/share/classes/java/lang/invoke/package-info.java
@@ -185,7 +185,7 @@
* The method handle constant produced for such a method behaves as if
* it were created by {@link java.lang.invoke.MethodHandle#asVarargsCollector asVarargsCollector}.
* In other words, the constant method handle will exhibit variable arity,
- * when invoked via {@code invokeGeneric}.
+ * when invoked via {@code MethodHandle.invoke}.
* On the other hand, its behavior with respect to {@code invokeExact} will be the same
* as if the {@code varargs} bit were not set.
*
*
* The method handle is then applied to the other values as if by
- * {@link java.lang.invoke.MethodHandle#invokeGeneric invokeGeneric}.
+ * {@link java.lang.invoke.MethodHandle#invoke MethodHandle.invoke}.
* The returned result must be a {@link java.lang.invoke.CallSite CallSite} (or a subclass).
* The type of the call site's target must be exactly equal to the type
* derived from the dynamic call site's type descriptor and passed to
@@ -251,7 +251,7 @@
* The call site then becomes permanently linked to the dynamic call site.
*
* As long as each bootstrap method can be correctly invoked
- * by invokeGeneric, its detailed type is arbitrary.
+ * by MethodHandle.invoke, its detailed type is arbitrary.
* For example, the first argument could be {@code Object}
* instead of {@code MethodHandles.Lookup}, and the return type
* could also be {@code Object} instead of {@code CallSite}.
@@ -272,7 +272,7 @@
* (i.e., a {@code CONSTANT_Class}, {@code CONSTANT_MethodType},
* or {@code CONSTANT_MethodHandle} argument cannot be linked)
*
the bootstrap method has the wrong arity,
- * causing {@code invokeGeneric} to throw {@code WrongMethodTypeException}
+ * causing {@code MethodHandle.invoke} to throw {@code WrongMethodTypeException}
*
the bootstrap method has a wrong argument or return type
*
the bootstrap method invocation completes abnormally
*
the result from the bootstrap invocation is not a reference to
@@ -381,10 +381,10 @@
* those values will be passed as additional arguments to the method handle.
* (Note that because there is a limit of 255 arguments to any method,
* at most 252 extra arguments can be supplied.)
- * The bootstrap method will be invoked as if by either {@code invokeGeneric}
+ * The bootstrap method will be invoked as if by either {@code MethodHandle.invoke}
* or {@code invokeWithArguments}. (There is no way to tell the difference.)
*
- * The normal argument conversion rules for {@code invokeGeneric} apply to all stacked arguments.
+ * The normal argument conversion rules for {@code MethodHandle.invoke} apply to all stacked arguments.
* For example, if a pushed value is a primitive type, it may be converted to a reference by boxing conversion.
* If the bootstrap method is a variable arity method (its modifier bit {@code 0x0080} is set),
* then some or all of the arguments specified here may be collected into a trailing array parameter.
@@ -419,8 +419,8 @@
* For example, the fourth argument could be {@code MethodHandle},
* if that is the type of the corresponding constant in
* the {@code CONSTANT_InvokeDynamic} entry.
- * In that case, the {@code invokeGeneric} call will pass the extra method handle
- * constant as an {@code Object}, but the type matching machinery of {@code invokeGeneric}
+ * In that case, the {@code MethodHandle.invoke} call will pass the extra method handle
+ * constant as an {@code Object}, but the type matching machinery of {@code MethodHandle.invoke}
* will cast the reference back to {@code MethodHandle} before invoking the bootstrap method.
* (If a string constant were passed instead, by badly generated code, that cast would then fail,
* resulting in a {@code BootstrapMethodError}.)
diff --git a/src/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html b/src/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html
index 721bdb2e702798a527903c7ec047d01b966ff48f..5d3b0ea5e7d573b247a6db56734d47bcd3e7bc1f 100644
--- a/src/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html
+++ b/src/share/classes/javax/imageio/metadata/doc-files/jpeg_metadata.html
@@ -211,6 +211,20 @@ to any listeners.
+Optional ColorSpace support:
+Handling of PhotoYCC (YCC), PhotoYCCA (YCCA), RGBA and YCbCrA color spaces
+by the standard plugin, as described below, is dependent on capabilities
+of the libraries used to interpret the JPEG data. Thus all consequential
+behaviors are optional. If the support is not available when decoding,
+the color space will be treated as unrecognized and the appropriate
+default color space for the specified number of component channels
+may be used.
+When writing, an Exception may be thrown if no suitable conversion
+can be applied before encoding.
+But where the support for these color spaces is available, the behavior
+must be as documented.
+
+
When reading, the contents of the stream are interpreted by the usual
JPEG conventions, as follows:
@@ -241,8 +255,11 @@ JPEG conventions, as follows:
2-channel images are assumed to be grayscale with an alpha channel.
For 3- and 4-channel images, the component ids are consulted. If these
values are 1-3 for a 3-channel image, then the image is assumed to be
- YCbCr. If these values are 1-4 for a 4-channel image, then the image
- is assumed to be YCbCrA. If these values are > 4, they are checked
+ YCbCr. Subject to the availability of the
+ optional color space support
+ described above, if these values are 1-4 for a 4-channel image,
+ then the image is assumed to be YCbCrA.
+ If these values are > 4, they are checked
against the ASCII codes for 'R', 'G', 'B', 'A', 'C', 'c'. These can
encode the following colorspaces:
@@ -346,12 +363,16 @@ If no metadata object is specified, then the following defaults apply:
component ids in the frame and scan headers are set to 1, 2, and 3.
-
RGBA images are converted to YCbCrA, subsampled in the
+
Subject to the optional library support
+ described above,
+ RGBA images are converted to YCbCrA, subsampled in the
chrominance channels by half both vertically and horizontally, and
written without any special marker segments. The component ids
in the frame and scan headers are set to 1, 2, 3, and 4.
-
PhotoYCC and YCCAimages are subsampled by half in the chrominance
+
Subject to the optional library support
+ described above,
+ PhotoYCC and YCCAimages are subsampled by half in the chrominance
channels both vertically and horizontally and written with an
Adobe APP14 marker segment and 'Y','C', and 'c' (and
'A' if an alpha channel is present) as component ids in the frame
@@ -433,6 +454,8 @@ in the frame header node of the metadata object, regardless of color space.)
If an app0JFIF node is present in the metadata object,
it is ignored and a warning is sent to listeners, as JFIF does not
@@ -456,6 +479,8 @@ in the frame header node of the metadata object, regardless of color space.)
If an app0JFIF node is present in the metadata object,
the image is converted to sRGB, and then to YCbCr during encoding,
@@ -471,6 +496,8 @@ in the frame header node of the metadata object, regardless of color space.)
If an app0JFIF node is present in the metadata object,
it is ignored and a warning is sent to listeners, as JFIF does not
diff --git a/src/share/classes/javax/swing/ComboBoxModel.java b/src/share/classes/javax/swing/ComboBoxModel.java
index 78ac525ec7dbc8df6abd9f151647d20daa1f3015..4b657daf88135732789aed26dc8eb47b8e2ed30b 100644
--- a/src/share/classes/javax/swing/ComboBoxModel.java
+++ b/src/share/classes/javax/swing/ComboBoxModel.java
@@ -33,9 +33,11 @@ package javax.swing;
* ListModel. This disjoint behavior allows for the temporary
* storage and retrieval of a selected item in the model.
*
+ * @param the type of the elements of this model
+ *
* @author Arnaud Weber
*/
-public interface ComboBoxModel extends ListModel {
+public interface ComboBoxModel extends ListModel {
/**
* Set the selected item. The implementation of this method should notify
diff --git a/src/share/classes/javax/swing/DefaultComboBoxModel.java b/src/share/classes/javax/swing/DefaultComboBoxModel.java
index f7cc50b1a7078353c83313560000d462e9b5e762..f0266fc73511f1edfdcb234a4af96a47ea696e60 100644
--- a/src/share/classes/javax/swing/DefaultComboBoxModel.java
+++ b/src/share/classes/javax/swing/DefaultComboBoxModel.java
@@ -24,39 +24,28 @@
*/
package javax.swing;
-import java.beans.*;
import java.util.*;
-import java.awt.*;
-import java.awt.event.*;
-
import java.io.Serializable;
-import java.io.ObjectOutputStream;
-import java.io.ObjectInputStream;
-import java.io.IOException;
-
-import javax.swing.event.*;
-import javax.swing.plaf.*;
-import javax.swing.border.*;
-
-import javax.accessibility.*;
/**
* The default model for combo boxes.
*
+ * @param the type of the elements of this model
+ *
* @author Arnaud Weber
* @author Tom Santos
*/
-public class DefaultComboBoxModel extends AbstractListModel implements MutableComboBoxModel, Serializable {
- Vector objects;
+public class DefaultComboBoxModel extends AbstractListModel implements MutableComboBoxModel, Serializable {
+ Vector objects;
Object selectedObject;
/**
* Constructs an empty DefaultComboBoxModel object.
*/
public DefaultComboBoxModel() {
- objects = new Vector();
+ objects = new Vector();
}
/**
@@ -65,8 +54,8 @@ public class DefaultComboBoxModel extends AbstractListModel implements MutableCo
*
* @param items an array of Object objects
*/
- public DefaultComboBoxModel(final Object items[]) {
- objects = new Vector();
+ public DefaultComboBoxModel(final E items[]) {
+ objects = new Vector();
objects.ensureCapacity( items.length );
int i,c;
@@ -84,7 +73,7 @@ public class DefaultComboBoxModel extends AbstractListModel implements MutableCo
*
* @param v a Vector object ...
*/
- public DefaultComboBoxModel(Vector v) {
+ public DefaultComboBoxModel(Vector v) {
objects = v;
if ( getSize() > 0 ) {
@@ -117,7 +106,7 @@ public class DefaultComboBoxModel extends AbstractListModel implements MutableCo
}
// implements javax.swing.ListModel
- public Object getElementAt(int index) {
+ public E getElementAt(int index) {
if ( index >= 0 && index < objects.size() )
return objects.elementAt(index);
else
@@ -136,7 +125,7 @@ public class DefaultComboBoxModel extends AbstractListModel implements MutableCo
}
// implements javax.swing.MutableComboBoxModel
- public void addElement(Object anObject) {
+ public void addElement(E anObject) {
objects.addElement(anObject);
fireIntervalAdded(this,objects.size()-1, objects.size()-1);
if ( objects.size() == 1 && selectedObject == null && anObject != null ) {
@@ -145,7 +134,7 @@ public class DefaultComboBoxModel extends AbstractListModel implements MutableCo
}
// implements javax.swing.MutableComboBoxModel
- public void insertElementAt(Object anObject,int index) {
+ public void insertElementAt(E anObject,int index) {
objects.insertElementAt(anObject,index);
fireIntervalAdded(this, index, index);
}
diff --git a/src/share/classes/javax/swing/JComboBox.java b/src/share/classes/javax/swing/JComboBox.java
index b4a414bbf1aa29374263999cec935c0b62fd1fb7..8ac710910a84ead4e0e1007e23a9eb05de2515c2 100644
--- a/src/share/classes/javax/swing/JComboBox.java
+++ b/src/share/classes/javax/swing/JComboBox.java
@@ -69,6 +69,8 @@ import javax.accessibility.*;
* @see ComboBoxModel
* @see DefaultComboBoxModel
*
+ * @param the type of the elements of this combo box
+ *
* @beaninfo
* attribute: isContainer false
* description: A combination of a text field and a drop-down list.
@@ -76,7 +78,7 @@ import javax.accessibility.*;
* @author Arnaud Weber
* @author Mark Davidson
*/
-public class JComboBox extends JComponent
+public class JComboBox extends JComponent
implements ItemSelectable,ListDataListener,ActionListener, Accessible {
/**
* @see #getUIClassID
@@ -91,7 +93,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* @see #getModel
* @see #setModel
*/
- protected ComboBoxModel dataModel;
+ protected ComboBoxModel dataModel;
/**
* This protected field is implementation specific. Do not access directly
* or override. Use the accessor methods instead.
@@ -99,7 +101,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* @see #getRenderer
* @see #setRenderer
*/
- protected ListCellRenderer renderer;
+ protected ListCellRenderer renderer;
/**
* This protected field is implementation specific. Do not access directly
* or override. Use the accessor methods instead.
@@ -156,7 +158,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
*/
protected Object selectedItemReminder = null;
- private Object prototypeDisplayValue;
+ private E prototypeDisplayValue;
// Flag to ensure that infinite loops do not occur with ActionEvents.
private boolean firingActionEvent = false;
@@ -175,7 +177,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* displayed list of items
* @see DefaultComboBoxModel
*/
- public JComboBox(ComboBoxModel aModel) {
+ public JComboBox(ComboBoxModel aModel) {
super();
setModel(aModel);
init();
@@ -189,9 +191,9 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* @param items an array of objects to insert into the combo box
* @see DefaultComboBoxModel
*/
- public JComboBox(final Object items[]) {
+ public JComboBox(E[] items) {
super();
- setModel(new DefaultComboBoxModel(items));
+ setModel(new DefaultComboBoxModel(items));
init();
}
@@ -203,9 +205,9 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* @param items an array of vectors to insert into the combo box
* @see DefaultComboBoxModel
*/
- public JComboBox(Vector items) {
+ public JComboBox(Vector items) {
super();
- setModel(new DefaultComboBoxModel(items));
+ setModel(new DefaultComboBoxModel(items));
init();
}
@@ -219,7 +221,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
*/
public JComboBox() {
super();
- setModel(new DefaultComboBoxModel());
+ setModel(new DefaultComboBoxModel());
init();
}
@@ -263,7 +265,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
public void updateUI() {
setUI((ComboBoxUI)UIManager.getUI(this));
- ListCellRenderer renderer = getRenderer();
+ ListCellRenderer renderer = getRenderer();
if (renderer instanceof Component) {
SwingUtilities.updateComponentTreeUI((Component)renderer);
}
@@ -302,8 +304,8 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* bound: true
* description: Model that the combo box uses to get data to display.
*/
- public void setModel(ComboBoxModel aModel) {
- ComboBoxModel oldModel = dataModel;
+ public void setModel(ComboBoxModel aModel) {
+ ComboBoxModel oldModel = dataModel;
if (oldModel != null) {
oldModel.removeListDataListener(this);
}
@@ -322,7 +324,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* @return the ComboBoxModel that provides the displayed
* list of items
*/
- public ComboBoxModel getModel() {
+ public ComboBoxModel getModel() {
return dataModel;
}
@@ -461,8 +463,8 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* expert: true
* description: The renderer that paints the item selected in the list.
*/
- public void setRenderer(ListCellRenderer aRenderer) {
- ListCellRenderer oldRenderer = renderer;
+ public void setRenderer(ListCellRenderer aRenderer) {
+ ListCellRenderer oldRenderer = renderer;
renderer = aRenderer;
firePropertyChange( "renderer", oldRenderer, renderer );
invalidate();
@@ -475,7 +477,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* @return the ListCellRenderer that displays
* the selected item.
*/
- public ListCellRenderer getRenderer() {
+ public ListCellRenderer getRenderer() {
return renderer;
}
@@ -558,7 +560,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
// will be rejected.
boolean found = false;
for (int i = 0; i < dataModel.getSize(); i++) {
- Object element = dataModel.getElementAt(i);
+ E element = dataModel.getElementAt(i);
if (anObject.equals(element)) {
found = true;
objectToSelect = element;
@@ -640,7 +642,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
public int getSelectedIndex() {
Object sObject = dataModel.getSelectedItem();
int i,c;
- Object obj;
+ E obj;
for ( i=0,c=dataModel.getSize();i
*
- * @param anObject the Object to add to the list
+ * @param item the item to add to the list
* @see MutableComboBoxModel
*/
- public void addItem(Object anObject) {
+ public void addItem(E item) {
checkMutableComboBoxModel();
- ((MutableComboBoxModel)dataModel).addElement(anObject);
+ ((MutableComboBoxModel)dataModel).addElement(item);
}
/**
@@ -721,14 +723,14 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
* This method works only if the JComboBox uses a
* mutable data model.
*
- * @param anObject the Object to add to the list
+ * @param item the item to add to the list
* @param index an integer specifying the position at which
* to add the item
* @see MutableComboBoxModel
*/
- public void insertItemAt(Object anObject, int index) {
+ public void insertItemAt(E item, int index) {
checkMutableComboBoxModel();
- ((MutableComboBoxModel)dataModel).insertElementAt(anObject,index);
+ ((MutableComboBoxModel)dataModel).insertElementAt(item,index);
}
/**
@@ -756,7 +758,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
*/
public void removeItemAt(int anIndex) {
checkMutableComboBoxModel();
- ((MutableComboBoxModel)dataModel).removeElementAt( anIndex );
+ ((MutableComboBoxModel)dataModel).removeElementAt( anIndex );
}
/**
@@ -764,7 +766,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
*/
public void removeAllItems() {
checkMutableComboBoxModel();
- MutableComboBoxModel model = (MutableComboBoxModel)dataModel;
+ MutableComboBoxModel model = (MutableComboBoxModel)dataModel;
int size = model.getSize();
if ( model instanceof DefaultComboBoxModel ) {
@@ -772,7 +774,7 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
}
else {
for ( int i = 0; i < size; ++i ) {
- Object element = model.getElementAt( 0 );
+ E element = model.getElementAt( 0 );
model.removeElement( element );
}
}
@@ -1188,11 +1190,11 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
private static class ComboBoxActionPropertyChangeListener
- extends ActionPropertyChangeListener {
- ComboBoxActionPropertyChangeListener(JComboBox b, Action a) {
+ extends ActionPropertyChangeListener> {
+ ComboBoxActionPropertyChangeListener(JComboBox b, Action a) {
super(b, a);
}
- protected void actionPropertyChanged(JComboBox cb,
+ protected void actionPropertyChanged(JComboBox cb,
Action action,
PropertyChangeEvent e) {
if (AbstractAction.shouldReconfigure(e)) {
@@ -1454,10 +1456,10 @@ implements ItemSelectable,ListDataListener,ActionListener, Accessible {
*
* @param index an integer indicating the list position, where the first
* item starts at zero
- * @return the Object at that list position; or
+ * @return the item at that list position; or
* null if out of range
*/
- public Object getItemAt(int index) {
+ public E getItemAt(int index) {
return dataModel.getElementAt(index);
}
diff --git a/src/share/classes/javax/swing/MutableComboBoxModel.java b/src/share/classes/javax/swing/MutableComboBoxModel.java
index 03b75631af93c3548e9cdf68f7c5469968e125b8..90f9474a7ea95b3fcb1b537a120899a8ba5bb74e 100644
--- a/src/share/classes/javax/swing/MutableComboBoxModel.java
+++ b/src/share/classes/javax/swing/MutableComboBoxModel.java
@@ -27,19 +27,21 @@ package javax.swing;
/**
* A mutable version of ComboBoxModel.
*
+ * @param the type of the elements of this model
+ *
* @author Tom Santos
*/
-public interface MutableComboBoxModel extends ComboBoxModel {
+public interface MutableComboBoxModel extends ComboBoxModel {
/**
* Adds an item at the end of the model. The implementation of this method
* should notify all registered ListDataListeners that the
* item has been added.
*
- * @param obj the Object to be added
+ * @param item the item to be added
*/
- public void addElement( Object obj );
+ public void addElement( E item );
/**
* Removes an item from the model. The implementation of this method should
@@ -55,17 +57,17 @@ public interface MutableComboBoxModel extends ComboBoxModel {
* should notify all registered ListDataListeners that the
* item has been added.
*
- * @param obj the Object to be added
+ * @param item the item to be added
* @param index location to add the object
*/
- public void insertElementAt( Object obj, int index );
+ public void insertElementAt( E item, int index );
/**
* Removes an item at a specific index. The implementation of this method
* should notify all registered ListDataListeners that the
* item has been removed.
*
- * @param index location of object to be removed
+ * @param index location of the item to be removed
*/
public void removeElementAt( int index );
}
diff --git a/src/share/classes/javax/swing/plaf/basic/BasicDirectoryModel.java b/src/share/classes/javax/swing/plaf/basic/BasicDirectoryModel.java
index f34b8d1684c7c87547da66ee868c4f2519da5399..23252d77a581e073d02e7b2fb3e95ba16d8500cf 100644
--- a/src/share/classes/javax/swing/plaf/basic/BasicDirectoryModel.java
+++ b/src/share/classes/javax/swing/plaf/basic/BasicDirectoryModel.java
@@ -40,7 +40,7 @@ import sun.awt.shell.ShellFolder;
*
* @author Jeff Dinkins
*/
-public class BasicDirectoryModel extends AbstractListModel implements PropertyChangeListener {
+public class BasicDirectoryModel extends AbstractListModel