sourceprinter.java

Python Development Environment (Python IDE plugin for Eclipse). Features editor, code completion, re

package org.python.pydev.refactoring.ast.printer;

import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.SpecialStr;
import org.python.pydev.parser.jython.ast.BoolOp;
import org.python.pydev.parser.jython.ast.Num;
import org.python.pydev.parser.jython.ast.Str;
import org.python.pydev.parser.jython.ast.cmpopType;
import org.python.pydev.parser.jython.ast.commentType;
import org.python.pydev.parser.jython.ast.operatorType;
import org.python.pydev.parser.jython.ast.str_typeType;
import org.python.pydev.parser.jython.ast.unaryopType;
import org.python.pydev.refactoring.ast.visitors.NodeHelper;

public class SourcePrinter {

	private boolean disabledIfPrinting;

	private final SyntaxHelper syntaxHelper;

	private boolean ignoreComments;

	private final NodeHelper nodeHelper;

	private final PrintWriter output;

	private final CallDepth callDepth;

    private String newLineDelim;

	public SourcePrinter(PrintWriter output, String newLineDelim) {
		this(output, new SyntaxHelper(newLineDelim), new CallDepth(), false);
        this.newLineDelim = newLineDelim;
	}

	public SourcePrinter(PrintWriter output, SyntaxHelper formatHelper, CallDepth callDepth, boolean ignoreComments) {
		this.output = output;
		this.syntaxHelper = formatHelper;
		this.callDepth = callDepth;
		this.ignoreComments = ignoreComments;

		this.disabledIfPrinting = false;
		this.nodeHelper = new NodeHelper(newLineDelim);

	}

	protected java.util.List<commentType> extractComments(java.util.List<Object> specials) {
		if (specials == null)
			return null;

		java.util.List<commentType> comments = new ArrayList<commentType>();

		for (Object node : specials) {
			if (node instanceof commentType) {
				commentType comment = (commentType) node;
				comments.add(comment);
			}
		}

		return comments;
	}

	protected java.util.List<commentType> extractComments(java.util.List<Object> specials, SimpleNode firstBodyNode, boolean before) {
		if (specials == null)
			return null;

		java.util.List<commentType> comments = new ArrayList<commentType>();

		for (commentType comment : extractComments(specials)) {
			if (firstBodyNode != null) {

				if (before) {
					if (comment.beginLine < firstBodyNode.beginLine)
						comments.add(comment);
				} else {
					if (comment.beginLine >= firstBodyNode.beginLine)
						comments.add(comment);
				}

			}
		}

		return comments;
	}

	public void flushStream() {
		output.flush();
	}

	public int getStartLine(SimpleNode n) {
		return nodeHelper.getStartLine(n);
	}

	public int getStartOffset(SimpleNode n) {
		return nodeHelper.getStartOffset(n);
	}

	public SyntaxHelper getSyntaxhelper() {
		return syntaxHelper;
	}

	public boolean hasCommentsAfter(SimpleNode node) {
		if (node == null)
			return false;
		if (node.specialsAfter == null)
			return false;

		java.util.List<commentType> comments = extractComments(node.specialsAfter);
		return (comments != null) && (comments.size() > 0);

	}

	public void indent() {
		syntaxHelper.indent();
	}

	public boolean isCommentBefore(SimpleNode node, commentType comment) {
		return getStartLine(comment) < getStartLine(node);
	}

	public boolean isDisabledIfPrinting() {
		return disabledIfPrinting;
	}

	private boolean isIgnoreComments(SimpleNode node) {
		return ignoreComments || (node == null);
	}

	public boolean isPrettyPrint(SimpleNode node) {
		return (nodeHelper.isFunctionOrClassDef(node) || isPrettyPrintControlStatement(node));
	}

	public boolean isPrettyPrintControlStatement(SimpleNode node) {
		return nodeHelper.isControlStatement(node) && !isDisabledIfPrinting();
	}

	public boolean isSameLine(SimpleNode node1, SimpleNode node2) {
		return (getStartLine(node1) == getStartLine(node2));
	}

	public void outdent() {
		syntaxHelper.outdent();
	}

	public void prettyPrintAfter(SimpleNode node, SimpleNode lastNode) {
		if (!inCall() && isPrettyPrint(node) && isPrettyPrint(lastNode)) {
			printNewlineAndIndentation();
		}
	}

	public void print(BigInteger i) {
		output.print(i);
	}

	public void print(char c) {
		output.print(c);
	}

	public void print(double d) {
		output.print(d);
	}

	public void print(int i) {
		output.print(i);
	}

	public void print(long l) {
		output.print(l);
	}

	public void print(Object o) {
		output.print(String.valueOf(o));
	}

	public void print(String s) {
		output.print(s);
	}

	public void printAfterDict() {
		print(syntaxHelper.afterDict());
	}

	public void printAfterList() {
		print(syntaxHelper.afterList());
	}

	public void printAfterTuple() {
		print(syntaxHelper.afterTuple());
	}

