sourceprinter.java

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

			break;
		case cmpopType.LtE:
			print(syntaxHelper.getOperatorLtEqual());
			break;
		case cmpopType.NotEq:
			print(syntaxHelper.getOperatorNotEqual());
			break;
		case cmpopType.NotIn:
			print(syntaxHelper.getOperatorNotIn());
			break;
		default:
			print("<undef_compop>");
			break;
		}

	}

	public void printContinue() {
		printStatement("continue", false, false);
	}

	public void printDestinationOperator(boolean withSpaceBefore, boolean withSpaceAfter) {
		if (withSpaceBefore)
			printSpace();
		print(syntaxHelper.getOperatorDestination());
		if (withSpaceAfter)
			printSpace();
	}

	public void printDictBeforeValue() {
		printFunctionMarker();
		printSpace();
	}

	public void printDoubleDot() {
		print(syntaxHelper.getDoubleDot());

	}

	public void printDoubleDotAndNewline() {
		printDoubleDot();
		printNewlineAndIndentation();
	}

	protected void printDoubleQuote() {
		print(syntaxHelper.getDoubleQuote());
	}

	public void printEllipsis() {
		print(syntaxHelper.getEllipsis());
	}

	public void printFunctionDef() {
		printStatement("def");
	}

	public void printFunctionMarker() {
		printDoubleDot();
	}

	public void printFunctionMarkerWithSpace() {
		printFunctionMarker();
		printSpace();
	}

	public void printListSeparator() {
		print(syntaxHelper.getListSeparator());
	}

	public void printNewlineAndIndentation() {
		print(syntaxHelper.getNewLine());
		print(syntaxHelper.getAlignment());
	}

	public void printNum(Num node) {
		print(node.num);
	}

	protected void printSingleQuote() {
		print(syntaxHelper.getSingleQuote());
	}

	protected void printSpace() {
		print(syntaxHelper.getSpace());
	}

	protected void printStatement(String statement) {
		printStatement(statement, false, true);
	}

	protected void printStatement(String statement, boolean spaceBefore, boolean spaceAfter) {
		if (spaceBefore)
			print(syntaxHelper.beforeStatement());
		print(statement);
		if (spaceAfter)
			print(syntaxHelper.afterStatement());
	}

	public void printStatementAs() {
		printStatement("as", true, true);
	}

	public void printStatementAssert() {
		printStatement("assert");

	}

	public void printStatementBreak() {
		print("break");
	}

	public void printStatementDel() {
		printStatement("del");
	}

	public void printStatementElif() {
		printStatement("elif");

	}

	public void printStatementElse() {
		print("else");
	}

	public void printStatementElseWithSpace() {
		printSpace();
		printStatementElse();
		printSpace();
	}

	public void printStatementExcept(boolean spaceAfter) {
		printStatement("except", false, spaceAfter);
	}

	public void printStatementExec() {
		printStatement("exec");
	}

	public void printStatementFinally() {
		print("finally");
	}

	public void printStatementFor(boolean spaceBefore, boolean spaceAfter) {
		printStatement("for", spaceBefore, spaceAfter);
	}

	public void printStatementFrom() {
		printStatement("from", false, true);
	}

	public void printStatementFromImport() {
		printStatement("import", true, true);
	}

	public void printStatementGlobal() {
		printStatement("global");
	}

	public void printStatementIf(SimpleNode node, boolean spaceBefore, boolean spaceAfter) {
		if (!isDisabledIfPrinting()){
			printStatement("if", spaceBefore, spaceAfter);
		}else{
			
			if(node != null){
    	        for(Object o:node.specialsBefore){
    	            if(o instanceof SpecialStr){
    	                SpecialStr specialStr = (SpecialStr) o;
    	                if(specialStr.str.trim().equals("if")){
    	                    printStatement("if", spaceBefore, spaceAfter);
    	                    return;
    	                }
    	            }
    	        }
			}
			
			setDisabledIfPrinting(false);
		}
	}

	public void printStatementImport() {
		printStatement("import");
	}

	public void printStatementIn() {
		printStatement("in", true, true);
	}

	public void printstatementLambda() {
		printStatement("lambda");
	}

	public void printStatementPass() {
		printStatement("pass", false, false);
	}

	public void printStatementPrint() {
		printStatement("print");
	}

	public void printStatementRaise(boolean spaceAfter) {
		printStatement("raise", false, spaceAfter);
	}

	public void printStatementReturn() {
		printStatement("return");
	}

	public void printStatementTry() {
		print("try");
	}

	public void printStatementWhile() {
		printStatement("while");
	}

	public void printStatementWith() {
		printStatement("with");
	}

	public void printStatementYield() {
		printStatement("yield");
	}

	public void printStr(Str node) {
		if (node.unicode)
			print("u");
		// u and r don't exclude themself (but u before r)
		if (node.raw)
			print("r");
		printStrQuote(node);
		print(node.s);
		printStrQuote(node);
	}

	public void printStrQuote(Str node) {
		switch (node.type) {
		case (str_typeType.SingleDouble):
			printDoubleQuote();
			break;
		case (str_typeType.SingleSingle):
			printSingleQuote();
			break;
		case (str_typeType.TripleDouble):
			printTripeDoubleQuote();
			break;
		case (str_typeType.TripleSingle):
			printTripeSingleQuote();
			break;
		}
	}

	public void printTripeDoubleQuote() {
		for (int i = 0; i < 3; i++)
			printDoubleQuote();
	}

	public void printTripeSingleQuote() {
		for (int i = 0; i < 3; i++)
			printSingleQuote();
	}

	public void printUnaryOp(int opType) {
		String op;

		switch (opType) {
		case unaryopType.Invert:
			op = syntaxHelper.getOperatorInvert();
			break;
		case unaryopType.Not:
			op = syntaxHelper.getOperatorNot();
			break;
		case unaryopType.UAdd:
			op = syntaxHelper.getOperatorUAdd();
			break;
		case unaryopType.USub:
			op = syntaxHelper.getOperatorUSub();
			break;
		default:
			op = "<undef_unaryop>";
			break;
		}

		print(op);
		if (opType == unaryopType.Not)
			printSpace();

	}

	public void setDisabledIfPrinting(boolean disabledIfPrinting) {
		this.disabledIfPrinting = disabledIfPrinting;
	}

	public void setIgnoreComments(boolean ignoreComments) {
		this.ignoreComments = ignoreComments;
	}

	public void printReprQuote() {
		print(syntaxHelper.getReprQuote());
	}

	public NodeHelper getNodeHelper() {
		return this.nodeHelper;
	}

	public boolean hasSpecialBefore(SimpleNode n, String match) {
		if (n == null)
			return false;
		return checkSpecialStr(n.getSpecialsBefore(), match);
	}

	public boolean hasSpecialAfter(SimpleNode n, String match) {
		if (n == null)
			return false;
		return checkSpecialStr(n.getSpecialsAfter(), match);
	}

	public boolean checkSpecialStr(List<Object> specials, String pattern) {
		for (Object object : specials) {
			if (object instanceof SpecialStr) {
				SpecialStr str = (SpecialStr) object;
				return (str.str.compareTo(pattern) == 0);

			} else if (object instanceof String) {
				String text = (String) object;
				return (text.compareTo(pattern) == 0);
			}
		}
		return false;
	}

	public void openParentheses(SimpleNode n) {
		if (needsParentheses(n)) {
			printBeforeTuple();
		}
	}

	public void closeParentheses(SimpleNode n) {
		if (needsParentheses(n)) {
			printAfterTuple();
		}
	}

	protected boolean needsParentheses(SimpleNode n) {
		return (inCall() || hasParentheses(n));
	}

	protected boolean needsBracket(SimpleNode n) {
		return (hasBracket(n) || nodeHelper.isList(n));
	}

	protected boolean hasParentheses(SimpleNode n) {
		return hasSpecialBefore(n, getSyntaxhelper().beforeTuple());
	}

	boolean hasBracket(SimpleNode n) {
		return hasSpecialBefore(n, getSyntaxhelper().beforeList());
	}

	public void closeBracket(SimpleNode n) {
		if (needsBracket(n)) {
			printAfterList();
		}
	}

	public void openBracket(SimpleNode n) {
		if (needsBracket(n)) {
			printBeforeList();
		}
	}

	public CallDepth getCallDepth() {
		return callDepth;
	}

	public void enterCall() {
		callDepth.enterCall();
	}

	public void leaveCall() {
		callDepth.leaveCall();
	}

	public boolean inCall() {
		return callDepth.inCall();
	}

}