jython-checkins

[Finn B. <bc...@us...>]

Update of /cvsroot/jython/jython/org/python/parser/ast
In directory usw-pr-cvs1:/tmp/cvs-serv12231

Added Files:
	Assert.java Assign.java Attribute.java AugAssign.java 
	BinOp.java BoolOp.java Break.java Call.java ClassDef.java 
	Compare.java Continue.java Delete.java Dict.java Ellipsis.java 
	Exec.java Expr.java Expression.java ExtSlice.java For.java 
	FunctionDef.java Global.java If.java Import.java 
	ImportFrom.java Index.java Interactive.java Lambda.java 
	List.java ListComp.java Module.java Name.java Num.java 
	Pass.java Print.java Raise.java Repr.java Return.java 
	Slice.java Str.java Subscript.java Suite.java TryExcept.java 
	TryFinally.java Tuple.java UnaryOp.java VisitorBase.java 
	VisitorIF.java While.java Yield.java aliasType.java 
	argumentsType.java boolopType.java cmpopType.java 
	excepthandlerType.java exprType.java expr_contextType.java 
	keywordType.java listcompType.java modType.java 
	operatorType.java sliceType.java stmtType.java 
	unaryopType.java 
Log Message:
AST nodes generated from python.asdl. Python.asdl is currently located
in CPython's nondist/sandbox/ast.