	public void printAssignmentOperator(boolean spaceBefore, boolean spaceAfter) {
		if (spaceBefore)
			printSpace();
		print(syntaxHelper.getOperatorAssignment());
		if (spaceAfter)
			printSpace();
	}

	public void printAttributeSeparator() {
		print(syntaxHelper.getAttributeSeparator());
	}

	public void printBeforeAndAfterCmpOp() {
		printSpace();
	}

	public void printBeforeComment() {
		print(syntaxHelper.afterStatement());
	}

	public void printBeforeDecorator() {
		print(syntaxHelper.getAtSymbol());

	}

	public void printBeforeDict() {
		print(syntaxHelper.beforeDict());
	}

	public void printBeforeKwArg() {
		print(syntaxHelper.getStar(2));
	}

	public void printBeforeList() {
		print(syntaxHelper.beforeList());
	}

	public void printBeforeTuple() {
		print(syntaxHelper.beforeTuple());
	}

	public void printBeforeVarArg() {
		print(syntaxHelper.getStar(1));
	}

	public void printBinOp(int opType, boolean spaceBefore, boolean spaceAfter) {
		String op;

		switch (opType) {
		case operatorType.Add:
			op = syntaxHelper.getOperatorAdd();
			break;
		case operatorType.BitAnd:
			op = syntaxHelper.getOperatorBitAnd();
			break;
		case operatorType.BitOr:
			op = syntaxHelper.getOperatorBitOr();
			break;
		case operatorType.BitXor:
			op = syntaxHelper.getOperatorBitXor();
			break;
		case operatorType.Div:
			op = syntaxHelper.getOperatorDiv();
			break;
		case operatorType.FloorDiv:
			op = syntaxHelper.getOperatorFloorDiv();
			break;
		case operatorType.LShift:
			op = syntaxHelper.getOperatorShiftLeft();
			break;
		case operatorType.Mod:
			op = syntaxHelper.getOperatorMod();
			break;
		case operatorType.Mult:
			op = syntaxHelper.getOperatorMult();
			break;
		case operatorType.Pow:
			op = syntaxHelper.getOperatorPow();
			break;
		case operatorType.RShift:
			op = syntaxHelper.getOperatorShiftRight();
			break;
		case operatorType.Sub:
			op = syntaxHelper.getOperatorSub();
			break;
		default:
			op = "<undef_binop>";
			break;
		}

		if (spaceBefore)
			printSpace();
		print(op);
		if (spaceAfter)
			printSpace();
	}

	public void printBoolOp(int op) {

		printSpace();
		switch (op) {
		case BoolOp.And:
			print(syntaxHelper.getOperatorBoolAnd());
			break;
		case BoolOp.Or:
			print(syntaxHelper.getOperatorBoolOr());
			break;
		default:
			print("<undef_boolop>");
			break;
		}
		printSpace();

	}

	public void printClassDef() {
		printStatement("class");
	}

	protected void printComment(SimpleNode node, java.util.List<commentType> comments) {

		if (comments == null)
			return;

		boolean wasOnSameLine = false;

		for (Iterator<commentType> iter = comments.iterator(); iter.hasNext();) {
			commentType comment = iter.next();
			String commentText = comment.id.trim();

			if (isSameLine(node, comment)) {
				printBeforeComment();
				wasOnSameLine = true;
			} else {
				printNewlineAndIndentation();
			}

			print(commentText);

			if (isCommentBefore(node, comment) && (!wasOnSameLine)) {
				printNewlineAndIndentation();
			}

		}

	}

	public void printCommentAfter(SimpleNode node) {
		if (!(isIgnoreComments(node))) {
			if (!(nodeHelper.isControlStatement(node)))
				printComment(node, extractComments(node.specialsAfter));
		}
	}

	public void printCommentBeforeBody(SimpleNode node, SimpleNode firstBodyNode) {
		if (!(isIgnoreComments(node)))
			printComment(node, extractComments(node.specialsAfter, firstBodyNode, true));
	}

	public void printCommentAfterBody(SimpleNode node, SimpleNode firstBodyNode) {
		if (!isIgnoreComments(node))
			printComment(node, extractComments(node.specialsAfter, firstBodyNode, false));
	}

	public void printCommentBefore(SimpleNode node) {
		if (!isIgnoreComments(node))
			printComment(node, extractComments(node.specialsBefore));
	}

	public void printCompOp(int opType) {
		switch (opType) {
		case cmpopType.Eq:
			print(syntaxHelper.getOperatorEqual());
			break;
		case cmpopType.Gt:
			print(syntaxHelper.getOperatorGt());
			break;
		case cmpopType.GtE:
			print(syntaxHelper.getOperatorGtEqual());
			break;
		case cmpopType.In:
			print(syntaxHelper.getOperatorIn());
			break;
		case cmpopType.Is:
			print(syntaxHelper.getOperatorIs());
			break;
		case cmpopType.IsNot:
			print(syntaxHelper.getOperatorIsNot());
			break;
		case cmpopType.Lt:
			print(syntaxHelper.getOperatorLt());