/** * @(#)Pretty.java	1.33 03/01/23 * * Copyright 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */package com.sun.tools.javac.v8.tree;import java.io.*;import com.sun.tools.javac.v8.util.*;import com.sun.tools.javac.v8.code.*;import com.sun.tools.javac.v8.code.Symbol.*;import com.sun.tools.javac.v8.tree.Tree.*;/** * Prints out a tree as an indented Java source program. */public class Pretty extends Tree.Visitor implements Flags {    public Pretty(PrintWriter out, boolean sourceOutput) {        super();        this.out = out;        this.sourceOutput = sourceOutput;    }    /**      * Set when we are producing source output.  If we're not      *  producing source output, we can sometimes give more detail in      *  the output even though that detail would not be valid java      *  soruce.      */    private final boolean sourceOutput;    /**     * The output stream on which trees are printed.     */    PrintWriter out;    /**     * Indentation width (can be reassigned from outside).     */    public int width = 4;    /**     * The current left margin.     */    int lmargin = 0;    /**     * The enclosing class name.     */    Name enclClassName;    /**     * A hashtable mapping trees to their documentation comments     *  (can be null)     */    Hashtable docComments = null;    /**     * Align code to be indented to left margin.     */    void align() {        for (int i = 0; i < lmargin; i++)            out.print(" ");    }    /**      * Increase left margin by indentation width.      */    void indent() {        lmargin = lmargin + width;    }    /**      * Decrease left margin by indentation width.      */    void undent() {        lmargin = lmargin - width;    }    /**      * Enter a new precedence level. Emit a `(' if new precedence level      *  is less than precedence level so far.      *  @param contextPrec    The precedence level in force so far.      *  @param ownPrec        The new precedence level.      */    void open(int contextPrec, int ownPrec) {        if (ownPrec < contextPrec)            out.print("(");    }    /**      * Leave precedence level. Emit a `(' if inner precedence level      *  is less than precedence level we revert to.      *  @param contextPrec    The precedence level we revert to.      *  @param ownPrec        The inner precedence level.      */    void close(int contextPrec, int ownPrec) {        if (ownPrec < contextPrec)            out.print(")");    }    /**      * Print string, replacing all non-ascii character with unicode escapes.      */    public void print(String s) {        out.print(Convert.escapeUnicode(s));    }    /**      * Print new line.      */    public void println() {        out.println();    }    /**      * Visitor argument: the current precedence level.      */    int prec;    /**     * Visitor method: print expression tree.     *  @param prec  The current precedence level.     */    public void printExpr(Tree tree, int prec) {        int prevPrec = this.prec;        try {            this.prec = prec;            if (tree == null)                print("/*missing*/");            else                tree.accept(this);        }        finally { this.prec = prevPrec;                } }    /**      * Derived visitor method: print expression tree at minimum precedence level      *  for expression.      */    public void printExpr(Tree tree) {        printExpr(tree, TreeInfo.noPrec);    }    /**      * Derived visitor method: print statement tree.      */    public void printStat(Tree tree) {        printExpr(tree, TreeInfo.notExpression);    }    /**      * Derived visitor method: print list of expression trees, separated by given string.      *  @param sep the separator string      */    public void printExprs(List trees, String sep) {        if (trees.nonEmpty()) {            printExpr((Tree) trees.head);            for (List l = trees.tail; l.nonEmpty(); l = l.tail) {                print(sep);                printExpr((Tree) l.head);            }        }    }    /**      * Derived visitor method: print list of expression trees, separated by commas.      */    public void printExprs(List trees) {        printExprs(trees, ", ");    }    /**      * Derived visitor method: print list of statements, each on a separate line.      */    public void printStats(List trees) {        for (List l = trees; l.nonEmpty(); l = l.tail) {            align();            printStat((Tree) l.head);            println();        }    }    /**      * Print a set of modifiers.      */    public void printFlags(long flags) {        if ((flags & SYNTHETIC) != 0)            print("/*synthetic*/ ");        print(TreeInfo.flagNames(flags));        if ((flags & StandardFlags) != 0)            print(" ");    }    /**      * Print documentation comment, if it exists      *  @param tree    The tree for which a documentation comment should be printed.      */    public void printDocComment(Tree tree) {        if (docComments != null) {            String dc = (String) docComments.get(tree);            if (dc != null) {                print("/**");                println();                int pos = 0;                int endpos = lineEndPos(dc, pos);                while (pos < dc.length()) {                    align();                    print(" *");                    if (pos < dc.length() && dc.charAt(pos) > ' ')                        print(" ");                    print(dc.substring(pos, endpos));                    println();                    pos = endpos + 1;                    endpos = lineEndPos(dc, pos);                }                align();                print(" */");                println();                align();            }        }    }    static int lineEndPos(String s, int start) {        int pos = s.indexOf('\n', start);        if (pos < 0)            pos = s.length();        return pos;    }    /**      * Print a block.      */    public void printBlock(List stats) {        print("{");        println();        indent();        printStats(stats);        undent();        align();        print("}");    }    /**      * Print unit consisting of package clause and import statements in toplevel,      *  followed by class definition. if class definition == null,      *  print all definitions in toplevel.      *  @param tree     The toplevel tree      *  @param cdef     The class definition, which is assumed to be part of the      *                  toplevel tree.      */    public void printUnit(TopLevel tree, ClassDef cdef) {        docComments = tree.docComments;        printDocComment(tree);        if (tree.pid != null) {            print("package ");            printExpr(tree.pid);            print(";");            println();        }        for (List l = tree.defs; l.nonEmpty() &&                (cdef == null || ((Tree) l.head).tag == Tree.IMPORT); l = l.tail) {            printStat((Tree) l.head);            println();        }        if (cdef != null) {            printStat(cdef);            println();        }    }    /**      * Visitor methods      */    public void visitTopLevel(TopLevel tree) {        printUnit(tree, null);    }    public void visitImport(Import tree) {        print("import ");        printExpr(tree.qualid);        print(";");        println();    }    public void visitClassDef(ClassDef tree) {        println();        align();        printDocComment(tree);        printFlags(tree.flags & ~INTERFACE);        Name enclClassNamePrev = enclClassName;        enclClassName = tree.name;        if ((tree.flags & INTERFACE) != 0) {            print("interface " + tree.name);            if (tree.implementing.nonEmpty()) {                print(" extends ");                printExprs(tree.implementing);            }        } else {            print("class " + tree.name);            if (tree.extending != null) {                print(" extends ");                printExpr(tree.extending);            }            if (tree.implementing.nonEmpty()) {                print(" implements ");                printExprs(tree.implementing);            }        }        print(" ");        printBlock(tree.defs);        enclClassName = enclClassNamePrev;    }    public void visitMethodDef(MethodDef tree) {        if (tree.name == tree.name.table.init && enclClassName == null &&                sourceOutput)            return;        println();        align();        printDocComment(tree);        printFlags(tree.flags);        if (tree.name == tree.name.table.init) {            print(enclClassName != null ? enclClassName.toString() :                    tree.name.toString());        } else {            printExpr(tree.restype);            print(" " + tree.name);        }        print("(");        printExprs(tree.params);        print(")");        if (tree.thrown.nonEmpty()) {            print(" throws ");            printExprs(tree.thrown);        }        if (tree.body != null) {            print(" ");            printStat(tree.body);        } else {            print(";");        }    }    public void visitVarDef(VarDef tree) {        if (docComments != null && docComments.get(tree) != null) {            println();            align();        }        printDocComment(tree);        printFlags(tree.flags);        printExpr(tree.vartype);        print(" " + tree.name);        if (tree.init != null) {            print(" = ");            printExpr(tree.init);        }        if (prec == TreeInfo.notExpression)            print(";");    }    public void visitSkip(Skip tree) {        print(";");    }    public void visitBlock(Block tree) {        printFlags(tree.flags);        printBlock(tree.stats);    }    public void visitDoLoop(DoLoop tree) {        print("do ");        printStat(tree.body);        align();        print(" while ");        if (tree.cond.tag == Tree.PARENS) {            printExpr(tree.cond);        } else {            print("(");            printExpr(tree.cond);            print(")");        }        print(";");    }    public void visitWhileLoop(WhileLoop tree) {        print("while ");        if (tree.cond.tag == Tree.PARENS) {            printExpr(tree.cond);        } else {            print("(");            printExpr(tree.cond);            print(")");        }        print(" ");        printStat(tree.body);    }    public void visitForLoop(ForLoop tree) {        print("for (");        if (tree.init.nonEmpty()) {            if (((Tree) tree.init.head).tag == Tree.VARDEF) {                printExpr((Tree) tree.init.head);                for (List l = tree.init.tail; l.nonEmpty(); l = l.tail) {                    VarDef vdef = (VarDef) l.head;                    print(", " + vdef.name + " = ");                    printExpr(vdef.init);                }            } else {                printExprs(tree.init);            }        }        print("; ");        if (tree.cond != null)            printExpr(tree.cond);        print("; ");        printExprs(tree.step);        print(") ");        printStat(tree.body);    }    public void visitLabelled(Labelled tree) {        print(tree.label + ": ");        printStat(tree.body);    }    public void visitSwitch(Switch tree) {        print("switch ");        if (tree.selector.tag == Tree.PARENS) {            printExpr(tree.selector);        } else {            print("(");            printExpr(tree.selector);            print(")");        }        print(" {");