pretty.java

GJC（Generic Java Compiler）编译器

        println();
        printStats(tree.cases);
        align();
        print("}");
    }

    public void visitCase(Case tree) {
        if (tree.pat == null) {
            print("default");
        } else {
            print("case ");
            printExpr(tree.pat);
        }
        print(": ");
        println();
        indent();
        printStats(tree.stats);
        undent();
        align();
    }

    public void visitSynchronized(Synchronized tree) {
        print("synchronized ");
        if (tree.lock.tag == Tree.PARENS) {
            printExpr(tree.lock);
        } else {
            print("(");
            printExpr(tree.lock);
            print(")");
        }
        print(" ");
        printStat(tree.body);
    }

    public void visitTry(Try tree) {
        print("try ");
        printStat(tree.body);
        for (List l = tree.catchers; l.nonEmpty(); l = l.tail) {
            printStat((Tree) l.head);
        }
        if (tree.finalizer != null) {
            print(" finally ");
            printStat(tree.finalizer);
        }
    }

    public void visitCatch(Catch tree) {
        print(" catch (");
        printExpr(tree.param);
        print(") ");
        printStat(tree.body);
    }

    public void visitConditional(Conditional tree) {
        open(prec, TreeInfo.condPrec);
        printExpr(tree.cond, TreeInfo.condPrec);
        print(" ? ");
        printExpr(tree.truepart, TreeInfo.condPrec);
        print(" : ");
        printExpr(tree.falsepart, TreeInfo.condPrec);
        close(prec, TreeInfo.condPrec);
    }

    public void visitIf(If tree) {
        print("if ");
        if (tree.cond.tag == Tree.PARENS) {
            printExpr(tree.cond);
        } else {
            print("(");
            printExpr(tree.cond);
            print(")");
        }
        print(" ");
        printStat(tree.thenpart);
        if (tree.elsepart != null) {
            print(" else ");
            printStat(tree.elsepart);
        }
    }

    public void visitExec(Exec tree) {
        printExpr(tree.expr);
        if (prec == TreeInfo.notExpression)
            print(";");
    }

    public void visitBreak(Break tree) {
        print("break");
        if (tree.label != null)
            print(" " + tree.label);
        print(";");
    }

    public void visitContinue(Continue tree) {
        print("continue");
        if (tree.label != null)
            print(" " + tree.label);
        print(";");
    }

    public void visitReturn(Return tree) {
        print("return");
        if (tree.expr != null) {
            print(" ");
            printExpr(tree.expr);
        }
        print(";");
    }

    public void visitThrow(Throw tree) {
        print("throw ");
        printExpr(tree.expr);
        print(";");
    }

    public void visitAssert(Assert tree) {
        print("assert ");
        printExpr(tree.cond);
        if (tree.detail != null) {
            print(" : ");
            printExpr(tree.detail);
        }
        print(";");
    }

    public void visitApply(Apply tree) {
        printExpr(tree.meth);
        print("(");
        printExprs(tree.args);
        print(")");
    }

    public void visitNewClass(NewClass tree) {
        if (tree.encl != null) {
            printExpr(tree.encl);
            print(".");
        }
        print("new ");
        printExpr(tree.clazz);
        print("(");
        printExprs(tree.args);
        print(")");
        if (tree.def != null) {
            Name enclClassNamePrev = enclClassName;
            enclClassName = null;
            printBlock(((ClassDef) tree.def).defs);
            enclClassName = enclClassNamePrev;
        }
    }

    public void visitNewArray(NewArray tree) {
        if (tree.elemtype != null) {
            print("new ");
            int n = 0;
            Tree elemtype = tree.elemtype;
            while (elemtype.tag == Tree.TYPEARRAY) {
                n++;
                elemtype = ((TypeArray) elemtype).elemtype;
            }
            printExpr(elemtype);
            for (List l = tree.dims; l.nonEmpty(); l = l.tail) {
                print("[");
                printExpr((Tree) l.head);
                print("]");
            }
            for (int i = 0; i < n; i++) {
                print("[]");
            }
            if (tree.elems != null) {
                print("[]");
            }
        }
        if (tree.elems != null) {
            print("{");
            printExprs(tree.elems);
            print("}");
        }
    }

    public void visitParens(Parens tree) {
        print("(");
        printExpr(tree.expr);
        print(")");
    }

    public void visitAssign(Assign tree) {
        open(prec, TreeInfo.assignPrec);
        printExpr(tree.lhs, TreeInfo.assignPrec + 1);
        print(" = ");
        printExpr(tree.rhs, TreeInfo.assignPrec);
        close(prec, TreeInfo.assignPrec);
    }

    public String operatorName(int tag) {
        switch (tag) {
        case Tree.POS:
            return "+";

        case Tree.NEG:
            return "-";

        case Tree.NOT:
            return "!";

        case Tree.COMPL:
            return "~";

        case Tree.PREINC:
            return "++";

        case Tree.PREDEC:
            return "--";

        case Tree.POSTINC:
            return "++";

        case Tree.POSTDEC:
            return "--";

        case Tree.NULLCHK:
            return "<*nullchk*>";

        case Tree.OR:
            return "||";

        case Tree.AND:
            return "&&";

        case Tree.EQ:
            return "==";

        case Tree.NE:
            return "!=";

        case Tree.LT:
            return "<";

        case Tree.GT:
            return ">";

        case Tree.LE:
            return "<=";

        case Tree.GE:
            return ">=";

        case Tree.BITOR:
            return "|";

        case Tree.BITXOR:
            return "^";

        case Tree.BITAND:
            return "&";

        case Tree.SL:
            return "<<";

        case Tree.SR:
            return ">>";

        case Tree.USR:
            return ">>>";

        case Tree.PLUS:
            return "+";

        case Tree.MINUS:
            return "-";

        case Tree.MUL:
            return "*";

        case Tree.DIV:
            return "/";

        case Tree.MOD:
            return "%";

        default:
            throw new Error();

        }
    }

    public void visitAssignop(Assignop tree) {
        open(prec, TreeInfo.assignopPrec);
        printExpr(tree.lhs, TreeInfo.assignopPrec + 1);
        print(" " + operatorName(tree.tag - Tree.ASGOffset) + "= ");
        printExpr(tree.rhs, TreeInfo.assignopPrec);
        close(prec, TreeInfo.assignopPrec);
    }

    public void visitUnary(Unary tree) {
        int ownprec = TreeInfo.opPrec(tree.tag);
        String opname = operatorName(tree.tag).toString();
        open(prec, ownprec);
        if (tree.tag <= Tree.PREDEC) {
            print(opname);
            printExpr(tree.arg, ownprec);
        } else {
            printExpr(tree.arg, ownprec);
            print(opname);
        }
        close(prec, ownprec);
    }

    public void visitBinary(Binary tree) {
        int ownprec = TreeInfo.opPrec(tree.tag);
        String opname = operatorName(tree.tag).toString();
        open(prec, ownprec);
        printExpr(tree.lhs, ownprec);
        print(" " + opname + " ");
        printExpr(tree.rhs, ownprec + 1);
        close(prec, ownprec);
    }

    public void visitTypeCast(TypeCast tree) {
        open(prec, TreeInfo.prefixPrec);
        print("(");
        printExpr(tree.clazz);
        print(")");
        printExpr(tree.expr, TreeInfo.prefixPrec);
        close(prec, TreeInfo.prefixPrec);
    }

    public void visitTypeTest(TypeTest tree) {
        open(prec, TreeInfo.ordPrec);
        printExpr(tree.expr, TreeInfo.ordPrec);
        print(" instanceof ");
        printExpr(tree.clazz, TreeInfo.ordPrec + 1);
        close(prec, TreeInfo.ordPrec);
    }

    public void visitIndexed(Indexed tree) {
        printExpr(tree.indexed, TreeInfo.postfixPrec);
        print("[");
        printExpr(tree.index);
        print("]");
    }

    public void visitSelect(Select tree) {
        printExpr(tree.selected, TreeInfo.postfixPrec);
        print("." + tree.name);
    }

    public void visitIdent(Ident tree) {
        print(tree.name.toString());
    }

    public void visitLiteral(Literal tree) {
        switch (tree.typetag) {
        case Type.INT:
            print(tree.value.toString());
            break;

        case Type.LONG:
            print(tree.value.toString() + "L");
            break;

        case Type.FLOAT:
            print(tree.value.toString() + "F");
            break;

        case Type.DOUBLE:
            print(tree.value.toString());
            break;

        case Type.CHAR:
            print("\'" + Convert.quote(
                    String.valueOf((char)((Number) tree.value).intValue())) + "\'");
            break;

        case Type.CLASS:
            print("\"" + Convert.quote((String) tree.value) + "\"");
            break;

        default:
            print(tree.value.toString());

        }
    }

    public void visitTypeIdent(TypeIdent tree) {
        switch (tree.typetag) {
        case TypeTags.BYTE:
            print("byte");
            break;

        case TypeTags.CHAR:
            print("char");
            break;

        case TypeTags.SHORT:
            print("short");
            break;

        case TypeTags.INT:
            print("int");
            break;

        case TypeTags.LONG:
            print("long");
            break;

        case TypeTags.FLOAT:
            print("float");
            break;

        case TypeTags.DOUBLE:
            print("double");
            break;

        case TypeTags.BOOLEAN:
            print("boolean");
            break;

        case TypeTags.VOID:
            print("void");
            break;

        default:
            print("error");
            break;

        }
    }

    public void visitTypeArray(TypeArray tree) {
        printExpr(tree.elemtype);
        print("[]");
    }

    public void visitErroneous(Erroneous tree) {
        print("(ERROR)");
    }

    public void visitTree(Tree tree) {
        print("(UNKNOWN: " + tree + ")");
        println();
    }
}