JDK 11 jdk.rmic.jmod - RMI Compiler Tool
JDK 11 jdk.rmic.jmod is the JMOD file for JDK 11 RMI (Remote Method Invocation) Compiler Tool tool,
which can be invoked by the "rmic" command.
JDK 11 RMI Compiler Tool tool compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.rmic.jmod.
JDK 11 RMI Compiler Tool tool compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 RMI Compiler Tool tool source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.rmic.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ sun/tools/tree/NewInstanceExpression.java
/*
* Copyright (c) 1994, 2003, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package sun.tools.tree;
import sun.tools.java.*;
import sun.tools.asm.Assembler;
import java.util.Hashtable;
/**
* WARNING: The contents of this source file are not part of any
* supported API. Code that depends on them does so at its own risk:
* they are subject to change or removal without notice.
*/
public
class NewInstanceExpression extends NaryExpression {
MemberDefinition field;
Expression outerArg;
ClassDefinition body;
// Access method for constructor, if needed.
MemberDefinition implMethod = null;
/**
* Constructor
*/
public NewInstanceExpression(long where, Expression right, Expression args[]) {
super(NEWINSTANCE, where, Type.tError, right, args);
}
public NewInstanceExpression(long where, Expression right,
Expression args[],
Expression outerArg, ClassDefinition body) {
this(where, right, args);
this.outerArg = outerArg;
this.body = body;
}
/**
* From the "new" in an expression of the form outer.new InnerCls(...),
* return the "outer" expression, or null if there is none.
*/
public Expression getOuterArg() {
return outerArg;
}
int precedence() {
return 100;
}
public Expression order() {
// act like a method or field reference expression:
if (outerArg != null && opPrecedence[FIELD] > outerArg.precedence()) {
UnaryExpression e = (UnaryExpression)outerArg;
outerArg = e.right;
e.right = order();
return e;
}
return this;
}
/**
* Check expression type
*/
public Vset checkValue(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) {
// What type?
ClassDefinition def = null;
Expression alreadyChecked = null;
try {
if (outerArg != null) {
vset = outerArg.checkValue(env, ctx, vset, exp);
// Remember the expression that we already checked
// so that we don't attempt to check it again when
// it appears as an argument to the constructor.
// Fix for 4030426.
alreadyChecked = outerArg;
// Check outerArg and the type name together.
Identifier typeName = FieldExpression.toIdentifier(right);
// According to the inner classes spec, the type name in a
// qualified 'new' expression must be a single identifier.
if (typeName != null && typeName.isQualified()) {
env.error(where, "unqualified.name.required", typeName);
}
if (typeName == null || !outerArg.type.isType(TC_CLASS)) {
if (!outerArg.type.isType(TC_ERROR)) {
env.error(where, "invalid.field.reference",
idNew, outerArg.type);
}
outerArg = null;
} else {
// Don't perform checks on components of qualified name
// ('getQualifiedClassDefinition'), because a qualified
// name is illegal in this context, and will have previously
// been reported as an error.
ClassDefinition oc = env.getClassDefinition(outerArg.type);
Identifier nm = oc.resolveInnerClass(env, typeName);
right = new TypeExpression(right.where, Type.tClass(nm));
// Check access directly, since we're not calling toType().
env.resolve(right.where, ctx.field.getClassDefinition(),
right.type);
// and fall through to env.getClassDefinition() below
}
}
if (!(right instanceof TypeExpression)) {
// The call to 'toType' should perform component access checks.
right = new TypeExpression(right.where, right.toType(env, ctx));
}
if (right.type.isType(TC_CLASS))
def = env.getClassDefinition(right.type);
} catch (AmbiguousClass ee) {
env.error(where, "ambig.class", ee.name1, ee.name2);
} catch (ClassNotFound ee) {
env.error(where, "class.not.found", ee.name, ctx.field);
}
Type t = right.type;
boolean hasErrors = t.isType(TC_ERROR);
if (!t.isType(TC_CLASS)) {
if (!hasErrors) {
env.error(where, "invalid.arg.type", t, opNames[op]);
hasErrors = true;
}
}
// If we failed to find a class or a class was ambiguous, def
// may be null. Bail out. This allows us to report multiple
// unfound or ambiguous classes rather than tripping over an
// internal compiler error.
if (def == null) {
type = Type.tError;
return vset;
}
// Add an extra argument, maybe.
Expression args[] = this.args;
args = NewInstanceExpression.
insertOuterLink(env, ctx, where, def, outerArg, args);
if (args.length > this.args.length)
outerArg = args[0]; // recopy the checked arg
else if (outerArg != null)
// else set it to void (maybe it has a side-effect)
outerArg = new CommaExpression(outerArg.where, outerArg, null);
// Compose a list of argument types
Type argTypes[] = new Type[args.length];
for (int i = 0 ; i < args.length ; i++) {
// Don't check 'outerArg' again. Fix for 4030426.
if (args[i] != alreadyChecked) {
vset = args[i].checkValue(env, ctx, vset, exp);
}
argTypes[i] = args[i].type;
hasErrors = hasErrors || argTypes[i].isType(TC_ERROR);
}
try {
// Check if there are any type errors in the arguments
if (hasErrors) {
type = Type.tError;
return vset;
}
// Get the source class that this declaration appears in.
ClassDefinition sourceClass = ctx.field.getClassDefinition();
ClassDeclaration c = env.getClassDeclaration(t);
// If this is an anonymous class, handle it specially now.
if (body != null) {
// The current package.
Identifier packageName = sourceClass.getName().getQualifier();
// This is an anonymous class.
ClassDefinition superDef = null;
if (def.isInterface()) {
// For interfaces, our superclass is java.lang.Object.
// We could just assume that java.lang.Object has
// one constructor with no arguments in the code
// that follows, but we don't. This way, if Object
// grows a new constructor (unlikely) then the
// compiler should handle it.
superDef = env.getClassDefinition(idJavaLangObject);
} else {
// Otherwise, def is actually our superclass.
superDef = def;
}
// Try to find a matching constructor in our superclass.
MemberDefinition constructor =
superDef.matchAnonConstructor(env, packageName, argTypes);
if (constructor != null) {
// We've found one. Process the body.
//
// Note that we are passing in the constructors' argument
// types, rather than the argument types of the actual
// expressions, to checkLocalClass(). Previously,
// the expression types were passed in. This could
// lead to trouble when one of the argument types was
// the special internal type tNull. (bug 4054689).
if (tracing)
env.dtEvent(
"NewInstanceExpression.checkValue: ANON CLASS " +
body + " SUPER " + def);
vset = body.checkLocalClass(env, ctx, vset,
def, args,
constructor.getType()
.getArgumentTypes());
// Set t to be the true type of this expression.
// (bug 4102056).
t = body.getClassDeclaration().getType();
def = body;
}
} else {
// Check if it is an interface
if (def.isInterface()) {
env.error(where, "new.intf", c);
return vset;
}
// Check for abstract class
if (def.mustBeAbstract(env)) {
env.error(where, "new.abstract", c);
return vset;
}
}
// Get the constructor that the "new" expression should call.
field = def.matchMethod(env, sourceClass, idInit, argTypes);
// Report an error if there is no matching constructor.
if (field == null) {
MemberDefinition anyInit = def.findAnyMethod(env, idInit);
if (anyInit != null &&
new MethodExpression(where, right, anyInit, args)
.diagnoseMismatch(env, args, argTypes))
return vset;
String sig = c.getName().getName().toString();
sig = Type.tMethod(Type.tError, argTypes).typeString(sig, false, false);
env.error(where, "unmatched.constr", sig, c);
return vset;
}
if (field.isPrivate()) {
ClassDefinition cdef = field.getClassDefinition();
if (cdef != sourceClass) {
// Use access method.
implMethod = cdef.getAccessMember(env, ctx, field, false);
}
}
// Check for abstract anonymous class
if (def.mustBeAbstract(env)) {
env.error(where, "new.abstract", c);
return vset;
}
if (field.reportDeprecated(env)) {
env.error(where, "warn.constr.is.deprecated",
field, field.getClassDefinition());
}
// According to JLS 6.6.2, a protected constructor may be accessed
// by a class instance creation expression only from within the
// package in which it is defined.
if (field.isProtected() &&
!(sourceClass.getName().getQualifier().equals(
field.getClassDeclaration().getName().getQualifier()))) {
env.error(where, "invalid.protected.constructor.use",
sourceClass);
}
} catch (ClassNotFound ee) {
env.error(where, "class.not.found", ee.name, opNames[op]);
return vset;
} catch (AmbiguousMember ee) {
env.error(where, "ambig.constr", ee.field1, ee.field2);
return vset;
}
// Cast arguments
argTypes = field.getType().getArgumentTypes();
for (int i = 0 ; i < args.length ; i++) {
args[i] = convert(env, ctx, argTypes[i], args[i]);
}
if (args.length > this.args.length) {
outerArg = args[0]; // recopy the checked arg
// maintain an accurate tree
for (int i = 1 ; i < args.length ; i++) {
this.args[i-1] = args[i];
}
}
// Throw the declared exceptions.
ClassDeclaration exceptions[] = field.getExceptions(env);
for (int i = 0 ; i < exceptions.length ; i++) {
if (exp.get(exceptions[i]) == null) {
exp.put(exceptions[i], this);
}
}
type = t;
return vset;
}
/**
* Given a list of arguments for a constructor,
* return a possibly modified list which includes the hidden
* argument which initializes the uplevel self pointer.
* @arg def the class which perhaps contains an outer link.
* @arg outerArg if non-null, an explicit location in which to construct.
*/
public static Expression[] insertOuterLink(Environment env, Context ctx,
long where, ClassDefinition def,
Expression outerArg,
Expression args[]) {
if (!def.isTopLevel() && !def.isLocal()) {
Expression args2[] = new Expression[1+args.length];
System.arraycopy(args, 0, args2, 1, args.length);
try {
if (outerArg == null)
outerArg = ctx.findOuterLink(env, where,
def.findAnyMethod(env, idInit));
} catch (ClassNotFound e) {
// die somewhere else
}
args2[0] = outerArg;
args = args2;
}
return args;
}
/**
* Check void expression
*/
public Vset check(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) {
return checkValue(env, ctx, vset, exp);
}
/**
* Inline
*/
final int MAXINLINECOST = Statement.MAXINLINECOST;
public Expression copyInline(Context ctx) {
NewInstanceExpression e = (NewInstanceExpression)super.copyInline(ctx);
if (outerArg != null) {
e.outerArg = outerArg.copyInline(ctx);
}
return e;
}
Expression inlineNewInstance(Environment env, Context ctx, Statement s) {
if (env.dump()) {
System.out.println("INLINE NEW INSTANCE " + field + " in " + ctx.field);
}
LocalMember v[] = LocalMember.copyArguments(ctx, field);
Statement body[] = new Statement[v.length + 2];
int o = 1;
if (outerArg != null && !outerArg.type.isType(TC_VOID)) {
o = 2;
body[1] = new VarDeclarationStatement(where, v[1], outerArg);
} else if (outerArg != null) {
body[0] = new ExpressionStatement(where, outerArg);
}
for (int i = 0 ; i < args.length ; i++) {
body[i+o] = new VarDeclarationStatement(where, v[i+o], args[i]);
}
//System.out.print("BEFORE:"); s.print(System.out); System.out.println();
body[body.length - 1] = (s != null) ? s.copyInline(ctx, false) : null;
//System.out.print("COPY:"); body[body.length - 1].print(System.out); System.out.println();
//System.out.print("AFTER:"); s.print(System.out); System.out.println();
LocalMember.doneWithArguments(ctx, v);
return new InlineNewInstanceExpression(where, type, field, new CompoundStatement(where, body)).inline(env, ctx);
}
public Expression inline(Environment env, Context ctx) {
return inlineValue(env, ctx);
}
public Expression inlineValue(Environment env, Context ctx) {
if (body != null) {
body.inlineLocalClass(env);
}
ClassDefinition refc = field.getClassDefinition();
UplevelReference r = refc.getReferencesFrozen();
if (r != null) {
r.willCodeArguments(env, ctx);
}
//right = right.inlineValue(env, ctx);
try {
if (outerArg != null) {
if (outerArg.type.isType(TC_VOID))
outerArg = outerArg.inline(env, ctx);
else
outerArg = outerArg.inlineValue(env, ctx);
}
for (int i = 0 ; i < args.length ; i++) {
args[i] = args[i].inlineValue(env, ctx);
}
// This 'false' that fy put in is inexplicable to me
// the decision to not inline new instance expressions
// should be revisited. - dps
if (false && env.opt() && field.isInlineable(env, false) &&
(!ctx.field.isInitializer()) && ctx.field.isMethod() &&
(ctx.getInlineMemberContext(field) == null)) {
Statement s = (Statement)field.getValue(env);
if ((s == null)
|| (s.costInline(MAXINLINECOST, env, ctx) < MAXINLINECOST)) {
return inlineNewInstance(env, ctx, s);
}
}
} catch (ClassNotFound e) {
throw new CompilerError(e);
}
if (outerArg != null && outerArg.type.isType(TC_VOID)) {
Expression e = outerArg;
outerArg = null;
return new CommaExpression(where, e, this);
}
return this;
}
public int costInline(int thresh, Environment env, Context ctx) {
if (body != null) {
return thresh; // don't copy classes...
}
if (ctx == null) {
return 2 + super.costInline(thresh, env, ctx);
}
// sourceClass is the current class trying to inline this method
ClassDefinition sourceClass = ctx.field.getClassDefinition();
try {
// We only allow the inlining if the current class can access
// the field and the field's class;
if ( sourceClass.permitInlinedAccess(env, field.getClassDeclaration())
&& sourceClass.permitInlinedAccess(env, field)) {
return 2 + super.costInline(thresh, env, ctx);
}
} catch (ClassNotFound e) {
}
return thresh;
}
/**
* Code
*/
public void code(Environment env, Context ctx, Assembler asm) {
codeCommon(env, ctx, asm, false);
}
public void codeValue(Environment env, Context ctx, Assembler asm) {
codeCommon(env, ctx, asm, true);
}
@SuppressWarnings("fallthrough")
private void codeCommon(Environment env, Context ctx, Assembler asm,
boolean forValue) {
asm.add(where, opc_new, field.getClassDeclaration());
if (forValue) {
asm.add(where, opc_dup);
}
ClassDefinition refc = field.getClassDefinition();
UplevelReference r = refc.getReferencesFrozen();
if (r != null) {
r.codeArguments(env, ctx, asm, where, field);
}
if (outerArg != null) {
outerArg.codeValue(env, ctx, asm);
switch (outerArg.op) {
case THIS:
case SUPER:
case NEW:
// guaranteed non-null
break;
case FIELD: {
MemberDefinition f = ((FieldExpression)outerArg).field;
if (f != null && f.isNeverNull()) {
break;
}
// else fall through:
}
default:
// Test for nullity by invoking some trivial operation
// that can throw a NullPointerException.
try {
ClassDefinition c = env.getClassDefinition(idJavaLangObject);
MemberDefinition getc = c.getFirstMatch(idGetClass);
asm.add(where, opc_dup);
asm.add(where, opc_invokevirtual, getc);
asm.add(where, opc_pop);
} catch (ClassNotFound e) {
}
}
}
if (implMethod != null) {
// Constructor call will be via an access method.
// Pass 'null' as the value of the dummy argument.
asm.add(where, opc_aconst_null);
}
for (int i = 0 ; i < args.length ; i++) {
args[i].codeValue(env, ctx, asm);
}
asm.add(where, opc_invokespecial,
((implMethod != null) ? implMethod : field));
}
}
⏎ sun/tools/tree/NewInstanceExpression.java
Or download all of them as a single archive file:
File name: jdk.rmic-11.0.1-src.zip File size: 418901 bytes Release date: 2018-11-04 Download
⇒ JDK 11 jdk.scripting.nashorn.jmod - Scripting Nashorn Module
2020-04-25, 45215👍, 0💬
Related Topics: