rewritervisitor.java

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

	}

	private void handleTryBody(stmtType node, stmtType[] body) throws Exception {
		if (!printer.getNodeHelper().isTryStatement(node))
			return;

		printer.printStatementTry();
		printer.printFunctionMarker();
		printer.indent();
		if (isFilledList(body))
			handleCommentBeforeBody(node, body[0]);

		printer.printNewlineAndIndentation();

		if (isFilledList(body)) {
			handleCommentAfterBody(node, visit(node, body));
		}
	}

	private SimpleNode handleVarArgs(argumentsType arguments, SimpleNode lastNode) throws Exception {
		if (arguments.vararg != null) {
			if (lastNode != null)
				printer.printListSeparator();
			printer.printBeforeVarArg();
			super.visit(arguments.vararg);
			lastNode = arguments.vararg;

			if (handleCommaOptional(lastNode) && arguments.kwarg == null)
				printer.printListSeparator();
		}
		return lastNode;
	}

	public boolean isEmptyList(SimpleNode[] list) {
		return printer.getNodeHelper().isEmptyList(list);
	}

	public boolean isFilledList(SimpleNode[] list) {
		return printer.getNodeHelper().isFilledList(list);
	}

	private SimpleNode[] reverseNodeArray(SimpleNode[] expressions) {
		java.util.List<SimpleNode> ifs = Arrays.asList(expressions);
		Collections.reverse(ifs);
		SimpleNode[] ifsInOrder = ifs.toArray(new SimpleNode[0]);
		return ifsInOrder;
	}

	protected void visit(decoratorsType[] decs) throws Exception {
		if (decs == null)
			return;
		java.util.List<decoratorsType> stmts = Arrays.asList(decs);

		for (Iterator<decoratorsType> iter = stmts.iterator(); iter.hasNext();) {
			decoratorsType node = iter.next();

			visitDecoratorsType(node);

		}
	}

	@Override
	public SimpleNode visit(SimpleNode node) throws Exception {
		SimpleNode lastNode = null;

		handleBeforeNode(node);
		handleCommentBefore(node);
		lastNode = super.visitNode(node);
		handleCommentAfter(node);
		handleAfterNode(node);

		return lastNode;
	}

	private SimpleNode visit(SimpleNode node, SimpleNode[] body) throws Exception {
		return visit(node, body, true, false);
	}

	private SimpleNode visit(SimpleNode parent, SimpleNode[] list, boolean outdent, boolean separator) throws Exception {
		if (list == null)
			return null;
		SimpleNode lastNode = null;
		java.util.List<SimpleNode> nodes = Arrays.asList(list);
		for (Iterator<SimpleNode> iter = nodes.iterator(); iter.hasNext();) {
			lastNode = iter.next();

			handlePreNode(parent, lastNode, nodes);

			super.visit(lastNode);

			handlePostNode(parent, lastNode, iter, outdent, separator);

		}
		return lastNode;
	}

	public Object visitAliasType(aliasType node) throws Exception {
		SimpleNode lastNode = super.visit(node.name);
		if (node.asname != null) {
			printer.printStatementAs();
			super.visit(node.asname);
			lastNode = node.asname;
		}
		handleCommentAfter(lastNode);

		return lastNode;
	}

	public Object visitArgumentsType(argumentsType node) throws Exception {
		SimpleNode lastNode = handleFunctionArgs(getPreviousNode(), node);
		return lastNode;
	}

	public Object visitAssert(Assert node) throws Exception {
		handleCommentBefore(node.test);
		printer.printStatementAssert();
		super.visit(node.test);
		if (node.msg != null) {
			printer.printListSeparator();
			visit(node.msg);
			handleCommentAfter(node.msg);
		} else
			handleCommentAfter(node.test);

		return null;
	}

	public Object visitAssign(Assign node) throws Exception {
		visitWithSeparator(node, node.targets);
		printer.printAssignmentOperator(!inCall(), !inCall());
		visit(node.value);
		return null;
	}

	public Object visitAttribute(Attribute node) throws Exception {
		visit(node.value);
		printer.printAttributeSeparator();
		visit(node.attr);
		return null;
	}

	public Object visitAugAssign(AugAssign node) throws Exception {
		visit(node.target);
		printer.printBinOp(node.op, true, false);
		printer.printAssignmentOperator(false, true);
		visit(node.value);

		return null;

	}

	public Object visitBinOp(BinOp node) throws Exception {
		if ((node.left != null) && (node.right != null)) {
			visit(node.left);
			printer.printBinOp(node.op, true, true);
			visit(node.right);
		}
		return null;
	}

	public Object visitBoolOp(BoolOp node) throws Exception {
		visitWithSeparator(node, node.values);
		return null;
	}

	public Object visitBreak(Break node) throws Exception {
		printer.printStatementBreak();
		return null;
	}

	public Object visitCall(Call node) throws Exception {
		visit(node.func);
		enterCall();
		printer.openParentheses(node);
		handleCallArguments(node);
		printer.closeParentheses(node);
		leaveCall();

		return null;

	}

	public Object visitClassDef(ClassDef node) throws Exception {
		SimpleNode lastNode = null;

		printer.printClassDef();
		super.visit(node.name);

		printer.setIgnoreComments(true);
		if (isFilledList(node.bases)) {
			printer.printBeforeTuple();
			lastNode = visitWithSeparator(node, node.bases);
			printer.printAfterTuple();
		}
		printer.setIgnoreComments(false);

		printer.indent();

		printer.printFunctionMarker();

		if (lastNode == null) {
			handleCommentAfter(node.name);
		} else {
			handleCommentAfter(lastNode);
		}
		printer.printNewlineAndIndentation();

		visit(node, node.body);

		return null;
	}

	public Object visitCompare(Compare node) throws Exception {
		visit(node.left);
		for (int i = 0; i < node.ops.length; i++) {
			printer.printBeforeAndAfterCmpOp();
			printer.printCompOp(node.ops[i]);
			printer.printBeforeAndAfterCmpOp();
			visit(node.comparators[i]);

		}
		return null;
	}

	public Object visitComprehension(Comprehension node) throws Exception {
		printer.printStatementFor(true, true);
		super.visit(node.target);
		printer.printStatementIn();
		super.visit(node.iter);
		if (isFilledList(node.ifs)) {
			printer.indent();
			visit(node, reverseNodeArray(node.ifs));
		}

		return null;
	}

	public Object visitContinue(Continue node) throws Exception {
		printer.printContinue();
		return null;
	}

	public Object visitDecoratorsType(decoratorsType node) throws Exception {
		if (node == null)
			return null;

		printer.printBeforeDecorator();
		super.visit(node.func);

		SimpleNode lastNode = handleDecoratorArgs(node);

		if (lastNode == null) {
			handleCommentAfter(node.func);
		} else {
			handleCommentAfter(lastNode);
		}
		printer.printNewlineAndIndentation();

		return lastNode;
	}

	public Object visitDelete(Delete node) throws Exception {
		printer.printStatementDel();
		visitWithSeparator(node, node.targets);
		return null;
	}

	public Object visitDict(Dict node) throws Exception {
		printer.printBeforeDict();
		SimpleNode lastNode = visitKeyValue(node, node.keys, node.values);
		printer.printAfterDict();
		handleCommentAfter(lastNode);

		return null;
	}

	public Object visitEllipsis(Ellipsis node) throws Exception {
		printer.printEllipsis();
		return null;
	}

	public Object visitExceptHandlerType(excepthandlerType node) throws Exception {
		printer.printStatementExcept(node.type != null);
		super.visit(node.type);
		if (node.name != null) {
			printer.printListSeparator();
			super.visit(node.name);
		}
		printer.printFunctionMarker();
		printer.indent();

		if (isFilledList(node.body))
			handleCommentBeforeBody(node.type, node.body[0]);

		printer.printNewlineAndIndentation();
		SimpleNode lastNode = visit(node, node.body);

		if (isFilledList(node.body))
			handleCommentAfterBody(node, lastNode);
		return null;

	}

	private void visitExceptionHandlers(TryExcept node) throws Exception {
		if (node.handlers != null) {
			for (int i = 0; i < node.handlers.length; i++) {
				printer.printNewlineAndIndentation();
				visitExceptHandlerType(node.handlers[i]);
			}

		}
	}

	public Object visitExec(Exec node) throws Exception {
		printer.printStatementExec();
		visit(node.body);
		if (node.globals != null) {
			printer.printStatementIn();
			visit(node.globals);
			if (node.locals != null) {
				printer.printListSeparator();
				visit(node.locals);
			}
		}

		return null;
	}

	public Object visitExpr(Expr node) throws Exception {
		visit(node.value);
		return null;
	}

	public Object visitExpression(Expression node) throws Exception {
		visit(node.body);
		return null;
	}

	public Object visitExtSlice(ExtSlice node) throws Exception {
		visitWithSeparator(node, node.dims);
		return null;
	}

	public Object visitFor(For node) throws Exception {
		handleCommentBefore(node.target);
		printer.printStatementFor(false, true);
		printer.openParentheses(node);
		super.visit(node.target);
		printer.closeParentheses(node);
		printer.printStatementIn();
		super.visit(node.iter);
		printer.printFunctionMarker();
		handleCommentAfter(node.iter);

		printer.indent();
		printer.printNewlineAndIndentation();
		visit(node, node.body);

		visitSuiteType(node.orelse);

		return null;

	}

	public Object visitFunctionDef(FunctionDef node) throws Exception {

		SimpleNode lastNode = null;

		visit(node.decs);

		handleCommentBefore(node.name);
		printer.printFunctionDef();
		super.visit(node.name);

		enterCall();
		printer.printBeforeTuple();
		this.setPreviousNode(node);
		lastNode = super.visit(node.args);
		this.setPreviousNode(node.name);
		printer.printAfterTuple();

		printer.indent();

		printer.printFunctionMarker();
		leaveCall();

		if (lastNode == null)
			handleCommentAfter(node.name);
		else