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/Context.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;

/**
 * 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 Context implements Constants {
    Context prev;
    Node node;
    int varNumber;
    LocalMember locals;
    LocalMember classes;
    MemberDefinition field;
    int scopeNumber;
    int frameNumber;

    /**
     * Create the initial context for a method
     * The incoming context is inherited from
     */
    public Context(Context ctx, MemberDefinition field) {
        this.field = field;
        if (ctx == null) {
            this.frameNumber = 1;
            this.scopeNumber = 2;
            this.varNumber = 0;
        } else {
            this.prev = ctx;
            this.locals = ctx.locals;
            this.classes = ctx.classes;
            if (field != null &&
                  (field.isVariable() || field.isInitializer())) {
                // Variables and initializers are inlined into a constructor.
                // Model this by inheriting the frame number of the parent,
                // which will contain a "this" parameter.
                this.frameNumber = ctx.frameNumber;
                this.scopeNumber = ctx.scopeNumber + 1;
            } else {
                this.frameNumber = ctx.scopeNumber + 1;
                this.scopeNumber = this.frameNumber + 1;
            }
            this.varNumber = ctx.varNumber;
        }
    }

    /**
     * Create a new context, for initializing a class.
     */
    public Context(Context ctx, ClassDefinition c) {
        this(ctx, (MemberDefinition)null);
    }

    /**
     * Create a new nested context, for a block statement
     */
    Context(Context ctx, Node node) {
        if (ctx == null) {
            this.frameNumber = 1;
            this.scopeNumber = 2;
            this.varNumber = 0;
        } else {
            this.prev = ctx;
            this.locals = ctx.locals;
            // Inherit local classes from surrounding block,
            // just as for local variables.  Fixes 4074421.
            this.classes = ctx.classes;
            this.varNumber = ctx.varNumber;
            this.field = ctx.field;
            this.frameNumber = ctx.frameNumber;
            this.scopeNumber = ctx.scopeNumber + 1;
            this.node = node;
        }
    }

    public Context(Context ctx) {
        this(ctx, (Node)null);
    }

    /**
     * Declare local
     */
    public int declare(Environment env, LocalMember local) {
        //System.out.println(   "DECLARE= " + local.getName() + "=" + varNumber + ", read=" + local.readcount + ", write=" + local.writecount + ", hash=" + local.hashCode());
        local.scopeNumber = scopeNumber;
        if (this.field == null && idThis.equals(local.getName())) {
            local.scopeNumber += 1; // Anticipate variable or initializer.
        }
        if (local.isInnerClass()) {
            local.prev = classes;
            classes = local;
            return 0;
        }

        // Originally the statement:
        //
        //     local.subModifiers(M_INLINEABLE);
        //
        // was here with the comment:
        //
        //     // prevent inlining across call sites
        //
        // This statement prevented constant local variables from
        // inlining. It didn't seem to do anything useful.
        //
        // The statement has been removed and an assertion has been
        // added which mandates that the only members which are marked
        // with M_INLINEABLE are the ones for which isConstant() is true.
        // (Fix for 4106244.)
        //
        // Addition to the above comment: they might also be
        // final variables initialized with 'this', 'super', or other
        // final identifiers.  See VarDeclarationStatement.inline().
        // So I've removed the assertion.  The original subModifiers
        // call appears to have been there to fix nested class translation
        // breakage, which has been fixed in VarDeclarationStatement
        // now instead.  (Fix for 4073244.)

        local.prev = locals;
        locals = local;
        local.number = varNumber;
        varNumber += local.getType().stackSize();
        return local.number;
    }

    /**
     * Get a local variable by name
     */
    public
    LocalMember getLocalField(Identifier name) {
        for (LocalMember f = locals ; f != null ; f = f.prev) {
            if (name.equals(f.getName())) {
                return f;
            }
        }
        return null;
    }

    /**
     * Get the scope number for a reference to a member of this class
     * (Larger scope numbers are more deeply nested.)
     * @see LocalMember#scopeNumber
     */
    public
    int getScopeNumber(ClassDefinition c) {
        for (Context ctx = this; ctx != null; ctx = ctx.prev) {
            if (ctx.field == null)  continue;
            if (ctx.field.getClassDefinition() == c) {
                return ctx.frameNumber;
            }
        }
        return -1;
    }

    private
    MemberDefinition getFieldCommon(Environment env, Identifier name,
                                   boolean apparentOnly) throws AmbiguousMember, ClassNotFound {
        // Note:  This is structured as a pair of parallel lookups.
        // If we were to redesign Context, we might prefer to walk
        // along a single chain of scopes.

        LocalMember lf = getLocalField(name);
        int ls = (lf == null) ? -2 : lf.scopeNumber;

        ClassDefinition thisClass = field.getClassDefinition();

        // Also look for a class member in a shallower scope.
        for (ClassDefinition c = thisClass;
             c != null;
             c = c.getOuterClass()) {
            MemberDefinition f = c.getVariable(env, name, thisClass);
            if (f != null && getScopeNumber(c) > ls) {
                if (apparentOnly && f.getClassDefinition() != c) {
                    continue;
                }
                return f;
            }
        }

        return lf;
    }

    /**
     * Assign a number to a class field.
     * (This is used to track definite assignment of some blank finals.)
     */
    public int declareFieldNumber(MemberDefinition field) {
        return declare(null, new LocalMember(field));
    }

    /**
     * Retrieve a number previously assigned by declareMember().
     * Return -1 if there was no such assignment in this context.
     */
    public int getFieldNumber(MemberDefinition field) {
        for (LocalMember f = locals ; f != null ; f = f.prev) {
            if (f.getMember() == field) {
                return f.number;
            }
        }
        return -1;
    }

    /**
     * Return the local field or member field corresponding to a number.
     * Return null if there is no such field.
     */
    public MemberDefinition getElement(int number) {
        for (LocalMember f = locals ; f != null ; f = f.prev) {
            if (f.number == number) {
                MemberDefinition field = f.getMember();
                return (field != null) ? field : f;
            }
        }
        return null;
    }

    /**
     * Get a local class by name
     */
    public
    LocalMember getLocalClass(Identifier name) {
        for (LocalMember f = classes ; f != null ; f = f.prev) {
            if (name.equals(f.getName())) {
                return f;
            }
        }
        return null;
    }

    private
    MemberDefinition getClassCommon(Environment env, Identifier name,
                                   boolean apparentOnly) throws ClassNotFound {
        LocalMember lf = getLocalClass(name);
        int ls = (lf == null) ? -2 : lf.scopeNumber;

        // Also look for a class member in a shallower scope.
        for (ClassDefinition c = field.getClassDefinition();
             c != null;
             c = c.getOuterClass()) {
            // QUERY: We may need to get the inner class from a
            // superclass of 'c'.  This call is prepared to
            // resolve the superclass if necessary.  Can we arrange
            // to assure that it is always previously resolved?
            // This is one of a small number of problematic calls that
            // requires 'getSuperClass' to resolve superclasses on demand.
            // See 'ClassDefinition.getInnerClass(env, nm)'.
            MemberDefinition f = c.getInnerClass(env, name);
            if (f != null && getScopeNumber(c) > ls) {
                if (apparentOnly && f.getClassDefinition() != c) {
                    continue;
                }
                return f;
            }
        }

        return lf;
    }

    /**
     * Get either a local variable, or a field in a current class
     */
    public final
    MemberDefinition getField(Environment env, Identifier name) throws AmbiguousMember, ClassNotFound {
        return getFieldCommon(env, name, false);
    }

    /**
     * Like getField, except that it skips over inherited fields.
     * Used for error checking.
     */
    public final
    MemberDefinition getApparentField(Environment env, Identifier name) throws AmbiguousMember, ClassNotFound {
        return getFieldCommon(env, name, true);
    }

    /**
     * Check if the given field is active in this context.
     */
    public boolean isInScope(LocalMember field) {
        for (LocalMember f = locals ; f != null ; f = f.prev) {
            if (field == f) {
                return true;
            }
        }
        return false;
    }

    /**
     * Notice a reference (usually an uplevel one).
     * Update the references list of every enclosing class
     * which is enclosed by the scope of the target.
     * Update decisions about which uplevels to make into fields.
     * Return the uplevel reference descriptor, or null if it's local.
     * <p>
     * The target must be in scope in this context.
     * So, call this method only from the check phase.
     * (In other phases, the context may be less complete.)
     * <p>
     * This can and should be called both before and after classes are frozen.
     * It should be a no-op, and will raise a compiler error if not.
     */
    public UplevelReference noteReference(Environment env, LocalMember target) {
        int targetScopeNumber = !isInScope(target) ? -1 : target.scopeNumber;

        // Walk outward visiting each scope.
        // Note each distinct frame (i.e., enclosing method).
        // For each frame in which the variable is uplevel,
        // record the event in the references list of the enclosing class.
        UplevelReference res = null;
        int currentFrameNumber = -1;
        for (Context refctx = this; refctx != null; refctx = refctx.prev) {
            if (currentFrameNumber == refctx.frameNumber) {
                continue;       // we're processing frames, not contexts
            }
            currentFrameNumber = refctx.frameNumber;
            if (targetScopeNumber >= currentFrameNumber) {
                break;          // the target is native to this frame
            }

            // process a frame which is using this variable as an uplevel
            ClassDefinition refc = refctx.field.getClassDefinition();
            UplevelReference r = refc.getReference(target);
            r.noteReference(env, refctx);

            // remember the reference pertaining to the innermost frame
            if (res == null) {
                res = r;
            }
        }
        return res;
    }

    /**
     * Implement a reference (usually an uplevel one).
     * Call noteReference() first, to make sure the reference
     * lists are up to date.
     * <p>
     * The resulting expression tree does not need checking;
     * it can be code-generated right away.
     * If the reference is not uplevel, the result is an IDENT or THIS.
     */
    public Expression makeReference(Environment env, LocalMember target) {
        UplevelReference r = noteReference(env, target);

        // Now create a referencing expression.
        if (r != null) {
            return r.makeLocalReference(env, this);
        } else if (idThis.equals(target.getName())) {
            return new ThisExpression(0, target);
        } else {
            return new IdentifierExpression(0, target);
        }
    }

    /**
     * Return a local expression which can serve as the base reference
     * for the given field.  If the field is a constructor, return an
     * expression for the implicit enclosing instance argument.
     * <p>
     * Return null if there is no need for such an argument,
     * or if there was an error.
     */
    public Expression findOuterLink(Environment env, long where,
                                    MemberDefinition f) {
        // reqc is the base pointer type required to use f
        ClassDefinition fc = f.getClassDefinition();
        ClassDefinition reqc = f.isStatic() ? null
                             : !f.isConstructor() ? fc
                             : fc.isTopLevel() ? null
                             : fc.getOuterClass();
        if (reqc == null) {
            return null;
        }
        return findOuterLink(env, where, reqc, f, false);
    }

    private static boolean match(Environment env,
                                 ClassDefinition thisc, ClassDefinition reqc) {
        try {
            return thisc == reqc
                || reqc.implementedBy(env, thisc.getClassDeclaration());
        } catch (ClassNotFound ee) {
            return false;
        }
    }

    public Expression findOuterLink(Environment env, long where,
                                    ClassDefinition reqc,
                                    MemberDefinition f,
                                    boolean needExactMatch) {
        if (field.isStatic()) {
            if (f == null) {
                // say something like: undefined variable A.this
                Identifier nm = reqc.getName().getFlatName().getName();
                env.error(where, "undef.var", Identifier.lookup(nm,idThis));
            } else if (f.isConstructor()) {
                env.error(where, "no.outer.arg", reqc, f.getClassDeclaration());
            } else if (f.isMethod()) {
                env.error(where, "no.static.meth.access",
                          f, f.getClassDeclaration());
            } else {
                env.error(where, "no.static.field.access", f.getName(),
                          f.getClassDeclaration());
            }
            // This is an attempt at error recovery.
            // Unfortunately, the constructor may throw
            // a null pointer exception after failing to resolve
            // 'idThis'.  Since an error message has already been
            // issued previously, this exception is caught and
            // silently ignored.  Ideally, we should avoid throwing
            // the exception.
            Expression e = new ThisExpression(where, this);
            e.type = reqc.getType();
            return e;
        }

        // use lp to scan for current instances (locals named "this")
        LocalMember lp = locals;

        // thise is a link expression being built up
        Expression thise = null;

        // root is the local variable (idThis) at the far left of thise
        LocalMember root = null;

        // thisc is the class of the link expression thise
        ClassDefinition thisc = null;

        // conCls is the class of the "this", in a constructor
        ClassDefinition conCls = null;
        if (field.isConstructor()) {
            conCls = field.getClassDefinition();
        }

        if (!field.isMethod()) {
            thisc = field.getClassDefinition();
            thise = new ThisExpression(where, this);
        }

        while (true) {
            if (thise == null) {
                // start fresh from lp
                while (lp != null && !idThis.equals(lp.getName())) {
                    lp = lp.prev;
                }
                if (lp == null) {
                    break;
                }
                thise = new ThisExpression(where, lp);
                thisc = lp.getClassDefinition();
                root = lp;
                lp = lp.prev;
            }

            // Require exact class identity when called with
            // 'needExactMatch' true.  This is done when checking
            // the '<class>.this' syntax.  Fixes 4102393 and 4133457.
            if (thisc == reqc ||
                (!needExactMatch && match(env, thisc, reqc))) {
                break;
            }

            // move out one step, if the current instance has an outer link

            MemberDefinition outerMember = thisc.findOuterMember();
            if (outerMember == null) {
                thise = null;
                continue;       // try to find more help in lp
            }
            ClassDefinition prevc = thisc;
            thisc = prevc.getOuterClass();

            if (prevc == conCls) {
                // Must pick up "this$C" from the constructor argument,
                // not from "this.this$C", since the latter may not be
                // initialized properly.  (This way is cheaper too.)
                Identifier nm = outerMember.getName();
                IdentifierExpression arg = new IdentifierExpression(where, nm);
                arg.bind(env, this);
                thise = arg;
            } else {
                thise = new FieldExpression(where, thise, outerMember);
            }
        }
        if (thise != null) {
            // mark crossed scopes
            // ?????
            //ensureAvailable(root);
            return thise;
        }

        if (f == null) {
            // say something like: undefined variable A.this
            Identifier nm = reqc.getName().getFlatName().getName();
            env.error(where, "undef.var", Identifier.lookup(nm,idThis));
        } else if (f.isConstructor()) {
            env.error(where, "no.outer.arg", reqc, f.getClassDefinition());
        } else {
            env.error(where, "no.static.field.access", f, field);
        }

        // avoid floodgating:
        Expression e = new ThisExpression(where, this);
        e.type = reqc.getType();
        return e;
    }

    /**
     * Is there a "this" of type reqc in scope?
     */
    public static boolean outerLinkExists(Environment env,
                                          ClassDefinition reqc,
                                          ClassDefinition thisc) {
        while (!match(env, thisc, reqc)) {
            if (thisc.isTopLevel()) {
                return false;
            }
            thisc = thisc.getOuterClass();
        }
        return true;
    }

    /**
     * From which enclosing class do members of this type come?
     */
    public ClassDefinition findScope(Environment env, ClassDefinition reqc) {
        ClassDefinition thisc = field.getClassDefinition();
        while (thisc != null && !match(env, thisc, reqc)) {
            thisc = thisc.getOuterClass();
        }
        return thisc;
    }

    /**
     * Resolve a type name from within a local scope.
     * @see Environment#resolveName
     */
    Identifier resolveName(Environment env, Identifier name) {
        // This logic is pretty much exactly parallel to that of
        // Environment.resolveName().
        if (name.isQualified()) {
            // Try to resolve the first identifier component,
            // because inner class names take precedence over
            // package prefixes.  (Cf. Environment.resolveName.)
            Identifier rhead = resolveName(env, name.getHead());

            if (rhead.hasAmbigPrefix()) {
                // The first identifier component refers to an
                // ambiguous class.  Limp on.  We throw away the
                // rest of the classname as it is irrelevant.
                // (part of solution for 4059855).
                return rhead;
            }

            if (!env.classExists(rhead)) {
                return env.resolvePackageQualifiedName(name);
            }
            try {
                return env.getClassDefinition(rhead).
                    resolveInnerClass(env, name.getTail());
            } catch (ClassNotFound ee) {
                // return partially-resolved name someone else can fail on
                return Identifier.lookupInner(rhead, name.getTail());
            }
        }

        // Look for an unqualified name in enclosing scopes.
        try {
            MemberDefinition f = getClassCommon(env, name, false);
            if (f != null) {
                return f.getInnerClass().getName();
            }
        } catch (ClassNotFound ee) {
            // a missing superclass, or something catastrophic
        }

        // look in imports, etc.
        return env.resolveName(name);
    }

    /**
     * Return the name of a lexically apparent type,
     * skipping inherited members, and ignoring
     * the current pacakge and imports.
     * This is used for error checking.
     */
    public
    Identifier getApparentClassName(Environment env, Identifier name) {
        if (name.isQualified()) {
            // Try to resolve the first identifier component,
            // because inner class names take precedence over
            // package prefixes.  (Cf. Environment.resolveName.)
            Identifier rhead = getApparentClassName(env, name.getHead());
            return (rhead == null) ? idNull
                : Identifier.lookup(rhead,
                                    name.getTail());
        }

        // Look for an unqualified name in enclosing scopes.
        try {
            MemberDefinition f = getClassCommon(env, name, true);
            if (f != null) {
                return f.getInnerClass().getName();
            }
        } catch (ClassNotFound ee) {
            // a missing superclass, or something catastrophic
        }

        // the enclosing class name is the only apparent package member:
        Identifier topnm = field.getClassDefinition().getTopClass().getName();
        if (topnm.getName().equals(name)) {
            return topnm;
        }
        return idNull;
    }

    /**
     * Raise an error if a blank final was definitely unassigned
     * on entry to a loop, but has possibly been assigned on the
     * back-branch.  If this is the case, the loop may be assigning
     * it multiple times.
     */
    public void checkBackBranch(Environment env, Statement loop,
                                Vset vsEntry, Vset vsBack) {
        for (LocalMember f = locals ; f != null ; f = f.prev) {
            if (f.isBlankFinal()
                && vsEntry.testVarUnassigned(f.number)
                && !vsBack.testVarUnassigned(f.number)) {
                env.error(loop.where, "assign.to.blank.final.in.loop",
                          f.getName());
            }
        }
    }

    /**
     * Check if a field can reach another field (only considers
     * forward references, not the access modifiers).
     */
    public boolean canReach(Environment env, MemberDefinition f) {
        return field.canReach(env, f);
    }

    /**
     * Get the context that corresponds to a label, return null if
     * not found.
     */
    public
    Context getLabelContext(Identifier lbl) {
        for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
            if ((ctx.node != null) && (ctx.node instanceof Statement)) {
                if (((Statement)(ctx.node)).hasLabel(lbl))
                    return ctx;
            }
        }
        return null;
    }

    /**
     * Get the destination context of a break
     */
    public
    Context getBreakContext(Identifier lbl) {
        if (lbl != null) {
            return getLabelContext(lbl);
        }
        for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
            if (ctx.node != null) {
                switch (ctx.node.op) {
                  case SWITCH:
                  case FOR:
                  case DO:
                  case WHILE:
                    return ctx;
                }
            }
        }
        return null;
    }

    /**
     * Get the destination context of a continue
     */
    public
    Context getContinueContext(Identifier lbl) {
        if (lbl != null) {
            return getLabelContext(lbl);
        }
        for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
            if (ctx.node != null) {
                switch (ctx.node.op) {
                  case FOR:
                  case DO:
                  case WHILE:
                    return ctx;
                }
            }
        }
        return null;
    }

    /**
     * Get the destination context of a return (the method body)
     */
    public
    CheckContext getReturnContext() {
        for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
            // The METHOD node is set up by Statement.checkMethod().
            if (ctx.node != null && ctx.node.op == METHOD) {
                return (CheckContext)ctx;
            }
        }
        return null;
    }

    /**
     * Get the context of the innermost surrounding try-block.
     * Consider only try-blocks contained within the same method.
     * (There could be others when searching from within a method
     * of a local class, but they are irrelevant to our purpose.)
     * This is used for recording DA/DU information preceding
     * all abnormal transfers of control: break, continue, return,
     * and throw.
     */
    public
    CheckContext getTryExitContext() {
        for (Context ctx = this;
             ctx != null && ctx.node != null && ctx.node.op != METHOD;
             ctx = ctx.prev) {
            if (ctx.node.op == TRY) {
                return (CheckContext)ctx;
            }
        }
        return null;
    }

    /**
     * Get the nearest inlined context
     */
    Context getInlineContext() {
        for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
            if (ctx.node != null) {
                switch (ctx.node.op) {
                  case INLINEMETHOD:
                  case INLINENEWINSTANCE:
                    return ctx;
                }
            }
        }
        return null;
    }

    /**
     * Get the context of a field that is being inlined
     */
    Context getInlineMemberContext(MemberDefinition field) {
        for (Context ctx = this ; ctx != null ; ctx = ctx.prev) {
            if (ctx.node != null) {
                switch (ctx.node.op) {
                  case INLINEMETHOD:
                    if (((InlineMethodExpression)ctx.node).field.equals(field)) {
                        return ctx;
                    }
                    break;
                  case INLINENEWINSTANCE:
                    if (((InlineNewInstanceExpression)ctx.node).field.equals(field)) {
                        return ctx;
                    }
                }
            }
        }
        return null;
    }

    /**
     * Remove variables from the vset set  that are no longer part of
     * this context.
     */
    public final Vset removeAdditionalVars(Vset vset) {
        return vset.removeAdditionalVars(varNumber);
    }

    public final int getVarNumber() {
        return varNumber;
    }

    /**
     * Return the number of the innermost current instance reference.
     */
    public int getThisNumber() {
        LocalMember thisf = getLocalField(idThis);
        if (thisf != null
            && thisf.getClassDefinition() == field.getClassDefinition()) {
            return thisf.number;
        }
        // this is a variable; there is no "this" (should not happen)
        return varNumber;
    }

    /**
     * Return the field containing the present context.
     */
    public final MemberDefinition getField() {
        return field;
    }

    /**
     * Extend an environment with the given context.
     * The resulting environment behaves the same as
     * the given one, except that resolveName() takes
     * into account local class names in this context.
     */
    public static Environment newEnvironment(Environment env, Context ctx) {
        return new ContextEnvironment(env, ctx);
    }
}

final
class ContextEnvironment extends Environment {
    Context ctx;
    Environment innerEnv;

    ContextEnvironment(Environment env, Context ctx) {
        super(env, env.getSource());
        this.ctx = ctx;
        this.innerEnv = env;
    }

    public Identifier resolveName(Identifier name) {
        return ctx.resolveName(innerEnv, name);
    }
}

sun/tools/tree/Context.java

 

JDK 11 jdk.scripting.nashorn.jmod - Scripting Nashorn Module

JDK 11 jdk.pack.jmod - Pack Module

Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)

2020-04-25, 8134👍, 0💬