}
public final SimpleNode onCloseNode(SimpleNode n, int arity) throws Exception {
exprType value;
exprType[] exprs;
suiteType orelseSuite;
stmtType[] body;
exprType iter;
exprType target;
Suite suite;
int l;
switch (n.getId()) {
case JJTEXPR_STMT:
value = (exprType) stack.popNode();
if (arity > 1) {
exprs = makeExprs(arity - 1);
ctx.setStore(exprs);
return new Assign(exprs, value);
} else {
return new Expr(value);
}
case JJTINDEX_OP:
sliceType slice = (sliceType) stack.popNode();
value = (exprType) stack.popNode();
return new Subscript(value, slice, Subscript.Load);
case JJTPRINT_STMT:
boolean nl = true;
if (stack.nodeArity() == 0) {
Print p = new Print(null, null, true);
return p;
}
if (stack.peekNode().getId() == JJTCOMMA) {
stack.popNode();
nl = false;
}
Print p = new Print(null, makeExprs(), nl);
return p;
case JJTPRINTEXT_STMT:
nl = true;
if (stack.peekNode().getId() == JJTCOMMA) {
stack.popNode();
nl = false;
}
exprs = makeExprs(stack.nodeArity() - 1);
p = new Print(((exprType) stack.popNode()), exprs, nl);
return p;
case JJTBEGIN_FOR_ELSE_STMT:
return new Suite(null);
case JJTBEGIN_ELSE_STMT:
return new Suite(null);
case JJTBEGIN_WHILE_STMT:
return new While(null, null, null);
case JJTWHILE_STMT:
orelseSuite = null;
if (stack.nodeArity() == 5) {
orelseSuite = popSuiteAndSuiteType();
}
body = popSuite();
exprType test = (exprType) stack.popNode();
While w = (While) stack.popNode();
w.test = test;
w.body = body;
w.orelse = orelseSuite;
return w;
case JJTDECORATED:
if (stack.nodeArity() != 2) {
throw new RuntimeException("Expected 2 nodes at this context, found: " + arity);
}
SimpleNode def = stack.popNode();
Decorators decorators = (Decorators) stack.popNode();
if (def instanceof ClassDef) {
ClassDef classDef = (ClassDef) def;
classDef.decs = decorators.exp;
} else {
FunctionDef fDef = (FunctionDef) def;
fDef.decs = decorators.exp;
}
return def;
case JJTCALL_OP:
exprType starargs = null;
exprType kwargs = null;
java.util.List<exprType> args = new ArrayList<exprType>();
java.util.List<keywordType> keywords = new ArrayList<keywordType>();
for (int i = arity - 2; i >= 0; i--) {
SimpleNode node = stack.popNode();
if (node instanceof keywordType) {
keywords.add(0, (keywordType) node);
} else if (node.getId() == JJTEXTRAARGVALUELIST) {
ExtraArgValue nstarargs = (ExtraArgValue) node;
starargs = nstarargs.value;
this.addSpecialsAndClearOriginal(nstarargs, starargs);
} else if (node.getId() == JJTEXTRAKEYWORDVALUELIST) {
ExtraArgValue nkwargs = (ExtraArgValue) node;
kwargs = nkwargs.value;
this.addSpecialsAndClearOriginal(nkwargs, kwargs);
} else if (node instanceof ComprehensionCollection) {
//what can happen is something like print sum(x for x in y), where we have already passed x in the args, and then get 'for x in y'
args.add(
0,
new ListComp((exprType) stack.popNode(), ((ComprehensionCollection) node)
.getGenerators(), ListComp.EmptyCtx));
i--; //popped node
} else {
args.add(0, (exprType) node);
}
}
exprType func = (exprType) stack.popNode();
Call c = new Call(func, args.toArray(new exprType[args.size()]),
keywords.toArray(new keywordType[keywords.size()]), starargs, kwargs);
addSpecialsAndClearOriginal(n, c);
return c;
case JJTFUNCDEF:
suite = (Suite) stack.popNode();
body = suite.body;
argumentsType arguments = makeArguments(stack.nodeArity() - 1);
NameTok nameTok = makeName(NameTok.FunctionName);
//decorator is always null at this point... it's decorated later on
FunctionDef funcDef = new FunctionDef(nameTok, arguments, body, null, null);
addSpecialsAndClearOriginal(suite, funcDef);
setParentForFuncOrClass(body, funcDef);
return funcDef;
case JJTDEFAULTARG:
value = (arity == 1) ? null : ((exprType) stack.popNode());
return new DefaultArg(((exprType) stack.popNode()), value, n.getId());
case JJTEXTRAARGLIST:
return new ExtraArg(makeName(NameTok.VarArg), JJTEXTRAARGLIST);
case JJTEXTRAKEYWORDLIST:
return new ExtraArg(makeName(NameTok.KwArg), JJTEXTRAKEYWORDLIST);
case JJTCLASSDEF:
suite = (Suite) stack.popNode();
body = suite.body;
exprType[] bases = makeExprs(stack.nodeArity() - 1);
nameTok = makeName(NameTok.ClassName);
ClassDef classDef = new ClassDef(nameTok, bases, body, null, null, null, null);
addSpecialsAndClearOriginal(suite, classDef);
setParentForFuncOrClass(body, classDef);
return classDef;
case JJTBEGIN_RETURN_STMT:
return new Return(null);
case JJTRETURN_STMT:
value = arity == 2 ? ((exprType) stack.popNode()) : null;
Return ret = (Return) stack.popNode();
ret.value = value;
return ret;
case JJTYIELD_STMT:
return stack.popNode();
case JJTYIELD_EXPR:
exprType yieldExpr = null;
if (arity > 0) {
//we may have an empty yield, so, we have to check it before
yieldExpr = (exprType) stack.popNode();
}
return new Yield(yieldExpr, false);
case JJTRAISE_STMT:
exprType tback = arity >= 3 ? ((exprType) stack.popNode()) : null;
exprType inst = arity >= 2 ? ((exprType) stack.popNode()) : null;
exprType type = arity >= 1 ? ((exprType) stack.popNode()) : null;
return new Raise(type, inst, tback, null);
case JJTGLOBAL_STMT:
Global global = new Global(makeIdentifiers(NameTok.GlobalName), null);
return global;
case JJTASSERT_STMT:
exprType msg = arity == 2 ? ((exprType) stack.popNode()) : null;
test = (exprType) stack.popNode();
return new Assert(test, msg);
case JJTBEGIN_TRY_STMT:
//we do that just to get the specials
return new TryExcept(null, null, null);
case JJTTRYELSE_STMT:
orelseSuite = popSuiteAndSuiteType();
return orelseSuite;
case JJTTRYFINALLY_OUTER_STMT:
orelseSuite = popSuiteAndSuiteType();
return new TryFinally(null, orelseSuite); //it does not have a body at this time... it will be filled with the inner try..except
case JJTTRY_STMT:
TryFinally outer = null;
if (stack.peekNode() instanceof TryFinally) {
outer = (TryFinally) stack.popNode();
arity--;
}
orelseSuite = null;
if (stack.peekNode() instanceof suiteType) {
orelseSuite = (suiteType) stack.popNode();
arity--;
}
l = arity;
excepthandlerType[] handlers = new excepthandlerType[l];
for (int i = l - 1; i >= 0; i--) {
handlers[i] = (excepthandlerType) stack.popNode();
}
suite = (Suite) stack.popNode();
TryExcept tryExc = (TryExcept) stack.popNode();
if (outer != null) {
outer.beginLine = tryExc.beginLine;
}
tryExc.body = suite.body;
tryExc.handlers = handlers;
tryExc.orelse = orelseSuite;
addSpecials(suite, tryExc);
if (outer == null) {
return tryExc;
} else {
if (outer.body != null) {
throw new RuntimeException("Error. Expecting null body to be filled on try..except..finally");
}
outer.body = new stmtType[] { tryExc };
return outer;
}
case JJTBEGIN_TRY_ELSE_STMT:
//we do that just to get the specials
return new Suite(null);
case JJTBEGIN_EXCEPT_CLAUSE:
return new excepthandlerType(null, null, null);
case JJTEXCEPT_CLAUSE:
suite = (Suite) stack.popNode();
body = suite.body;
exprType excname = arity == 4 ? ((exprType) stack.popNode()) : null;
if (excname != null) {
ctx.setStore(excname);
}
type = arity >= 3 ? ((exprType) stack.popNode()) : null;
excepthandlerType handler = (excepthandlerType) stack.popNode();
handler.type = type;
handler.name = excname;
handler.body = body;
addSpecials(suite, handler);
return handler;
case JJTBEGIN_FINALLY_STMT:
//we do that just to get the specials
return new Suite(null);
case JJTTRYFINALLY_STMT:
suiteType finalBody = popSuiteAndSuiteType();
body = popSuite();
//We have a try..except in the stack, but we will change it for a try..finally
//This is because we recognize a try..except in the 'try:' token, but actually end up with a try..finally
TryExcept tryExcept = (TryExcept) stack.popNode();
TryFinally tryFinally = new TryFinally(body, finalBody);
tryFinally.beginLine = tryExcept.beginLine;
tryFinally.beginColumn = tryExcept.beginColumn;
addSpecialsAndClearOriginal(tryExcept, tryFinally);
return tryFinally;
case JJTWITH_STMT:
suite = (Suite) stack.popNode();
arity--;
exprType asOrExpr = (exprType) stack.popNode();
arity--;
exprType expr = null;
if (arity > 0) {
expr = (exprType) stack.popNode();
arity--;
} else {
expr = asOrExpr;
asOrExpr = null;
}
suiteType s = new Suite(suite.body);
addSpecialsAndClearOriginal(suite, s);
return new With(new WithItem[] { new WithItem(expr, asOrExpr) }, s);
case JJTWITH_VAR:
expr = (exprType) stack.popNode(); //expr