private static final Object Exit = new Integer(1);

    private static final Object NoExit = null;

    private Module module;

    private Code code;

    private CompilerFlags cflags;

    private int temporary;

    private expr_contextType augmode;

    private int augtmp1;

    private int augtmp2;

    private int augtmp3;

    private int augtmp4;

    private boolean fast_locals, print_results;

    private Map<String, SymInfo> tbl;

    private ScopeInfo my_scope;

    private boolean optimizeGlobals = true;

    private String className;

    private Stack<Label> continueLabels, breakLabels;

    private Stack<ExceptionHandler> exceptionHandlers;

    private Vector<Label> yields = new Vector<Label>();

    /*

     * break/continue finally's level.  This is the lowest level in the

     * exceptionHandlers which should be executed at break or continue.  It is

     * saved/updated/restored when compiling loops.  A similar level for

     * returns is not needed because a new CodeCompiler is used for each

     * PyCode, in other words: each 'function'.  When returning through

     * finally's all the exceptionHandlers are executed.

     */

    private int bcfLevel = 0;

    private int yield_count = 0;

    private Stack<String> stack = new Stack<String>();

    public CodeCompiler(Module module, boolean print_results) {

        this.module = module;

        this.print_results = print_results;

        continueLabels = new Stack<Label>();

        breakLabels = new Stack<Label>();

        exceptionHandlers = new Stack<ExceptionHandler>();

    }

    public void getNone() throws IOException {

        code.getstatic(p(Py.class), "None", ci(PyObject.class));

    }

    public void loadFrame() throws Exception {

        code.aload(1);

    }

    public void loadThreadState() throws Exception {

        code.aload(2);

    }

    public void setLastI(int idx) throws Exception {

        loadFrame();

        code.iconst(idx);

        code.putfield(p(PyFrame.class), "f_lasti", "I");

    }

    private void loadf_back() throws Exception {

        code.getfield(p(PyFrame.class), "f_back", ci(PyFrame.class));

    }

    public int storeTop() throws Exception {

        int tmp = code.getLocal(p(PyObject.class));

        code.astore(tmp);

        return tmp;

    }

    public void setline(int line) throws Exception {

        if (module.linenumbers) {

            code.setline(line);

            loadFrame();

            code.iconst(line);

            code.invokevirtual(p(PyFrame.class), "setline", sig(Void.TYPE, Integer.TYPE));

        }

    }

    public void setline(PythonTree node) throws Exception {

        setline(node.getLine());

    }

    public void set(PythonTree node) throws Exception {

        int tmp = storeTop();

        set(node, tmp);

        code.aconst_null();

        code.astore(tmp);

        code.freeLocal(tmp);

    }

    public void set(PythonTree node, int tmp) throws Exception {

        temporary = tmp;

        visit(node);

    }

    private void saveAugTmps(PythonTree node, int count) throws Exception {

        if (count >= 4) {

            augtmp4 = code.getLocal(ci(PyObject.class));

            code.astore(augtmp4);

        }

        if (count >= 3) {

            augtmp3 = code.getLocal(ci(PyObject.class));

            code.astore(augtmp3);

        }

        if (count >= 2) {

            augtmp2 = code.getLocal(ci(PyObject.class));

            code.astore(augtmp2);

        }

        augtmp1 = code.getLocal(ci(PyObject.class));

        code.astore(augtmp1);

        code.aload(augtmp1);

        if (count >= 2) {

            code.aload(augtmp2);

        }

        if (count >= 3) {

            code.aload(augtmp3);

        }

        if (count >= 4) {

            code.aload(augtmp4);

        }

    }

    private void restoreAugTmps(PythonTree node, int count) throws Exception {

        code.aload(augtmp1);

        code.freeLocal(augtmp1);

        if (count == 1) {

            return;

        }

        code.aload(augtmp2);

        code.freeLocal(augtmp2);

        if (count == 2) {

            return;

        }

        code.aload(augtmp3);

        code.freeLocal(augtmp3);

        if (count == 3) {

            return;

        }

        code.aload(augtmp4);

        code.freeLocal(augtmp4);

    }

    static boolean checkOptimizeGlobals(boolean fast_locals, ScopeInfo scope) {

        return fast_locals && !scope.exec && !scope.from_import_star;

    }

    void parse(mod node, Code code, boolean fast_locals, String className, Str classDoc,

               boolean classBody, ScopeInfo scope, CompilerFlags cflags) throws Exception {

        this.fast_locals = fast_locals;

        this.className = className;

        this.code = code;

        this.cflags = cflags;

        this.my_scope = scope;

        this.tbl = scope.tbl;

        //BEGIN preparse

        if (classBody) {

            // Set the class's __module__ to __name__. fails when there's no __name__

            loadFrame();

            code.ldc("__module__");

            loadFrame();

            code.ldc("__name__");

            code.invokevirtual(p(PyFrame.class), "getname", sig(PyObject.class, String.class));

            code.invokevirtual(p(PyFrame.class), "setlocal", sig(Void.TYPE, String.class,

                                                                 PyObject.class));

            if (classDoc != null) {

                loadFrame();

                code.ldc("__doc__");

                visit(classDoc);

                code.invokevirtual(p(PyFrame.class), "setlocal", sig(Void.TYPE, String.class,

                                                                     PyObject.class));

            }

        }

        Label genswitch = new Label();

        if (my_scope.generator) {

            code.goto_(genswitch);

        }

        Label start = new Label();

        code.label(start);

        int nparamcell = my_scope.jy_paramcells.size();

        if (nparamcell > 0) {

            java.util.List<String> paramcells = my_scope.jy_paramcells;

            for (int i = 0; i < nparamcell; i++) {

                code.aload(1);

                SymInfo syminf = tbl.get(paramcells.get(i));

                code.iconst(syminf.locals_index);

                code.iconst(syminf.env_index);

                code.invokevirtual(p(PyFrame.class), "to_cell", sig(Void.TYPE, Integer.TYPE,

                        Integer.TYPE));

            }

        }

        //END preparse

        optimizeGlobals = checkOptimizeGlobals(fast_locals, my_scope);

        if (my_scope.max_with_count > 0) {

            // allocate for all the with-exits we will have in the frame;

            // this allows yield and with to happily co-exist

            loadFrame();

            code.iconst(my_scope.max_with_count);

            code.anewarray(p(PyObject.class));

            code.putfield(p(PyFrame.class), "f_exits", ci(PyObject[].class));

        }

        Object exit = visit(node);

        if (classBody) {

            loadFrame();

            code.invokevirtual(p(PyFrame.class), "getf_locals", sig(PyObject.class));

            code.areturn();

        } else {

            if (exit == null) {

                setLastI(-1);

                getNone();

                code.areturn();

            }

        }

        //BEGIN postparse

        // similar to visitResume code in pyasm.py

        if (my_scope.generator) {

            code.label(genswitch);

            code.aload(1);

            code.getfield(p(PyFrame.class), "f_lasti", "I");

            Label[] y = new Label[yields.size() + 1];

            y[0] = start;

            for (int i = 1; i < y.length; i++) {

                y[i] = yields.get(i - 1);

            }

            code.tableswitch(0, y.length - 1, start, y);

        }

        //END postparse

    }

    @Override

    public Object visitInteractive(Interactive node) throws Exception {

        traverse(node);

        return null;

    }

    @Override

    public Object visitModule(org.python.antlr.ast.Module suite) throws Exception {

        Str docStr = getDocStr(suite.getInternalBody());

        if (docStr != null) {

            loadFrame();

            code.ldc("__doc__");

            visit(docStr);

            code.invokevirtual(p(PyFrame.class), "setglobal", sig(Void.TYPE, String.class,

                                                                  PyObject.class));

        }

        traverse(suite);

        return null;

    }

    @Override

    public Object visitExpression(Expression node) throws Exception {

        if (my_scope.generator && node.getInternalBody() != null) {

            module.error("'return' with argument inside generator",

                    true, node);

        }

        return visitReturn(new Return(node, node.getInternalBody()), true);

    }

    public int makeArray(java.util.List<? extends PythonTree> nodes) throws Exception {

        // XXX: This should produce an array on the stack (if possible) instead of a local

        // the caller is responsible for freeing.

        int n;

        if (nodes == null) {

            n = 0;

        } else {

            n = nodes.size();

        }

        int array = code.getLocal(ci(PyObject[].class));

        if (n == 0) {

            code.getstatic(p(Py.class), "EmptyObjects", ci(PyObject[].class));

            code.astore(array);

        } else {

            code.iconst(n);

            code.anewarray(p(PyObject.class));

            code.astore(array);

            for (int i = 0; i < n; i++) {

                visit(nodes.get(i));

                code.aload(array);

                code.swap();

                code.iconst(i);

                code.swap();

                code.aastore();

            }

        }

        return array;

    }

    // nulls out an array of references

    public void freeArray(int array) {

        code.aload(array);

        code.aconst_null();

        code.invokestatic(p(Arrays.class), "fill", sig(Void.TYPE, Object[].class, Object.class));

        code.freeLocal(array);

    }

    public void freeArrayRef(int array) {

        code.aconst_null();

        code.astore(array);

        code.freeLocal(array);

    }

    public Str getDocStr(java.util.List<stmt> suite) {

        if (suite.size() > 0) {

            stmt stmt = suite.get(0);

            if (stmt instanceof Expr && ((Expr) stmt).getInternalValue() instanceof Str) {

                return (Str) ((Expr) stmt).getInternalValue();

            }

        }

        return null;

    }

    public boolean makeClosure(ScopeInfo scope) throws Exception {

        if (scope == null || scope.freevars == null) {

            return false;

        }

        int n = scope.freevars.size();

        if (n == 0) {

            return false;

        }

        int tmp = code.getLocal(ci(PyObject[].class));

        code.iconst(n);

        code.anewarray(p(PyObject.class));

        code.astore(tmp);

        Map<String, SymInfo> upTbl = scope.up.tbl;

        for (int i = 0; i < n; i++) {

            code.aload(tmp);

            code.iconst(i);

            loadFrame();

            for (int j = 1; j < scope.distance; j++) {

                loadf_back();

            }

            SymInfo symInfo = upTbl.get(scope.freevars.elementAt(i));

            code.iconst(symInfo.env_index);

            code.invokevirtual(p(PyFrame.class), "getclosure", sig(PyObject.class, Integer.TYPE));

            code.aastore();

        }

        code.aload(tmp);

        code.freeLocal(tmp);

        return true;

    }

    @Override

    public Object visitFunctionDef(FunctionDef node) throws Exception {

        String name = getName(node.getInternalName());

        setline(node);

        ScopeInfo scope = module.getScopeInfo(node);

        // NOTE: this is attached to the constructed PyFunction, so it cannot be nulled out

        // with freeArray, unlike other usages of makeArray here

        int defaults = makeArray(scope.ac.getDefaults());

        code.new_(p(PyFunction.class));

        code.dup();

        loadFrame();

        code.getfield(p(PyFrame.class), "f_globals", ci(PyObject.class));

        code.aload(defaults);

        code.freeLocal(defaults);

        scope.setup_closure();

        scope.dump();

        module.codeConstant(new Suite(node, node.getInternalBody()), name, true,

                className, false, false,

                node.getLine(), scope, cflags).get(code);

        Str docStr = getDocStr(node.getInternalBody());

        if (docStr != null) {

            visit(docStr);

        } else {

            code.aconst_null();

        }

        if (!makeClosure(scope)) {

            code.invokespecial(p(PyFunction.class), "<init>", sig(Void.TYPE, PyObject.class,

                    PyObject[].class, PyCode.class, PyObject.class));

        } else {

            code.invokespecial(p(PyFunction.class), "<init>", sig(Void.TYPE, PyObject.class,

                    PyObject[].class, PyCode.class, PyObject.class, PyObject[].class));

        }

        applyDecorators(node.getInternalDecorator_list());

        set(new Name(node, node.getInternalName(), expr_contextType.Store));

        return null;

    }

    private void applyDecorators(java.util.List<expr> decorators) throws Exception {

        if (decorators != null && !decorators.isEmpty()) {

            int res = storeTop();

            for (expr decorator : decorators) {

                visit(decorator);

                stackProduce();

            }

            for (int i = decorators.size(); i > 0; i--) {

                stackConsume();

                loadThreadState();

                code.aload(res);

                code.invokevirtual(p(PyObject.class), "__call__", sig(PyObject.class,

                        ThreadState.class, PyObject.class));

                code.astore(res);

            }

            code.aload(res);

            code.freeLocal(res);

        }

    }

    @Override

    public Object visitExpr(Expr node) throws Exception {

        setline(node);

        visit(node.getInternalValue());

        if (print_results) {

            code.invokestatic(p(Py.class), "printResult", sig(Void.TYPE, PyObject.class));

        } else {

            code.pop();

        }

        return null;

    }

    @Override

    public Object visitAssign(Assign node) throws Exception {

        setline(node);

        visit(node.getInternalValue());

        if (node.getInternalTargets().size() == 1) {

            set(node.getInternalTargets().get(0));

        } else {

            int tmp = storeTop();

            for (expr target : node.getInternalTargets()) {

                set(target, tmp);

            }

            code.freeLocal(tmp);

        }

        return null;

    }

    @Override

    public Object visitPrint(Print node) throws Exception {

        setline(node);

        int tmp = -1;

        if (node.getInternalDest() != null) {

            visit(node.getInternalDest());