You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
908 lines
24 KiB
908 lines
24 KiB
/* TabbedPrintWriter Copyright (C) 1998-2002 Jochen Hoenicke.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; see the file COPYING.LESSER. If not, write to
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
package net.sf.jode.decompiler;
|
|
import java.io.*;
|
|
import java.util.Stack;
|
|
import java.util.Vector;
|
|
import java.util.Enumeration;
|
|
import net.sf.jode.bytecode.ClassInfo;
|
|
import net.sf.jode.type.*;
|
|
|
|
public class TabbedPrintWriter {
|
|
/* The indentation size. */
|
|
private int indentsize;
|
|
/* The size of a tab, 0 if we shouldn't use tabs at all. */
|
|
private int tabWidth;
|
|
private int style;
|
|
private int lineWidth;
|
|
private int currentIndent = 0;
|
|
private String indentStr = "";
|
|
private PrintWriter pw;
|
|
private ImportHandler imports;
|
|
private Stack scopes = new Stack();
|
|
|
|
public static final int BRACE_AT_EOL = 0x10;
|
|
public static final int INDENT_BRACES = 0x20;
|
|
public static final int GNU_SPACING = 0x40;
|
|
public static final int CODD_FORMATTING = 0x80; // allow trailing CLOSING braces as well
|
|
|
|
/**
|
|
* This string contains a few tab characters followed by tabWidth - 1
|
|
* spaces. It is used to quickly calculate the indentation string.
|
|
*/
|
|
private String tabSpaceString;
|
|
private StringBuffer currentLine;
|
|
private BreakPoint currentBP;
|
|
|
|
public final static int EXPL_PAREN = 0;
|
|
public final static int NO_PAREN = 1;
|
|
public final static int IMPL_PAREN = 2;
|
|
public final static int DONT_BREAK = 3;
|
|
|
|
/**
|
|
* The amount of tabs for which we can use the tabSpaceString.
|
|
*/
|
|
private final static int FASTINDENT = 20;
|
|
|
|
/**
|
|
* Convert the numeric indentation to a string.
|
|
*/
|
|
protected String makeIndentStr(int indent) {
|
|
if (indent < 0)
|
|
return "NEGATIVEINDENT"+indent;
|
|
|
|
int tabs = indent / tabWidth;
|
|
indent -= tabs * tabWidth;
|
|
if (tabs <= FASTINDENT) {
|
|
/* The fast way. */
|
|
return tabSpaceString.substring(FASTINDENT - tabs,
|
|
FASTINDENT + indent);
|
|
}
|
|
/* the not so fast way */
|
|
StringBuffer sb = new StringBuffer(tabs + indent);
|
|
while (tabs > FASTINDENT) {
|
|
sb.append(tabSpaceString.substring(0, FASTINDENT));
|
|
tabs -= 20;
|
|
}
|
|
sb.append(tabSpaceString.substring(FASTINDENT - tabs,
|
|
FASTINDENT + indent));
|
|
return sb.toString();
|
|
}
|
|
|
|
class BreakPoint {
|
|
int options;
|
|
int breakPenalty;
|
|
int breakPos;
|
|
int startPos;
|
|
BreakPoint parentBP;
|
|
Vector childBPs;
|
|
int nesting = 0;
|
|
int endPos;
|
|
int whatBreak = 0;
|
|
|
|
public BreakPoint(BreakPoint parent, int position) {
|
|
this.breakPos = position;
|
|
this.parentBP = parent;
|
|
this.options = DONT_BREAK;
|
|
this.breakPenalty = 0;
|
|
this.startPos = -1;
|
|
this.endPos = -1;
|
|
this.whatBreak = 0;
|
|
this.childBPs = null;
|
|
}
|
|
|
|
public void startOp(int opts, int penalty, int pos) {
|
|
if (startPos != -1)
|
|
throw new InternalError("missing breakOp");
|
|
startPos = pos;
|
|
options = opts;
|
|
breakPenalty = penalty;
|
|
childBPs = new Vector();
|
|
breakOp(pos);
|
|
}
|
|
|
|
public void breakOp(int pos) {
|
|
childBPs.addElement (new BreakPoint(this, pos));
|
|
}
|
|
|
|
public void endOp(int pos) {
|
|
endPos = pos;
|
|
if (childBPs.size() == 1) {
|
|
/* There is no breakpoint in this op, replace this with
|
|
* our child, if possible.
|
|
*/
|
|
BreakPoint child = (BreakPoint) childBPs.elementAt(0);
|
|
options = Math.min(options, child.options);
|
|
startPos = child.startPos;
|
|
endPos = child.endPos;
|
|
breakPenalty = child.breakPenalty;
|
|
childBPs = child.childBPs;
|
|
}
|
|
}
|
|
|
|
public void dump(String line) {
|
|
if (startPos == -1) {
|
|
pw.print(line);
|
|
} else {
|
|
pw.print(line.substring(0, startPos));
|
|
dumpRegion(line);
|
|
pw.print(line.substring(endPos));
|
|
}
|
|
}
|
|
|
|
public void dumpRegion(String line) {
|
|
String parens = "{\010{}\010}<\010<>\010>[\010[]\010]`\010`'\010'"
|
|
.substring(options*6, options*6+6);
|
|
pw.print(parens.substring(0,3));
|
|
Enumeration enumeration = childBPs.elements();
|
|
int cur = startPos;
|
|
BreakPoint child = (BreakPoint) enumeration.nextElement();
|
|
if (child.startPos >= 0) {
|
|
pw.print(line.substring(cur, child.startPos));
|
|
child.dumpRegion(line);
|
|
cur = child.endPos;
|
|
}
|
|
while (enumeration.hasMoreElements()) {
|
|
child = (BreakPoint) enumeration.nextElement();
|
|
pw.print(line.substring(cur, child.breakPos));
|
|
pw.print("!\010!"+breakPenalty);
|
|
cur = child.breakPos;
|
|
if (child.startPos >= 0) {
|
|
pw.print(line.substring(child.breakPos, child.startPos));
|
|
child.dumpRegion(line);
|
|
cur = child.endPos;
|
|
}
|
|
}
|
|
pw.print(line.substring(cur, endPos));
|
|
pw.print(parens.substring(3));
|
|
}
|
|
|
|
public void printLines(int indent, String line) {
|
|
if (startPos == -1) {
|
|
pw.print(line);
|
|
} else {
|
|
pw.print(line.substring(0, startPos));
|
|
printRegion(indent + startPos, line);
|
|
pw.print(line.substring(endPos));
|
|
}
|
|
}
|
|
|
|
public void printRegion(int indent, String line) {
|
|
if (options == IMPL_PAREN) {
|
|
pw.print("(");
|
|
indent++;
|
|
}
|
|
|
|
Enumeration enumeration = childBPs.elements();
|
|
int cur = startPos;
|
|
BreakPoint child = (BreakPoint) enumeration.nextElement();
|
|
if (child.startPos >= 0) {
|
|
pw.print(line.substring(cur, child.startPos));
|
|
child.printRegion(indent + child.startPos - cur, line);
|
|
cur = child.endPos;
|
|
}
|
|
if (options == NO_PAREN)
|
|
indent += indentsize;
|
|
String indentStr = makeIndentStr(indent);
|
|
while (enumeration.hasMoreElements()) {
|
|
child = (BreakPoint) enumeration.nextElement();
|
|
pw.print(line.substring(cur, child.breakPos));
|
|
pw.println();
|
|
pw.print(indentStr);
|
|
cur = child.breakPos;
|
|
if (cur < endPos && line.charAt(cur) == ' ')
|
|
cur++;
|
|
if (child.startPos >= 0) {
|
|
pw.print(line.substring(cur, child.startPos));
|
|
child.printRegion(indent + child.startPos - cur, line);
|
|
cur = child.endPos;
|
|
}
|
|
}
|
|
pw.print(line.substring(cur, endPos));
|
|
if (options == IMPL_PAREN)
|
|
pw.print(")");
|
|
}
|
|
|
|
public BreakPoint commitMinPenalty(int space, int lastSpace,
|
|
int minPenalty) {
|
|
if (startPos == -1 || lastSpace > endPos - startPos
|
|
|| minPenalty == 10 * (endPos - startPos - lastSpace)) {
|
|
/* We don't have to break anything */
|
|
startPos = -1;
|
|
childBPs = null;
|
|
return this;
|
|
}
|
|
|
|
int size = childBPs.size();
|
|
if (size > 1 && options != DONT_BREAK) {
|
|
/* penalty if we are breaking the line here. */
|
|
int breakPen
|
|
= getBreakPenalty(space, lastSpace, minPenalty + 1);
|
|
if (minPenalty == breakPen) {
|
|
commitBreakPenalty(space, lastSpace, breakPen);
|
|
return this;
|
|
}
|
|
}
|
|
|
|
/* penalty if we are breaking only one child */
|
|
for (int i=0; i < size; i++) {
|
|
BreakPoint child = (BreakPoint) childBPs.elementAt(i);
|
|
int front = child.startPos - startPos;
|
|
int tail = endPos - child.endPos;
|
|
int needPenalty = minPenalty - (i < size - 1 ? 1 : 0);
|
|
if (needPenalty ==
|
|
child.getMinPenalty(space - front,
|
|
lastSpace - front - tail,
|
|
needPenalty + 1)) {
|
|
child = child.commitMinPenalty(space - front,
|
|
lastSpace - front - tail,
|
|
needPenalty);
|
|
child.breakPos = breakPos;
|
|
return child;
|
|
}
|
|
}
|
|
throw new IllegalStateException("Can't commit line break!");
|
|
}
|
|
|
|
public int getMinPenalty(int space, int lastSpace, int minPenalty) {
|
|
if (10 * -lastSpace >= minPenalty) {
|
|
return minPenalty;
|
|
}
|
|
|
|
if (startPos == -1)
|
|
return 10 * -lastSpace;
|
|
|
|
if (lastSpace > endPos - startPos) {
|
|
return 0;
|
|
}
|
|
|
|
if (minPenalty <= 1) {
|
|
return minPenalty;
|
|
}
|
|
|
|
if (minPenalty > 10 * (endPos - startPos - lastSpace))
|
|
minPenalty = 10 * (endPos - startPos - lastSpace);
|
|
|
|
int size = childBPs.size();
|
|
if (size == 0)
|
|
return minPenalty;
|
|
|
|
if (size > 1 && options != DONT_BREAK) {
|
|
/* penalty if we are breaking at this level. */
|
|
minPenalty = getBreakPenalty(space, lastSpace, minPenalty);
|
|
}
|
|
|
|
/* penalty if we are breaking only one child */
|
|
for (int i=0; i < size; i++) {
|
|
BreakPoint child = (BreakPoint) childBPs.elementAt(i);
|
|
int front = child.startPos - startPos;
|
|
int tail = endPos - child.endPos;
|
|
int penalty = (i < size - 1 ? 1 : 0);
|
|
minPenalty = penalty +
|
|
child.getMinPenalty(space - front,
|
|
lastSpace - front - tail,
|
|
minPenalty - penalty);
|
|
}
|
|
return minPenalty;
|
|
}
|
|
|
|
public void commitBreakPenalty(int space, int lastSpace,
|
|
int minPenalty) {
|
|
if (options == IMPL_PAREN) {
|
|
space--;
|
|
lastSpace -= 2;
|
|
}
|
|
|
|
Enumeration enumeration = childBPs.elements();
|
|
childBPs = new Vector();
|
|
int currInd = 0;
|
|
BreakPoint lastChild, nextChild;
|
|
boolean indentNext = options == NO_PAREN;
|
|
for (lastChild = (BreakPoint) enumeration.nextElement();
|
|
enumeration.hasMoreElements(); lastChild = nextChild) {
|
|
nextChild = (BreakPoint) enumeration.nextElement();
|
|
int childStart = lastChild.breakPos;
|
|
int childEnd = nextChild.breakPos;
|
|
|
|
if (currInd > 0) {
|
|
currInd += childEnd - childStart;
|
|
if (currInd <= space)
|
|
continue;
|
|
}
|
|
if (childStart < endPos
|
|
&& currentLine.charAt(childStart) == ' ')
|
|
childStart++;
|
|
|
|
if (childEnd - childStart > space) {
|
|
int front = lastChild.startPos - childStart;
|
|
int tail = childEnd - lastChild.endPos;
|
|
int childPenalty = lastChild.getMinPenalty
|
|
(space - front, space - front - tail, minPenalty);
|
|
currInd = 0;
|
|
childBPs.addElement
|
|
(lastChild.commitMinPenalty
|
|
(space - front, space - front - tail, childPenalty));
|
|
} else {
|
|
lastChild.startPos = -1;
|
|
lastChild.childBPs = null;
|
|
childBPs.addElement(lastChild);
|
|
currInd = childEnd - childStart;
|
|
}
|
|
|
|
if (indentNext) {
|
|
space -= indentsize;
|
|
lastSpace -= indentsize;
|
|
indentNext = false;
|
|
}
|
|
}
|
|
int childStart = lastChild.breakPos;
|
|
if (currInd > 0 && currInd + endPos - childStart <= lastSpace)
|
|
return;
|
|
|
|
if (childStart < endPos
|
|
&& currentLine.charAt(childStart) == ' ')
|
|
childStart++;
|
|
if (endPos - childStart > lastSpace) {
|
|
int front = lastChild.startPos - childStart;
|
|
int tail = endPos - lastChild.endPos;
|
|
int childPenalty = lastChild.getMinPenalty
|
|
(space - front, lastSpace - front - tail, minPenalty + 1);
|
|
childBPs.addElement
|
|
(lastChild.commitMinPenalty
|
|
(space - front, lastSpace - front - tail, childPenalty));
|
|
} else {
|
|
lastChild.startPos = -1;
|
|
lastChild.childBPs = null;
|
|
childBPs.addElement(lastChild);
|
|
}
|
|
}
|
|
|
|
public int getBreakPenalty(int space, int lastSpace, int minPenalty) {
|
|
int penalty = breakPenalty;
|
|
int currInd = 0;
|
|
if (options == IMPL_PAREN) {
|
|
space--;
|
|
lastSpace -= 2;
|
|
}
|
|
if (space < 0)
|
|
return minPenalty;
|
|
Enumeration enumeration = childBPs.elements();
|
|
BreakPoint lastChild, nextChild;
|
|
boolean indentNext = options == NO_PAREN;
|
|
for (lastChild = (BreakPoint) enumeration.nextElement();
|
|
enumeration.hasMoreElements(); lastChild = nextChild) {
|
|
nextChild = (BreakPoint) enumeration.nextElement();
|
|
int childStart = lastChild.breakPos;
|
|
int childEnd = nextChild.breakPos;
|
|
|
|
if (currInd > 0) {
|
|
currInd += childEnd - childStart;
|
|
if (currInd <= space)
|
|
continue;
|
|
|
|
penalty++;
|
|
if (indentNext) {
|
|
space -= indentsize;
|
|
lastSpace -= indentsize;
|
|
indentNext = false;
|
|
}
|
|
}
|
|
|
|
if (childStart < endPos
|
|
&& currentLine.charAt(childStart) == ' ')
|
|
childStart++;
|
|
|
|
if (childEnd - childStart > space) {
|
|
int front = lastChild.startPos - childStart;
|
|
int tail = childEnd - lastChild.endPos;
|
|
penalty += 1 + lastChild.getMinPenalty
|
|
(space - front, space - front - tail,
|
|
minPenalty - penalty - 1);
|
|
|
|
if (indentNext) {
|
|
space -= indentsize;
|
|
lastSpace -= indentsize;
|
|
indentNext = false;
|
|
}
|
|
currInd = 0;
|
|
} else
|
|
currInd = childEnd - childStart;
|
|
|
|
if (penalty >= minPenalty)
|
|
return minPenalty;
|
|
}
|
|
int childStart = lastChild.breakPos;
|
|
if (currInd > 0) {
|
|
if (currInd + endPos - childStart <= lastSpace)
|
|
return penalty;
|
|
|
|
penalty++;
|
|
if (indentNext) {
|
|
space -= indentsize;
|
|
lastSpace -= indentsize;
|
|
indentNext = false;
|
|
}
|
|
}
|
|
if (childStart < endPos
|
|
&& currentLine.charAt(childStart) == ' ')
|
|
childStart++;
|
|
if (endPos - childStart > lastSpace) {
|
|
int front = lastChild.startPos - childStart;
|
|
int tail = endPos - lastChild.endPos;
|
|
penalty += lastChild.getMinPenalty
|
|
(space - front, lastSpace - front - tail,
|
|
minPenalty - penalty);
|
|
}
|
|
if (penalty < minPenalty)
|
|
return penalty;
|
|
return minPenalty;
|
|
}
|
|
}
|
|
|
|
public TabbedPrintWriter (OutputStream os, ImportHandler imports,
|
|
boolean autoFlush, int style,
|
|
int indentSize, int tabWidth, int lineWidth) {
|
|
if ((style & CODD_FORMATTING) != 0)
|
|
pw = new PrintWriter(new NlRemover(new OutputStreamWriter(os), tabWidth), autoFlush);
|
|
else
|
|
pw = new PrintWriter(os, autoFlush);
|
|
this.imports = imports;
|
|
this.style = style;
|
|
this.indentsize = indentSize;
|
|
this.tabWidth = tabWidth;
|
|
this.lineWidth = lineWidth;
|
|
init();
|
|
}
|
|
|
|
public TabbedPrintWriter (Writer os, ImportHandler imports, boolean autoFlush, int style, int indentSize, int tabWidth, int lineWidth) {
|
|
if ((style & CODD_FORMATTING) != 0)
|
|
pw = new PrintWriter(new NlRemover(os, tabWidth), autoFlush);
|
|
else {
|
|
pw = new PrintWriter(os, autoFlush); }
|
|
this.imports = imports;
|
|
this.style = style;
|
|
this.indentsize = indentSize;
|
|
this.tabWidth = tabWidth;
|
|
this.lineWidth = lineWidth;
|
|
init();
|
|
}
|
|
|
|
public TabbedPrintWriter (OutputStream os, ImportHandler imports,
|
|
boolean autoFlush) {
|
|
this(os, imports, autoFlush, BRACE_AT_EOL, 4, 8, 79);
|
|
}
|
|
|
|
public TabbedPrintWriter (Writer os, ImportHandler imports,
|
|
boolean autoFlush) {
|
|
this(os, imports, autoFlush, BRACE_AT_EOL, 4, 8, 79);
|
|
}
|
|
|
|
public TabbedPrintWriter (OutputStream os, ImportHandler imports) {
|
|
this(os, imports, true);
|
|
}
|
|
|
|
public TabbedPrintWriter (Writer os, ImportHandler imports) {
|
|
this(os, imports, true);
|
|
}
|
|
|
|
public TabbedPrintWriter (OutputStream os) {
|
|
this(os, null);
|
|
}
|
|
|
|
public TabbedPrintWriter (Writer os) {
|
|
this(os, null);
|
|
}
|
|
|
|
private void init() {
|
|
currentLine = new StringBuffer();
|
|
currentBP = new BreakPoint(null, 0);
|
|
currentBP.startOp(DONT_BREAK, 1, 0);
|
|
initTabString();
|
|
}
|
|
|
|
private void initTabString() {
|
|
char tabChar = '\t';
|
|
if (tabWidth <= 1) {
|
|
/* If tabWidth is 0 use spaces instead of tabs. */
|
|
tabWidth = 1;
|
|
tabChar = ' ';
|
|
}
|
|
StringBuffer sb = new StringBuffer(FASTINDENT + tabWidth - 1);
|
|
for (int i = 0; i < FASTINDENT; i++)
|
|
sb.append(tabChar);
|
|
for (int i = 0; i < tabWidth - 1; i++)
|
|
sb.append(' ');
|
|
tabSpaceString = sb.toString();
|
|
}
|
|
|
|
public void tab() {
|
|
currentIndent += indentsize;
|
|
indentStr = makeIndentStr(currentIndent);
|
|
}
|
|
|
|
public void untab() {
|
|
currentIndent -= indentsize;
|
|
indentStr = makeIndentStr(currentIndent);
|
|
}
|
|
|
|
public void startOp(int options, int penalty) {
|
|
currentBP = (BreakPoint) currentBP.childBPs.lastElement();
|
|
currentBP.startOp(options, penalty, currentLine.length());
|
|
}
|
|
|
|
public void breakOp() {
|
|
int pos = currentLine.length();
|
|
if (pos > currentBP.startPos && currentLine.charAt(pos-1) == ' ')
|
|
pos--;
|
|
currentBP.breakOp(pos);
|
|
}
|
|
|
|
public void endOp() {
|
|
currentBP.endOp(currentLine.length());
|
|
currentBP = currentBP.parentBP;
|
|
if (currentBP == null)
|
|
throw new NullPointerException();
|
|
}
|
|
|
|
public Object saveOps() {
|
|
Stack state = new Stack();
|
|
int pos = currentLine.length();
|
|
while (currentBP.parentBP != null) {
|
|
state.push(new Integer(currentBP.breakPenalty));
|
|
/* We don't want parentheses or unconventional line breaking */
|
|
currentBP.options = DONT_BREAK;
|
|
currentBP.endPos = pos;
|
|
currentBP = currentBP.parentBP;
|
|
}
|
|
return state;
|
|
}
|
|
|
|
public void restoreOps(Object s) {
|
|
Stack state = (Stack) s;
|
|
while (!state.isEmpty()) {
|
|
int penalty = ((Integer) state.pop()).intValue();
|
|
startOp(DONT_BREAK, penalty);
|
|
}
|
|
}
|
|
|
|
public void println(String str) {
|
|
print(str);
|
|
println();
|
|
}
|
|
|
|
public void flushLine() {
|
|
currentBP.endPos = currentLine.length();
|
|
|
|
// pw.print(indentStr);
|
|
// currentBP.dump(currentLine.toString());
|
|
// pw.println();
|
|
|
|
int lw = lineWidth - currentIndent;
|
|
int minPenalty = currentBP.getMinPenalty(lw, lw, Integer.MAX_VALUE/2);
|
|
currentBP = currentBP.commitMinPenalty(lw, lw, minPenalty);
|
|
|
|
// pw.print(indentStr);
|
|
// currentBP.dump(currentLine.toString());
|
|
// pw.println();
|
|
pw.print(indentStr);
|
|
currentBP.printLines(currentIndent, currentLine.toString());
|
|
|
|
currentLine.setLength(0);
|
|
currentBP = new BreakPoint(null, 0);
|
|
currentBP.startOp(DONT_BREAK, 1, 0);
|
|
}
|
|
|
|
public void println() {
|
|
flushLine();
|
|
pw.println();
|
|
}
|
|
|
|
public void print(String str) {
|
|
currentLine.append(str);
|
|
}
|
|
|
|
public void printType(Type type) {
|
|
print(getTypeString(type));
|
|
}
|
|
|
|
public void pushScope(Scope scope) {
|
|
scopes.push(scope);
|
|
}
|
|
|
|
public void popScope() {
|
|
scopes.pop();
|
|
}
|
|
|
|
/**
|
|
* Checks if the name in inScope conflicts with an identifier in a
|
|
* higher scope.
|
|
*/
|
|
public boolean conflicts(String name, Scope inScope, int context) {
|
|
int dot = name.indexOf('.');
|
|
if (dot >= 0)
|
|
name = name.substring(0, dot);
|
|
int count = scopes.size();
|
|
for (int ptr = count; ptr-- > 0; ) {
|
|
Scope scope = (Scope) scopes.elementAt(ptr);
|
|
if (scope == inScope)
|
|
return false;
|
|
if (scope.conflicts(name, context)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public Scope getScope(Object obj, int scopeType) {
|
|
int count = scopes.size();
|
|
for (int ptr = count; ptr-- > 0; ) {
|
|
Scope scope = (Scope) scopes.elementAt(ptr);
|
|
if (scope.isScopeOf(obj, scopeType))
|
|
return scope;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getClassString(ClassInfo clazz, int scopeType) {
|
|
try {
|
|
clazz.load(ClassInfo.OUTERCLASS);
|
|
} catch (IOException ex) {
|
|
clazz.guess(ClassInfo.OUTERCLASS);
|
|
}
|
|
if ((Options.options & Options.OPTION_INNER) != 0
|
|
&& clazz.getOuterClass() != null) {
|
|
|
|
String className = clazz.getClassName();
|
|
Scope scope = getScope(clazz.getOuterClass(), Scope.CLASSSCOPE);
|
|
if (scope != null &&
|
|
!conflicts(className, scope, scopeType))
|
|
return className;
|
|
|
|
return getClassString(clazz.getOuterClass(), scopeType)
|
|
+ "." + className;
|
|
}
|
|
|
|
if ((Options.options & Options.OPTION_ANON) != 0
|
|
&& clazz.isMethodScoped()) {
|
|
|
|
String className = clazz.getClassName();
|
|
if (className == null)
|
|
return "ANONYMOUS CLASS "+clazz.getName();
|
|
|
|
Scope scope = getScope(clazz, Scope.METHODSCOPE);
|
|
if (scope != null &&
|
|
!conflicts(className, scope, scopeType))
|
|
return className;
|
|
|
|
if (scope != null)
|
|
return "NAME CONFLICT " + className;
|
|
return "UNREACHABLE " + className;
|
|
}
|
|
if (imports != null) {
|
|
String importedName = imports.getClassString(clazz);
|
|
if (!conflicts(importedName, null, scopeType))
|
|
return importedName;
|
|
}
|
|
String name = clazz.getName();
|
|
if (conflicts(name, null, Scope.AMBIGUOUSNAME))
|
|
return "PKGNAMECONFLICT "+ name;
|
|
return name;
|
|
}
|
|
|
|
public String getTypeString(Type type) {
|
|
if (type instanceof ArrayType)
|
|
return getTypeString(((ArrayType) type).getElementType()) + "[]";
|
|
else if (type instanceof ClassInfoType) {
|
|
ClassInfo clazz = ((ClassInfoType) type).getClassInfo();
|
|
return getClassString(clazz, Scope.CLASSNAME);
|
|
} else if (type instanceof ClassType) {
|
|
String name = ((ClassType) type).getClassName();
|
|
if (imports != null) {
|
|
String importedName = imports.getClassString(name);
|
|
if (!conflicts(importedName, null, Scope.CLASSNAME))
|
|
return importedName;
|
|
}
|
|
if (conflicts(name, null, Scope.AMBIGUOUSNAME))
|
|
return "PKGNAMECONFLICT "+ name;
|
|
return name;
|
|
} else if (type instanceof NullType)
|
|
return "Object";
|
|
else
|
|
return type.toString();
|
|
}
|
|
|
|
public void printOptionalSpace() {
|
|
if ((style & GNU_SPACING) != 0)
|
|
print(" ");
|
|
}
|
|
|
|
/**
|
|
* Print a opening brace with the current indentation style.
|
|
* Called at the end of the line of the instance that opens the
|
|
* brace. It doesn't do a tab stop after opening the brace.
|
|
*/
|
|
public void openBrace() {
|
|
boolean bracePrinted = false;
|
|
if (currentLine.length() > 0) {
|
|
if ((style & BRACE_AT_EOL) != 0) {
|
|
print(" {");
|
|
bracePrinted = true;
|
|
}
|
|
println();
|
|
}
|
|
if ((style & INDENT_BRACES) != 0 && currentIndent > 0)
|
|
tab();
|
|
|
|
if (!bracePrinted)
|
|
println("{");
|
|
}
|
|
|
|
public void openBraceClass() {
|
|
openBraceNoIndent();
|
|
}
|
|
|
|
/**
|
|
* Print a opening brace with the current indentation style.
|
|
* Called at the end the line of a method declaration.
|
|
*/
|
|
public void openBraceNoIndent() {
|
|
if (currentLine.length() > 0) {
|
|
if ((style & BRACE_AT_EOL) != 0)
|
|
print(" ");
|
|
else
|
|
println();
|
|
}
|
|
println("{");
|
|
}
|
|
|
|
/**
|
|
* Print an opening brace with the current indentation style.
|
|
* Called at the end of the line of the instance that opens the
|
|
* brace. It doesn't do a tab stop after opening the brace.
|
|
*/
|
|
public void openBraceNoSpace() {
|
|
boolean bracePrinted = false;
|
|
if (currentLine.length() > 0) {
|
|
if ((style & BRACE_AT_EOL) != 0) {
|
|
print("{");
|
|
bracePrinted = true;
|
|
}
|
|
println();
|
|
}
|
|
if ((style & INDENT_BRACES) != 0 && currentIndent > 0)
|
|
tab();
|
|
if (!bracePrinted)
|
|
println("{");
|
|
}
|
|
|
|
public void closeBraceContinue() {
|
|
if ((style & (BRACE_AT_EOL|CODD_FORMATTING)) == BRACE_AT_EOL)
|
|
print("} ");
|
|
else
|
|
println("}");
|
|
if ((style & INDENT_BRACES) != 0 && currentIndent > 0)
|
|
untab();
|
|
}
|
|
|
|
public void closeBraceClass() {
|
|
print("}");
|
|
}
|
|
|
|
public void closeBrace() {
|
|
println("}");
|
|
if ((style & INDENT_BRACES) != 0 && currentIndent > 0)
|
|
untab();
|
|
}
|
|
|
|
public void closeBraceNoIndent() {
|
|
println("}");
|
|
}
|
|
|
|
public void flush() {
|
|
flushLine();
|
|
pw.flush();
|
|
}
|
|
|
|
public void close() {
|
|
flushLine();
|
|
pw.close();
|
|
}
|
|
}
|
|
|
|
|
|
class NlRemover extends Writer {
|
|
private int tabWidth;
|
|
private Writer out;
|
|
private int pendingNL;
|
|
private boolean lastWasClBr;
|
|
private int pendingSpace;
|
|
|
|
public NlRemover(Writer to, int tabWidth) {
|
|
this.out = to;
|
|
this.tabWidth = tabWidth; }
|
|
|
|
public void close() throws IOException {
|
|
if (out != null) {
|
|
while (pendingNL > 0) {
|
|
out.write('\n');
|
|
pendingNL--;
|
|
}
|
|
out.close();
|
|
out = null;
|
|
}
|
|
}
|
|
|
|
public void flush() throws IOException {
|
|
if (out != null) {
|
|
while (pendingNL > 0) {
|
|
out.write('\n');
|
|
pendingNL--;
|
|
}
|
|
out.flush();
|
|
}
|
|
}
|
|
|
|
public void write(int x) throws IOException {
|
|
switch ((char)x) {
|
|
|
|
case '}':
|
|
if (! lastWasClBr && pendingSpace > 0)
|
|
out.write(' ');
|
|
out.write('}');
|
|
pendingSpace = 0;
|
|
pendingNL = 0;
|
|
lastWasClBr = true;
|
|
return;
|
|
case '\r':
|
|
pendingSpace = 0;
|
|
return;
|
|
case '\n':
|
|
if (pendingNL > 0) {
|
|
out.write('\n'); }
|
|
else
|
|
pendingNL++;
|
|
pendingSpace = 0;
|
|
return;
|
|
case '\t':
|
|
pendingSpace = (pendingSpace + tabWidth) / tabWidth * tabWidth;
|
|
return;
|
|
case ' ':
|
|
pendingSpace += 1;
|
|
return;
|
|
default:
|
|
while (pendingNL > 0) {
|
|
out.write('\n');
|
|
pendingNL--;
|
|
}
|
|
while (pendingSpace > 0) {
|
|
out.write(' ');
|
|
pendingSpace--;
|
|
}
|
|
out.write(x);
|
|
lastWasClBr = false;
|
|
}
|
|
}
|
|
|
|
public void write(char[] cbuf, int off, int len) throws IOException {
|
|
len+=off;
|
|
while (off < len)
|
|
write(cbuf[off++]);
|
|
}
|
|
}
|
|
|