transinner.java

java编译器gjc源码 java编译环境

                    rs.resolveInternalMethod(make.pos, attrEnv, syms.classType,
                    names.forName,
                    Type.emptyList.prepend(syms.classLoaderType).prepend(
                    syms.booleanType).prepend(syms.stringType));
            Tree clvalue = make.Conditional( makeBinary(Tree.EQ, make.Ident(clsym),
                    make.Ident(syms.nullConst)),
                    make.Assign(make.Ident(clsym),
                    makeCall(
                    makeCall(makeCall(newcache, names.getClass, Tree.emptyList),
                    names.getComponentType, Tree.emptyList),
                    names.getClassLoader, Tree.emptyList)).setType(
                    syms.classLoaderType),
                    make.Ident(clsym)).setType(syms.classLoaderType);
            List args = Tree.emptyList.prepend(clvalue).prepend(
                    make.Ident(syms.falseConst)).prepend(
                    make.Ident(((Tree.VarDef) md.params.head).sym));
            returnResult = make.Block(0,
                    Tree.emptyList.prepend(
                    make.Call(make.App(make.Ident(forNameSym), args))));
        } else {
            Symbol forNameSym =
                    rs.resolveInternalMethod(make.pos, attrEnv, syms.classType,
                    names.forName, Type.emptyList.prepend(syms.stringType));
            returnResult = make.Block(0,
                    Tree.emptyList.prepend( make.Call(
                    make.App(make.QualIdent(forNameSym),
                    List.make(make.Ident(((Tree.VarDef) md.params.head).sym))))));
        }
        VarSymbol catchParam = new VarSymbol(0, make.paramName(1),
                syms.classNotFoundExceptionType, classDollarSym);
        Tree rethrow;
        if (target.ordinal >= Target.JDK1_4.ordinal) {
            Tree throwExpr = makeCall(
                    makeNewClass(syms.noClassDefFoundErrorType, Tree.emptyList),
                    names.initCause, Tree.emptyList.prepend(make.Ident(catchParam)));
            rethrow = make.Throw(throwExpr);
        } else {
            Symbol getMessageSym = rs.resolveInternalMethod(make.pos, attrEnv,
                    syms.classNotFoundExceptionType, names.getMessage,
                    Type.emptyList);
            rethrow = make.Throw( makeNewClass(syms.noClassDefFoundErrorType,
                    List.make(
                    make.App(make.Select(make.Ident(catchParam), getMessageSym),
                    Tree.emptyList))));
        }
        Tree rethrowStmt = make.Block(0, Tree.emptyList.prepend(rethrow));
        Catch catchBlock = make.Catch(make.VarDef(catchParam, null), rethrowStmt);
        Tree tryCatch =
                make.Try(returnResult, Catch.emptyList.prepend(catchBlock), null);
        return make.Block(0, Tree.emptyList.prepend(tryCatch));
    }

    /**
      * Create an attributed tree of the form left.name().
      */
    private Tree makeCall(Tree left, Name name, List args) {
        assert left.type != null;
        List types = Type.emptyList;
        Symbol funcsym = rs.resolveInternalMethod(make.pos, attrEnv, left.type, name,
                TreeInfo.types(args));
        return make.App(make.Select(left, funcsym), args);
    }

    /**
      * The Name Of The variable to cache T.class values.
      *  @param sig      The signature of type T.
      */
    private Name cacheName(String sig) {
        StringBuffer buf = new StringBuffer();
        if (sig.startsWith("[")) {
            buf = buf.append("array");
            while (sig.startsWith("[")) {
                buf = buf.append("$");
                sig = sig.substring(1);
            }
            if (sig.startsWith("L")) {
                sig = sig.substring(0, sig.length() - 1);
            }
        } else {
            buf = buf.append("class$");
        }
        buf = buf.append(sig.replace('.', '$'));
        return names.fromString(buf.toString());
    }

    /**
      * The variable symbol that caches T.class values.
      *  If none exists yet, create a definition.
      *  @param sig      The signature of type T.
      *  @param pos	The position to report diagnostics, if any.
      */
    private VarSymbol cacheSym(int pos, String sig) {
        ClassSymbol outerCacheClass = outerCacheClass();
        Name cname = cacheName(sig);
        VarSymbol cacheSym =
                (VarSymbol) lookupSynthetic(cname, outerCacheClass.members());
        if (cacheSym == null) {
            cacheSym = new VarSymbol(STATIC | SYNTHETIC, cname, syms.classType,
                    outerCacheClass);
            enterSynthetic(pos, cacheSym, outerCacheClass.members());
            VarDef cacheDef = make.VarDef(cacheSym, null);
            ClassDef outerCacheClassDef = classDef(outerCacheClass);
            outerCacheClassDef.defs = outerCacheClassDef.defs.prepend(cacheDef);
        }
        return cacheSym;
    }

    /**
      * The tree simulating a T.class expression.
      *  @param clazz      The tree identifying type T.
      */
    private Tree classOf(Tree clazz) {
        return classOfType(clazz.type, clazz.pos);
    }

    private Tree classOfType(Type type, int pos) {
        switch (type.tag) {
        case BYTE:

        case SHORT:

        case CHAR:

        case INT:

        case LONG:

        case FLOAT:

        case DOUBLE:

        case BOOLEAN:

        case VOID:
            Name bname = syms.boxedName[type.tag];
            ClassSymbol c = reader.enterClass(bname);
            Symbol typeSym = rs.access(
                    rs.findIdentInType(attrEnv, c.type, names.TYPE, VAR), pos,
                    c.type, names.TYPE, true);
            if (typeSym.kind == VAR)
                attr.evalInit((VarSymbol) typeSym);
            return make.QualIdent(typeSym);

        case CLASS:

        case ARRAY:
            String sig = writer.xClassName(type).toString().replace('/', '.');
            Symbol cs = cacheSym(pos, sig);
            return make.at(pos).Conditional( makeBinary(Tree.EQ, make.Ident(cs),
                    make.Ident(syms.nullConst)),
                    make.Assign(make.Ident(cs),
                    make.App(make.Ident(classDollarSym(pos)),
                    List.make(
                    make.Literal(Type.CLASS, sig).setType(syms.stringType)))).
                    setType(syms.classType), make.Ident(cs)).setType(syms.classType);

        default:
            throw new AssertionError();

        }
    }

    /**
      * Code for enabling/disabling assertions.
      */
    private Tree assertFlagTest(int pos) {
        ClassSymbol outermostClass = outermostClassDef.sym;
        ClassSymbol container = currentClass;
        VarSymbol assertDisabledSym =
                (VarSymbol) lookupSynthetic(names.dollarAssertionsDisabled,
                container.members());
        if (assertDisabledSym == null) {
            assertDisabledSym = new VarSymbol(STATIC | FINAL | SYNTHETIC,
                    names.dollarAssertionsDisabled, syms.booleanType, container);
            enterSynthetic(pos, assertDisabledSym, container.members());
            Symbol desiredAssertionStatusSym =
                    rs.resolveInternalMethod(pos, attrEnv, syms.classType,
                    names.desiredAssertionStatus, Type.emptyList);
            ClassDef containerDef = classDef(container);
            make.at(containerDef.pos);
            Tree notStatus = makeUnary(Tree.NOT,
                    make.App( make.Select(
                    classOfType(outermostClass.type, containerDef.pos),
                    desiredAssertionStatusSym), Tree.emptyList));
            VarDef assertDisabledDef = make.VarDef(assertDisabledSym, notStatus);
            containerDef.defs = containerDef.defs.prepend(assertDisabledDef);
        }
        make.at(pos);
        return makeUnary(Tree.NOT, make.Ident(assertDisabledSym));
    }

    /**
      * Visitor argument: enclosing operator node.
      */
    private Tree enclOp;

    /**
     * Visitor method: Translate a single node.
     *  Attach the source position from the old tree to its replacement tree.
     */
    public Tree translate(Tree tree) {
        if (tree == null) {
            return null;
        } else {
            make.at(tree.pos);
            tree.accept(this);
            if (endPositions != null && result != tree) {
                Integer endPos = (Integer) endPositions.remove(tree);
                if (endPos != null)
                    endPositions.put(result, endPos);
            }
            return result;
        }
    }

    /**
      * Visitor method: Translate tree.
      */
    public Tree translate(Tree tree, Tree enclOp) {
        Tree prevEnclOp = this.enclOp;
        this.enclOp = enclOp;
        Tree res = translate(tree);
        this.enclOp = prevEnclOp;
        return res;
    }

    /**
      * Visitor method: Translate list of trees.
      */
    public List translate(List trees, Tree enclOp) {
        Tree prevEnclOp = this.enclOp;
        this.enclOp = enclOp;
        List res = translate(trees);
        this.enclOp = prevEnclOp;
        return res;
    }

    public void visitClassDef(ClassDef tree) {
        ClassSymbol currentClassPrev = currentClass;
        currentClass = tree.sym;
        classdefs.put(currentClass, tree);
        proxies = proxies.dup();
        List prevOuterThisStack = outerThisStack;
        VarDef otdef = null;
        if (currentClass.hasOuterInstance())
            otdef = outerThisDef(tree.pos, currentClass);
        List fvdefs = freevarDefs(tree.pos, freevars(currentClass), currentClass);
        tree.extending = translate(tree.extending);
        tree.implementing = translate(tree.implementing);
        List seen = Tree.emptyList;
        while (tree.defs != seen) {
            List unseen = tree.defs;
            for (List l = unseen; l.nonEmpty() && l != seen; l = l.tail) {
                Tree outermostMemberDefPrev = outermostMemberDef;
                if (outermostMemberDefPrev == null)
                    outermostMemberDef = (Tree) l.head;
                l.head = translate((Tree) l.head);
                outermostMemberDef = outermostMemberDefPrev;
            }
            seen = unseen;
        }
        if ((tree.flags & PROTECTED) != 0)
            tree.flags |= PUBLIC;
        tree.flags &= ClassFlags;
        tree.name = Convert.shortName(currentClass.flatName());
        for (List l = fvdefs; l.nonEmpty(); l = l.tail) {
            tree.defs = tree.defs.prepend(l.head);
            enterSynthetic(tree.pos, ((Tree.VarDef) l.head).sym,
                    currentClass.members());
        }
        if (currentClass.hasOuterInstance()) {
            tree.defs = tree.defs.prepend(otdef);
            enterSynthetic(tree.pos, otdef.sym, currentClass.members());
        }
        proxies = proxies.leave();
        outerThisStack = prevOuterThisStack;
        translated.append(tree);
        currentClass = currentClassPrev;
        result = make.at(tree.pos).Block(0, Tree.emptyList);
    }

    public void visitMethodDef(MethodDef tree) {
        if (tree.name == names.init && (currentClass.isInner() ||
                (currentClass.owner.kind & (VAR | MTH)) != 0)) {
            MethodSymbol m = tree.sym;
            proxies = proxies.dup();
            List prevOuterThisStack = outerThisStack;
            List fvs = freevars(currentClass);
            VarDef otdef = null;
            if (currentClass.hasOuterInstance())
                otdef = outerThisDef(tree.pos, m);
            List fvdefs = freevarDefs(tree.pos, fvs, m);
            tree.restype = translate(tree.restype);
            tree.params = translateVarDefs(tree.params);
            tree.thrown = translate(tree.thrown);
            tree.params = tree.params.appendList(fvdefs);
            if (currentClass.hasOuterInstance())
                tree.params = tree.params.prepend(otdef);
            Tree selfCall = translate((Tree) tree.body.stats.head);
            List added = Tree.emptyList;
            if (fvs.nonEmpty()) {
                List addedargtypes = new List();
                for (List l = fvs; l.nonEmpty(); l = l.tail) {
                    if (TreeInfo.isInitialConstructor(tree))
                        added = added.prepend( initField(tree.body.pos,
                                proxyName(((Symbol.VarSymbol) l.head).name)));
                    addedargtypes = addedargtypes.prepend(
                            ((Symbol.VarSymbol) l.head).erasure());
                }
                Type olderasure = m.erasure();
                m.erasure_field = new MethodType(
                        olderasure.argtypes().appendList(addedargtypes),
                        olderasure.restype(), olderasure.thrown(), syms.methodClass);
            }
            if (currentClass.hasOuterInstance() &&
                    TreeInfo.isInitialConstructor(tree)) {
                added = added.prepend(initOuterThis(tree.body.pos));
            }
            proxies = proxies.leave();
            List stats = translate(tree.body.stats.tail);
            if (target.initializeFieldsBeforeSuper())
                tree.body.stats = stats.prepend(selfCall).prependList(added);
            else
                tree.body.stats = stats.prependList(added).prepend(selfCall);
            outerThisStack = prevOuterThisStack;
        } else {
            super.visitMethodDef(tree);
        }
        result = tree;
    }

    public void visitNewClass(NewClass tree) {
        ClassSymbol c = (ClassSymbol) tree.constructor.owner;
        tree.args = translate(tree.args);
        if ((c.owner.kind & (VAR | MTH)) != 0) {
            tree.args = tree.args.appendList(loadFreevars(tree.pos, freevars(c)));
        }
        Symbol constructor = accessConstructor(tree.pos, tree.constructor);
        if (constructor != tree.constructor) {
            tree.args = tree.args.append(make.Ident(syms.nullConst));
            tree.constructor = constructor;
        }
        if (c.hasOuterInstance()) {
            Tree thisArg;
            if (tree.encl != nul