--- NEW FILE: Assert.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Assert extends stmtType {
    public exprType test;
    public exprType msg;

    public Assert(exprType test, exprType msg) {
        this.test = test;
        this.msg = msg;
    }

    public Assert(exprType test, exprType msg, SimpleNode parent) {
        this(test, msg);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Assert[");
        sb.append("test=");
        sb.append(dumpThis(this.test));
        sb.append(", ");
        sb.append("msg=");
        sb.append(dumpThis(this.msg));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(19, ostream);
        pickleThis(this.test, ostream);
        pickleThis(this.msg, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitAssert(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (test != null)
            test.accept(visitor);
        if (msg != null)
            msg.accept(visitor);
    }

}

--- NEW FILE: Assign.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Assign extends stmtType {
    public exprType[] targets;
    public exprType value;

    public Assign(exprType[] targets, exprType value) {
        this.targets = targets;
        this.value = value;
    }

    public Assign(exprType[] targets, exprType value, SimpleNode parent) {
        this(targets, value);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Assign[");
        sb.append("targets=");
        sb.append(dumpThis(this.targets));
        sb.append(", ");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(10, ostream);
        pickleThis(this.targets, ostream);
        pickleThis(this.value, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitAssign(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (targets != null) {
            for (int i = 0; i < targets.length; i++) {
                if (targets[i] != null)
                    targets[i].accept(visitor);
            }
        }
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: Attribute.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Attribute extends exprType implements expr_contextType {
    public exprType value;
    public String attr;
    public int ctx;

    public Attribute(exprType value, String attr, int ctx) {
        this.value = value;
        this.attr = attr;
        this.ctx = ctx;
    }

    public Attribute(exprType value, String attr, int ctx, SimpleNode
    parent) {
        this(value, attr, ctx);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Attribute[");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append(", ");
        sb.append("attr=");
        sb.append(dumpThis(this.attr));
        sb.append(", ");
        sb.append("ctx=");
        sb.append(dumpThis(this.ctx,
        expr_contextType.expr_contextTypeNames));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(39, ostream);
        pickleThis(this.value, ostream);
        pickleThis(this.attr, ostream);
        pickleThis(this.ctx, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitAttribute(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: AugAssign.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class AugAssign extends stmtType implements operatorType {
    public exprType target;
    public int op;
    public exprType value;

    public AugAssign(exprType target, int op, exprType value) {
        this.target = target;
        this.op = op;
        this.value = value;
    }

    public AugAssign(exprType target, int op, exprType value, SimpleNode
    parent) {
        this(target, op, value);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("AugAssign[");
        sb.append("target=");
        sb.append(dumpThis(this.target));
        sb.append(", ");
        sb.append("op=");
        sb.append(dumpThis(this.op, operatorType.operatorTypeNames));
        sb.append(", ");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(11, ostream);
        pickleThis(this.target, ostream);
        pickleThis(this.op, ostream);
        pickleThis(this.value, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitAugAssign(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (target != null)
            target.accept(visitor);
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: BinOp.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class BinOp extends exprType implements operatorType {
    public exprType left;
    public int op;
    public exprType right;

    public BinOp(exprType left, int op, exprType right) {
        this.left = left;
        this.op = op;
        this.right = right;
    }

    public BinOp(exprType left, int op, exprType right, SimpleNode parent) {
        this(left, op, right);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("BinOp[");
        sb.append("left=");
        sb.append(dumpThis(this.left));
        sb.append(", ");
        sb.append("op=");
        sb.append(dumpThis(this.op, operatorType.operatorTypeNames));
        sb.append(", ");
        sb.append("right=");
        sb.append(dumpThis(this.right));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(29, ostream);
        pickleThis(this.left, ostream);
        pickleThis(this.op, ostream);
        pickleThis(this.right, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitBinOp(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (left != null)
            left.accept(visitor);
        if (right != null)
            right.accept(visitor);
    }

}

--- NEW FILE: BoolOp.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class BoolOp extends exprType implements boolopType {
    public int op;
    public exprType[] values;

    public BoolOp(int op, exprType[] values) {
        this.op = op;
        this.values = values;
    }

    public BoolOp(int op, exprType[] values, SimpleNode parent) {
        this(op, values);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("BoolOp[");
        sb.append("op=");
        sb.append(dumpThis(this.op, boolopType.boolopTypeNames));
        sb.append(", ");
        sb.append("values=");
        sb.append(dumpThis(this.values));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(28, ostream);
        pickleThis(this.op, ostream);
        pickleThis(this.values, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitBoolOp(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (values != null) {
            for (int i = 0; i < values.length; i++) {
                if (values[i] != null)
                    values[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Break.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Break extends stmtType {

    public Break() {
    }

    public Break(SimpleNode parent) {
        this();
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Break[");
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(26, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitBreak(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Call.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Call extends exprType {
    public exprType func;
    public exprType[] args;
    public keywordType[] keywords;
    public exprType starargs;
    public exprType kwargs;

    public Call(exprType func, exprType[] args, keywordType[] keywords,
    exprType starargs, exprType kwargs) {
        this.func = func;
        this.args = args;
        this.keywords = keywords;
        this.starargs = starargs;
        this.kwargs = kwargs;
    }

    public Call(exprType func, exprType[] args, keywordType[] keywords,
    exprType starargs, exprType kwargs, SimpleNode parent) {
        this(func, args, keywords, starargs, kwargs);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Call[");
        sb.append("func=");
        sb.append(dumpThis(this.func));
        sb.append(", ");
        sb.append("args=");
        sb.append(dumpThis(this.args));
        sb.append(", ");
        sb.append("keywords=");
        sb.append(dumpThis(this.keywords));
        sb.append(", ");
        sb.append("starargs=");
        sb.append(dumpThis(this.starargs));
        sb.append(", ");
        sb.append("kwargs=");
        sb.append(dumpThis(this.kwargs));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(35, ostream);
        pickleThis(this.func, ostream);
        pickleThis(this.args, ostream);
        pickleThis(this.keywords, ostream);
        pickleThis(this.starargs, ostream);
        pickleThis(this.kwargs, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitCall(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (func != null)
            func.accept(visitor);
        if (args != null) {
            for (int i = 0; i < args.length; i++) {
                if (args[i] != null)
                    args[i].accept(visitor);
            }
        }
        if (keywords != null) {
            for (int i = 0; i < keywords.length; i++) {
                if (keywords[i] != null)
                    keywords[i].accept(visitor);
            }
        }
        if (starargs != null)
            starargs.accept(visitor);
        if (kwargs != null)
            kwargs.accept(visitor);
    }

}

--- NEW FILE: ClassDef.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class ClassDef extends stmtType {
    public String name;
    public exprType[] bases;
    public stmtType[] body;

    public ClassDef(String name, exprType[] bases, stmtType[] body) {
        this.name = name;
        this.bases = bases;
        this.body = body;
    }

    public ClassDef(String name, exprType[] bases, stmtType[] body,
    SimpleNode parent) {
        this(name, bases, body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("ClassDef[");
        sb.append("name=");
        sb.append(dumpThis(this.name));
        sb.append(", ");
        sb.append("bases=");
        sb.append(dumpThis(this.bases));
        sb.append(", ");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(6, ostream);
        pickleThis(this.name, ostream);
        pickleThis(this.bases, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitClassDef(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (bases != null) {
            for (int i = 0; i < bases.length; i++) {
                if (bases[i] != null)
                    bases[i].accept(visitor);
            }
        }
        if (body != null) {
            for (int i = 0; i < body.length; i++) {
                if (body[i] != null)
                    body[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Compare.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Compare extends exprType implements cmpopType {
    public exprType left;
    public int[] ops;
    public exprType[] comparators;

    public Compare(exprType left, int[] ops, exprType[] comparators) {
        this.left = left;
        this.ops = ops;
        this.comparators = comparators;
    }

    public Compare(exprType left, int[] ops, exprType[] comparators,
    SimpleNode parent) {
        this(left, ops, comparators);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Compare[");
        sb.append("left=");
        sb.append(dumpThis(this.left));
        sb.append(", ");
        sb.append("ops=");
        sb.append(dumpThis(this.ops, cmpopType.cmpopTypeNames));
        sb.append(", ");
        sb.append("comparators=");
        sb.append(dumpThis(this.comparators));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(34, ostream);
        pickleThis(this.left, ostream);
        pickleThis(this.ops, ostream);
        pickleThis(this.comparators, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitCompare(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (left != null)
            left.accept(visitor);
        if (comparators != null) {
            for (int i = 0; i < comparators.length; i++) {
                if (comparators[i] != null)
                    comparators[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Continue.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Continue extends stmtType {

    public Continue() {
    }

    public Continue(SimpleNode parent) {
        this();
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Continue[");
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(27, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitContinue(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Delete.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Delete extends stmtType {
    public exprType[] targets;

    public Delete(exprType[] targets) {
        this.targets = targets;
    }

    public Delete(exprType[] targets, SimpleNode parent) {
        this(targets);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Delete[");
        sb.append("targets=");
        sb.append(dumpThis(this.targets));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(9, ostream);
        pickleThis(this.targets, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitDelete(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (targets != null) {
            for (int i = 0; i < targets.length; i++) {
                if (targets[i] != null)
                    targets[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Dict.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Dict extends exprType {
    public exprType[] keys;
    public exprType[] values;

    public Dict(exprType[] keys, exprType[] values) {
        this.keys = keys;
        this.values = values;
    }

    public Dict(exprType[] keys, exprType[] values, SimpleNode parent) {
        this(keys, values);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Dict[");
        sb.append("keys=");
        sb.append(dumpThis(this.keys));
        sb.append(", ");
        sb.append("values=");
        sb.append(dumpThis(this.values));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(32, ostream);
        pickleThis(this.keys, ostream);
        pickleThis(this.values, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitDict(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (keys != null) {
            for (int i = 0; i < keys.length; i++) {
                if (keys[i] != null)
                    keys[i].accept(visitor);
            }
        }
        if (values != null) {
            for (int i = 0; i < values.length; i++) {
                if (values[i] != null)
                    values[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Ellipsis.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Ellipsis extends sliceType {

    public Ellipsis() {
    }

    public Ellipsis(SimpleNode parent) {
        this();
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Ellipsis[");
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(44, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitEllipsis(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Exec.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Exec extends stmtType {
    public exprType body;
    public exprType globals;
    public exprType locals;

    public Exec(exprType body, exprType globals, exprType locals) {
        this.body = body;
        this.globals = globals;
        this.locals = locals;
    }

    public Exec(exprType body, exprType globals, exprType locals,
    SimpleNode parent) {
        this(body, globals, locals);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Exec[");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append(", ");
        sb.append("globals=");
        sb.append(dumpThis(this.globals));
        sb.append(", ");
        sb.append("locals=");
        sb.append(dumpThis(this.locals));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(22, ostream);
        pickleThis(this.body, ostream);
        pickleThis(this.globals, ostream);
        pickleThis(this.locals, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitExec(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (body != null)
            body.accept(visitor);
        if (globals != null)
            globals.accept(visitor);
        if (locals != null)
            locals.accept(visitor);
    }

}

--- NEW FILE: Expr.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Expr extends stmtType {
    public exprType value;

    public Expr(exprType value) {
        this.value = value;
    }

    public Expr(exprType value, SimpleNode parent) {
        this(value);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Expr[");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(24, ostream);
        pickleThis(this.value, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitExpr(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: Expression.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Expression extends modType {
    public exprType body;

    public Expression(exprType body) {
        this.body = body;
    }

    public Expression(exprType body, SimpleNode parent) {
        this(body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Expression[");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(3, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitExpression(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (body != null)
            body.accept(visitor);
    }

}

--- NEW FILE: ExtSlice.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class ExtSlice extends sliceType {
    public sliceType[] dims;

    public ExtSlice(sliceType[] dims) {
        this.dims = dims;
    }

    public ExtSlice(sliceType[] dims, SimpleNode parent) {
        this(dims);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("ExtSlice[");
        sb.append("dims=");
        sb.append(dumpThis(this.dims));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(46, ostream);
        pickleThis(this.dims, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitExtSlice(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (dims != null) {
            for (int i = 0; i < dims.length; i++) {
                if (dims[i] != null)
                    dims[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: For.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class For extends stmtType {
    public exprType target;
    public exprType iter;
    public stmtType[] body;
    public stmtType[] orelse;

    public For(exprType target, exprType iter, stmtType[] body, stmtType[]
    orelse) {
        this.target = target;
        this.iter = iter;
        this.body = body;
        this.orelse = orelse;
    }

    public For(exprType target, exprType iter, stmtType[] body, stmtType[]
    orelse, SimpleNode parent) {
        this(target, iter, body, orelse);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("For[");
        sb.append("target=");
        sb.append(dumpThis(this.target));
        sb.append(", ");
        sb.append("iter=");
        sb.append(dumpThis(this.iter));
        sb.append(", ");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append(", ");
        sb.append("orelse=");
        sb.append(dumpThis(this.orelse));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(13, ostream);
        pickleThis(this.target, ostream);
        pickleThis(this.iter, ostream);
        pickleThis(this.body, ostream);
        pickleThis(this.orelse, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitFor(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (target != null)
            target.accept(visitor);
        if (iter != null)
            iter.accept(visitor);
        if (body != null) {
            for (int i = 0; i < body.length; i++) {
                if (body[i] != null)
                    body[i].accept(visitor);
            }
        }
        if (orelse != null) {
            for (int i = 0; i < orelse.length; i++) {
                if (orelse[i] != null)
                    orelse[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: FunctionDef.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class FunctionDef extends stmtType {
    public String name;
    public argumentsType args;
    public stmtType[] body;

    public FunctionDef(String name, argumentsType args, stmtType[] body) {
        this.name = name;
        this.args = args;
        this.body = body;
    }

    public FunctionDef(String name, argumentsType args, stmtType[] body,
    SimpleNode parent) {
        this(name, args, body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("FunctionDef[");
        sb.append("name=");
        sb.append(dumpThis(this.name));
        sb.append(", ");
        sb.append("args=");
        sb.append(dumpThis(this.args));
        sb.append(", ");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(5, ostream);
        pickleThis(this.name, ostream);
        pickleThis(this.args, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitFunctionDef(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (args != null)
            args.accept(visitor);
        if (body != null) {
            for (int i = 0; i < body.length; i++) {
                if (body[i] != null)
                    body[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Global.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Global extends stmtType {
    public String[] names;

    public Global(String[] names) {
        this.names = names;
    }

    public Global(String[] names, SimpleNode parent) {
        this(names);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Global[");
        sb.append("names=");
        sb.append(dumpThis(this.names));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(23, ostream);
        pickleThis(this.names, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitGlobal(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: If.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class If extends stmtType {
    public exprType test;
    public stmtType[] body;
    public stmtType[] orelse;

    public If(exprType test, stmtType[] body, stmtType[] orelse) {
        this.test = test;
        this.body = body;
        this.orelse = orelse;
    }

    public If(exprType test, stmtType[] body, stmtType[] orelse, SimpleNode
    parent) {
        this(test, body, orelse);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("If[");
        sb.append("test=");
        sb.append(dumpThis(this.test));
        sb.append(", ");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append(", ");
        sb.append("orelse=");
        sb.append(dumpThis(this.orelse));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(15, ostream);
        pickleThis(this.test, ostream);
        pickleThis(this.body, ostream);
        pickleThis(this.orelse, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitIf(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (test != null)
            test.accept(visitor);
        if (body != null) {
            for (int i = 0; i < body.length; i++) {
                if (body[i] != null)
                    body[i].accept(visitor);
            }
        }
        if (orelse != null) {
            for (int i = 0; i < orelse.length; i++) {
                if (orelse[i] != null)
                    orelse[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Import.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Import extends stmtType {
    public aliasType[] names;

    public Import(aliasType[] names) {
        this.names = names;
    }

    public Import(aliasType[] names, SimpleNode parent) {
        this(names);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Import[");
        sb.append("names=");
        sb.append(dumpThis(this.names));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(20, ostream);
        pickleThis(this.names, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitImport(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (names != null) {
            for (int i = 0; i < names.length; i++) {
                if (names[i] != null)
                    names[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: ImportFrom.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class ImportFrom extends stmtType {
    public String module;
    public aliasType[] names;

    public ImportFrom(String module, aliasType[] names) {
        this.module = module;
        this.names = names;
    }

    public ImportFrom(String module, aliasType[] names, SimpleNode parent) {
        this(module, names);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("ImportFrom[");
        sb.append("module=");
        sb.append(dumpThis(this.module));
        sb.append(", ");
        sb.append("names=");
        sb.append(dumpThis(this.names));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(21, ostream);
        pickleThis(this.module, ostream);
        pickleThis(this.names, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitImportFrom(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (names != null) {
            for (int i = 0; i < names.length; i++) {
                if (names[i] != null)
                    names[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Index.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Index extends sliceType {
    public exprType value;

    public Index(exprType value) {
        this.value = value;
    }

    public Index(exprType value, SimpleNode parent) {
        this(value);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Index[");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(47, ostream);
        pickleThis(this.value, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitIndex(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: Interactive.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Interactive extends modType {
    public stmtType body;

    public Interactive(stmtType body) {
        this.body = body;
    }

    public Interactive(stmtType body, SimpleNode parent) {
        this(body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Interactive[");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(2, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitInteractive(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (body != null)
            body.accept(visitor);
    }

}

--- NEW FILE: Lambda.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Lambda extends exprType {
    public argumentsType args;
    public exprType body;

    public Lambda(argumentsType args, exprType body) {
        this.args = args;
        this.body = body;
    }

    public Lambda(argumentsType args, exprType body, SimpleNode parent) {
        this(args, body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Lambda[");
        sb.append("args=");
        sb.append(dumpThis(this.args));
        sb.append(", ");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(31, ostream);
        pickleThis(this.args, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitLambda(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (args != null)
            args.accept(visitor);
        if (body != null)
            body.accept(visitor);
    }

}

--- NEW FILE: List.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class List extends exprType implements expr_contextType {
    public exprType[] elts;
    public int ctx;

    public List(exprType[] elts, int ctx) {
        this.elts = elts;
        this.ctx = ctx;
    }

    public List(exprType[] elts, int ctx, SimpleNode parent) {
        this(elts, ctx);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("List[");
        sb.append("elts=");
        sb.append(dumpThis(this.elts));
        sb.append(", ");
        sb.append("ctx=");
        sb.append(dumpThis(this.ctx,
        expr_contextType.expr_contextTypeNames));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(42, ostream);
        pickleThis(this.elts, ostream);
        pickleThis(this.ctx, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitList(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (elts != null) {
            for (int i = 0; i < elts.length; i++) {
                if (elts[i] != null)
                    elts[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: ListComp.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class ListComp extends exprType {
    public exprType target;
    public listcompType[] generators;

    public ListComp(exprType target, listcompType[] generators) {
        this.target = target;
        this.generators = generators;
    }

    public ListComp(exprType target, listcompType[] generators, SimpleNode
    parent) {
        this(target, generators);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("ListComp[");
        sb.append("target=");
        sb.append(dumpThis(this.target));
        sb.append(", ");
        sb.append("generators=");
        sb.append(dumpThis(this.generators));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(33, ostream);
        pickleThis(this.target, ostream);
        pickleThis(this.generators, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitListComp(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (target != null)
            target.accept(visitor);
        if (generators != null) {
            for (int i = 0; i < generators.length; i++) {
                if (generators[i] != null)
                    generators[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Module.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Module extends modType {
    public stmtType[] body;

    public Module(stmtType[] body) {
        this.body = body;
    }

    public Module(stmtType[] body, SimpleNode parent) {
        this(body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Module[");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(1, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitModule(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (body != null) {
            for (int i = 0; i < body.length; i++) {
                if (body[i] != null)
                    body[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Name.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Name extends exprType implements expr_contextType {
    public String id;
    public int ctx;

    public Name(String id, int ctx) {
        this.id = id;
        this.ctx = ctx;
    }

    public Name(String id, int ctx, SimpleNode parent) {
        this(id, ctx);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Name[");
        sb.append("id=");
        sb.append(dumpThis(this.id));
        sb.append(", ");
        sb.append("ctx=");
        sb.append(dumpThis(this.ctx,
        expr_contextType.expr_contextTypeNames));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(41, ostream);
        pickleThis(this.id, ostream);
        pickleThis(this.ctx, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitName(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Num.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Num extends exprType {
    public org.python.core.PyObject n;

    public Num(org.python.core.PyObject n) {
        this.n = n;
    }

    public Num(org.python.core.PyObject n, SimpleNode parent) {
        this(n);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Num[");
        sb.append("n=");
        sb.append(dumpThis(this.n));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(37, ostream);
        pickleThis(this.n, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitNum(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Pass.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Pass extends stmtType {

    public Pass() {
    }

    public Pass(SimpleNode parent) {
        this();
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Pass[");
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(25, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitPass(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Print.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Print extends stmtType {
    public exprType dest;
    public exprType[] value;
    public boolean nl;

    public Print(exprType dest, exprType[] value, boolean nl) {
        this.dest = dest;
        this.value = value;
        this.nl = nl;
    }

    public Print(exprType dest, exprType[] value, boolean nl, SimpleNode
    parent) {
        this(dest, value, nl);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Print[");
        sb.append("dest=");
        sb.append(dumpThis(this.dest));
        sb.append(", ");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append(", ");
        sb.append("nl=");
        sb.append(dumpThis(this.nl));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(12, ostream);
        pickleThis(this.dest, ostream);
        pickleThis(this.value, ostream);
        pickleThis(this.nl, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitPrint(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (dest != null)
            dest.accept(visitor);
        if (value != null) {
            for (int i = 0; i < value.length; i++) {
                if (value[i] != null)
                    value[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: Raise.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Raise extends stmtType {
    public exprType type;
    public exprType inst;
    public exprType tback;

    public Raise(exprType type, exprType inst, exprType tback) {
        this.type = type;
        this.inst = inst;
        this.tback = tback;
    }

    public Raise(exprType type, exprType inst, exprType tback, SimpleNode
    parent) {
        this(type, inst, tback);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Raise[");
        sb.append("type=");
        sb.append(dumpThis(this.type));
        sb.append(", ");
        sb.append("inst=");
        sb.append(dumpThis(this.inst));
        sb.append(", ");
        sb.append("tback=");
        sb.append(dumpThis(this.tback));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(16, ostream);
        pickleThis(this.type, ostream);
        pickleThis(this.inst, ostream);
        pickleThis(this.tback, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitRaise(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (type != null)
            type.accept(visitor);
        if (inst != null)
            inst.accept(visitor);
        if (tback != null)
            tback.accept(visitor);
    }

}

--- NEW FILE: Repr.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Repr extends exprType {
    public exprType value;

    public Repr(exprType value) {
        this.value = value;
    }

    public Repr(exprType value, SimpleNode parent) {
        this(value);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Repr[");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(36, ostream);
        pickleThis(this.value, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitRepr(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: Return.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Return extends stmtType {
    public exprType value;

    public Return(exprType value) {
        this.value = value;
    }

    public Return(exprType value, SimpleNode parent) {
        this(value);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Return[");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(7, ostream);
        pickleThis(this.value, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitReturn(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (value != null)
            value.accept(visitor);
    }

}

--- NEW FILE: Slice.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Slice extends sliceType {
    public exprType lower;
    public exprType upper;
    public exprType step;

    public Slice(exprType lower, exprType upper, exprType step) {
        this.lower = lower;
        this.upper = upper;
        this.step = step;
    }

    public Slice(exprType lower, exprType upper, exprType step, SimpleNode
    parent) {
        this(lower, upper, step);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Slice[");
        sb.append("lower=");
        sb.append(dumpThis(this.lower));
        sb.append(", ");
        sb.append("upper=");
        sb.append(dumpThis(this.upper));
        sb.append(", ");
        sb.append("step=");
        sb.append(dumpThis(this.step));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(45, ostream);
        pickleThis(this.lower, ostream);
        pickleThis(this.upper, ostream);
        pickleThis(this.step, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitSlice(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (lower != null)
            lower.accept(visitor);
        if (upper != null)
            upper.accept(visitor);
        if (step != null)
            step.accept(visitor);
    }

}

--- NEW FILE: Str.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Str extends exprType {
    public String s;

    public Str(String s) {
        this.s = s;
    }

    public Str(String s, SimpleNode parent) {
        this(s);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Str[");
        sb.append("s=");
        sb.append(dumpThis(this.s));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(38, ostream);
        pickleThis(this.s, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitStr(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
    }

}

--- NEW FILE: Subscript.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Subscript extends exprType implements expr_contextType {
    public exprType value;
    public sliceType slice;
    public int ctx;

    public Subscript(exprType value, sliceType slice, int ctx) {
        this.value = value;
        this.slice = slice;
        this.ctx = ctx;
    }

    public Subscript(exprType value, sliceType slice, int ctx, SimpleNode
    parent) {
        this(value, slice, ctx);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Subscript[");
        sb.append("value=");
        sb.append(dumpThis(this.value));
        sb.append(", ");
        sb.append("slice=");
        sb.append(dumpThis(this.slice));
        sb.append(", ");
        sb.append("ctx=");
        sb.append(dumpThis(this.ctx,
        expr_contextType.expr_contextTypeNames));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(40, ostream);
        pickleThis(this.value, ostream);
        pickleThis(this.slice, ostream);
        pickleThis(this.ctx, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitSubscript(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (value != null)
            value.accept(visitor);
        if (slice != null)
            slice.accept(visitor);
    }

}

--- NEW FILE: Suite.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class Suite extends modType {
    public stmtType[] body;

    public Suite(stmtType[] body) {
        this.body = body;
    }

    public Suite(stmtType[] body, SimpleNode parent) {
        this(body);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Suite[");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append("]");
        return sb.toString();
    }

    public void pickle(DataOutputStream ostream) throws IOException {
        pickleThis(4, ostream);
        pickleThis(this.body, ostream);
    }

    public Object accept(VisitorIF visitor) throws Exception {
        return visitor.visitSuite(this);
    }

    public void traverse(VisitorIF visitor) throws Exception {
        if (body != null) {
            for (int i = 0; i < body.length; i++) {
                if (body[i] != null)
                    body[i].accept(visitor);
            }
        }
    }

}

--- NEW FILE: TryExcept.java ---
// Autogenerated AST node
package org.python.parser.ast;
import org.python.parser.SimpleNode;
import java.io.DataOutputStream;
import java.io.IOException;

public class TryExcept extends stmtType {
    public stmtType[] body;
    public excepthandlerType[] handlers;
    public stmtType[] orelse;

    public TryExcept(stmtType[] body, excepthandlerType[] handlers,
    stmtType[] orelse) {
        this.body = body;
        this.handlers = handlers;
        this.orelse = orelse;
    }

    public TryExcept(stmtType[] body, excepthandlerType[] handlers,
    stmtType[] orelse, SimpleNode parent) {
        this(body, handlers, orelse);
        this.beginLine = parent.beginLine;
        this.beginColumn = parent.beginColumn;
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("TryExcept[");
        sb.append("body=");
        sb.append(dumpThis(this.body));
        sb.append(", ");
        sb.append("handlers=");
        sb.append(dumpThis(this.handlers));
        sb.append(", ");
        sb.append("orels...
 
[truncated message content]