private static final Object Exit = Integer.valueOf(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>();

/*

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.getLineno());

}

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 void loadArray(Code code, java.util.List<? extends PythonTree> nodes) throws Exception {

final int n;

if (nodes == null) {

n = 0;

} else {

n = nodes.size();

}

if (n == 0) {

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

return;

} else if (module.emitPrimitiveArraySetters(nodes, code)) {

return;

}

code.iconst(n);

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

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

code.dup();

code.iconst(i);

visit(nodes.get(i));

code.aastore();

}

}

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

final 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.getLineno(), 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());

tmp = storeTop();

}

if (node.getInternalValues() == null || node.getInternalValues().size() == 0) {

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

code.aload(tmp);

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

} else {

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

}

} else {

for (int i = 0; i < node.getInternalValues().size(); i++) {

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

code.aload(tmp);

visit(node.getInternalValues().get(i));

if (node.getInternalNl() && i == node.getInternalValues().size() - 1) {

code.invokestatic(p(Py.class), "println",

sig(Void.TYPE, PyObject.class, PyObject.class));

} else {

code.invokestatic(p(Py.class), "printComma",

sig(Void.TYPE, PyObject.class, PyObject.class));

}

} else {

visit(node.getInternalValues().get(i));

if (node.getInternalNl() && i == node.getInternalValues().size() - 1) {

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

} else {

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

}

}

}

}

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

code.freeLocal(tmp);

}

return null;

}

@Override

public Object visitDelete(Delete node) throws Exception {

setline(node);

traverse(node);

return null;

}

@Override

public Object visitPass(Pass node) throws Exception {

setline(node);

return null;

}

@Override

public Object visitBreak(Break node) throws Exception {

// setline(node); Not needed here...

if (breakLabels.empty()) {

throw new ParseException("'break' outside loop", node);

}

doFinallysDownTo(bcfLevel);

code.goto_(breakLabels.peek());

return null;

}

@Override

public Object visitContinue(Continue node) throws Exception {

// setline(node); Not needed here...

if (continueLabels.empty()) {

throw new ParseException("'continue' not properly in loop", node);

}

doFinallysDownTo(bcfLevel);

code.goto_(continueLabels.peek());

return Exit;

}

@Override

public Object visitYield(Yield node) throws Exception {

setline(node);

if (!fast_locals) {

throw new ParseException("'yield' outside function", node);

}

int stackState = saveStack();

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

visit(node.getInternalValue());

} else {

getNone();

}

setLastI(++yield_count);

saveLocals();

code.areturn();

Label restart = new Label();

yields.addElement(restart);

code.label(restart);

restoreLocals();

restoreStack(stackState);

loadFrame();

code.invokevirtual(p(PyFrame.class), "getGeneratorInput", sig(Object.class));

code.dup();

code.instanceof_(p(PyException.class));

Label done2 = new Label();

code.ifeq(done2);

code.checkcast(p(Throwable.class));

code.athrow();

code.label(done2);

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

return null;

}

private void stackProduce() {

stackProduce(p(PyObject.class));

}

private void stackProduce(String signature) {

stack.push(signature);

}

private void stackConsume() {

stackConsume(1);

}

private void stackConsume(int numItems) {

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

stack.pop();

}

}

private int saveStack() throws Exception {

if (stack.size() > 0) {

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

code.iconst(stack.size());

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

code.astore(array);

ListIterator<String> content = stack.listIterator(stack.size());

for (int i = 0; content.hasPrevious(); i++) {

String signature = content.previous();

if (p(ThreadState.class).equals(signature)) {

// Stack: ... threadstate

code.pop();

// Stack: ...

} else {

code.aload(array);

// Stack: |- ... value array

code.swap();

code.iconst(i++);

code.swap();

// Stack: |- ... array index value

code.aastore();

// Stack: |- ...

}

}

return array;

} else {

return -1;

}

}

private void restoreStack(int array) throws Exception {

if (stack.size() > 0) {

int i = stack.size() - 1;

for (String signature : stack) {

if (p(ThreadState.class).equals(signature)) {

loadThreadState();

} else {

code.aload(array);

// Stack: |- ... array

code.iconst(i--);

code.aaload();

// Stack: |- ... value

code.checkcast(signature);

}

}

code.freeLocal(array);

}

}

private void restoreLocals() throws Exception {

endExceptionHandlers();

Vector<String> v = code.getActiveLocals();

loadFrame();

code.getfield(p(PyFrame.class), "f_savedlocals", ci(Object[].class));

int locals = code.getLocal(ci(Object[].class));

code.astore(locals);

for (int i = 0; i < v.size(); i++) {

String type = v.elementAt(i);

if (type == null) {

continue;

}

code.aload(locals);

code.iconst(i);

code.aaload();

code.checkcast(type);

code.astore(i);

}

code.freeLocal(locals);

restartExceptionHandlers();

}

/**

private void endExceptionHandlers() {

Label end = new Label();

code.label(end);

for (int i = 0; i < exceptionHandlers.size(); ++i) {

ExceptionHandler handler = exceptionHandlers.elementAt(i);

handler.exceptionEnds.addElement(end);

}

}

private void restartExceptionHandlers() {

Label start = new Label();

code.label(start);

for (int i = 0; i < exceptionHandlers.size(); ++i) {

ExceptionHandler handler = exceptionHandlers.elementAt(i);

handler.exceptionStarts.addElement(start);

}

}

private void saveLocals() throws Exception {

Vector<String> v = code.getActiveLocals();

code.iconst(v.size());

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

int locals = code.getLocal(ci(Object[].class));

code.astore(locals);

for (int i = 0; i < v.size(); i++) {

String type = v.elementAt(i);

if (type == null) {

continue;

}

code.aload(locals);

code.iconst(i);

// code.checkcast(code.pool.Class(p(Object.class)));

if (i == 2222) {

code.aconst_null();

} else {

code.aload(i);

}

code.aastore();

}

loadFrame();

code.aload(locals);

code.putfield(p(PyFrame.class), "f_savedlocals", ci(Object[].class));

code.freeLocal(locals);

}

@Override

public Object visitReturn(Return node) throws Exception {

return visitReturn(node, false);

}

public Object visitReturn(Return node, boolean inEval) throws Exception {

setline(node);

if (!inEval && !fast_locals) {

throw new ParseException("'return' outside function", node);

}

int tmp = 0;

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

if (my_scope.generator && !(node instanceof LambdaSyntheticReturn)) {

throw new ParseException("'return' with argument " + "inside generator", node);

}

visit(node.getInternalValue());

tmp = code.getReturnLocal();

code.astore(tmp);

}

doFinallysDownTo(0);

setLastI(-1);

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

code.aload(tmp);

} else {

getNone();

}

code.areturn();

return Exit;

}

@Override

public Object visitRaise(Raise node) throws Exception {

setline(node);

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

visit(node.getInternalType());

stackProduce();

}

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

visit(node.getInternalInst());

stackProduce();

}

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

visit(node.getInternalTback());

stackProduce();

}

if (node.getInternalType() == null) {

code.invokestatic(p(Py.class), "makeException", sig(PyException.class));

} else if (node.getInternalInst() == null) {

stackConsume();

code.invokestatic(p(Py.class), "makeException", sig(PyException.class, PyObject.class));

} else if (node.getInternalTback() == null) {

stackConsume(2);

code.invokestatic(p(Py.class), "makeException",

sig(PyException.class, PyObject.class, PyObject.class));

} else {

stackConsume(3);

code.invokestatic(p(Py.class), "makeException",

sig(PyException.class, PyObject.class, PyObject.class, PyObject.class));

}

code.athrow();

return Exit;

}

/**

private int impliedImportLevel(int level) {

// already prepared for a future change of DEFAULT_LEVEL

if (imp.DEFAULT_LEVEL == 0 || level != 0 || module.getFutures().isAbsoluteImportOn()) {

return level;

} else {

return imp.DEFAULT_LEVEL;

}

}

@Override

public Object visitImport(Import node) throws Exception {

setline(node);

for (alias a : node.getInternalNames()) {

String asname = null;

if (a.getInternalAsname() != null) {

String name = a.getInternalName();

asname = a.getInternalAsname();

code.ldc(name);

loadFrame();

code.iconst(impliedImportLevel(0));

code.invokestatic(p(imp.class), "importOneAs",

sig(PyObject.class, String.class, PyFrame.class, Integer.TYPE));

} else {

String name = a.getInternalName();

asname = name;

if (asname.indexOf('.') > 0) {

asname = asname.substring(0, asname.indexOf('.'));

}

code.ldc(name);

loadFrame();

code.iconst(impliedImportLevel(0));

code.invokestatic(p(imp.class), "importOne",

sig(PyObject.class, String.class, PyFrame.class, Integer.TYPE));

}

set(new Name(a, asname, expr_contextType.Store));

}

return null;

}

@Override

public Object visitImportFrom(ImportFrom node) throws Exception {

Future.checkFromFuture(node); // future stmt support

setline(node);

code.ldc(node.getInternalModule());

java.util.List<alias> aliases = node.getInternalNames();

if (aliases == null || aliases.size() == 0) {

throw new ParseException("Internel parser error", node);

} else if (aliases.size() == 1 && aliases.get(0).getInternalName().equals("*")) {

if (my_scope.func_level > 0) {

module.error("import * only allowed at module level", false, node);

if (my_scope.contains_ns_free_vars) {

module.error("import * is not allowed in function '" + my_scope.scope_name

+ "' because it contains a nested function with free variables", true,

node);

}

}

if (my_scope.func_level > 1) {

module.error("import * is not allowed in function '" + my_scope.scope_name

+ "' because it is a nested function", true, node);

}

loadFrame();

code.iconst(impliedImportLevel(node.getInternalLevel()));

code.invokestatic(p(imp.class), "importAll",

sig(Void.TYPE, String.class, PyFrame.class, Integer.TYPE));

} else {

java.util.List<String> fromNames = new ArrayList<String>(); // [names.size()];

java.util.List<String> asnames = new ArrayList<String>(); // [names.size()];

for (int i = 0; i < aliases.size(); i++) {

fromNames.add(aliases.get(i).getInternalName());

asnames.add(aliases.get(i).getInternalAsname());