/* Compile an expression node to intermediate code */
/* XXX TO DO:
- XXX Compute maximum needed stack sizes while compiling;
- XXX then frame object can be one malloc and no stack checks are needed
- XXX add __doc__ attribute == co_doc to code object attributes
- XXX don't execute doc string
+ XXX add __doc__ attribute == co_doc to code object attributes?
+ XXX (it's currently the first item of the co_const tuple)
XXX Generate simple jump for break/return outside 'try...finally'
+ XXX Allow 'continue' inside try-finally
XXX get rid of SET_LINENO instructions, use JAR's table trick
XXX (need an option to put them back in, for debugger!)
+ XXX New 1-byte opcode for loading None
+ XXX New opcode for loading the initial index for a for loop
XXX other JAR tricks?
*/
static struct memberlist code_memberlist[] = {
{"co_argcount", T_INT, OFF(co_argcount), READONLY},
{"co_nlocals", T_INT, OFF(co_nlocals), READONLY},
+ {"co_stacksize",T_INT, OFF(co_stacksize), READONLY},
{"co_flags", T_INT, OFF(co_flags), READONLY},
{"co_code", T_OBJECT, OFF(co_code), READONLY},
{"co_consts", T_OBJECT, OFF(co_consts), READONLY},
};
codeobject *
-newcodeobject(argcount, nlocals, flags,
+newcodeobject(argcount, nlocals, stacksize, flags,
code, consts, names, varnames, filename, name)
int argcount;
int nlocals;
+ int stacksize;
int flags;
object *code;
object *consts;
if (co != NULL) {
co->co_argcount = argcount;
co->co_nlocals = nlocals;
+ co->co_stacksize = stacksize;
co->co_flags = flags;
INCREF(code);
co->co_code = (stringobject *)code;
/* Data structure used internally */
-#define MAXBLOCKS 20 /* Max static block nesting within a function */
-
struct compiling {
object *c_code; /* string */
object *c_consts; /* list of objects */
int c_interactive; /* generating code for interactive command */
int c_loops; /* counts nested loops */
int c_begin; /* begin of current loop, for 'continue' */
- int c_block[MAXBLOCKS]; /* stack of block types */
+ int c_block[CO_MAXBLOCKS]; /* stack of block types */
int c_nblocks; /* current block stack level */
char *c_filename; /* filename of current node */
char *c_name; /* name of object (e.g. function) */
int c_lineno; /* Current line number */
+ int c_stacklevel; /* Current stack level */
+ int c_maxstacklevel; /* Maximum stack level */
#ifdef PRIVATE_NAME_MANGLING
char *c_private; /* for private name mangling */
#endif
struct compiling *c;
int type;
{
- if (c->c_nblocks >= MAXBLOCKS) {
+ if (c->c_nblocks >= CO_MAXBLOCKS) {
com_error(c, SystemError, "too many statically nested blocks");
}
else {
static int com_init PROTO((struct compiling *, char *));
static void com_free PROTO((struct compiling *));
+static void com_push PROTO((struct compiling *, int));
+static void com_pop PROTO((struct compiling *, int));
static void com_done PROTO((struct compiling *));
static void com_node PROTO((struct compiling *, struct _node *));
static void com_factor PROTO((struct compiling *, struct _node *));
c->c_filename = filename;
c->c_name = "?";
c->c_lineno = 0;
+ c->c_stacklevel = 0;
+ c->c_maxstacklevel = 0;
return 1;
fail_000:
XDECREF(c->c_varnames);
}
+static void
+com_push(c, n)
+ struct compiling *c;
+ int n;
+{
+ c->c_stacklevel += n;
+ if (c->c_stacklevel > c->c_maxstacklevel)
+ c->c_maxstacklevel = c->c_stacklevel;
+}
+
+static void
+com_pop(c, n)
+ struct compiling *c;
+ int n;
+{
+ if (c->c_stacklevel < n) {
+ fprintf(stderr,
+ "%s:%d: underflow! nexti=%d, level=%d, n=%d\n",
+ c->c_filename, c->c_lineno,
+ c->c_nexti, c->c_stacklevel, n);
+ c->c_stacklevel = 0;
+ }
+ else
+ c->c_stacklevel -= n;
+}
+
static void
com_done(c)
struct compiling *c;
for (i = 0; i < NCH(n); i += 2)
com_node(c, CHILD(n, i));
com_addoparg(c, BUILD_LIST, len);
+ com_pop(c, len-1);
}
static void
/* We must arrange things just right for STORE_SUBSCR.
It wants the stack to look like (value) (dict) (key) */
com_addbyte(c, DUP_TOP);
+ com_push(c, 1);
com_node(c, CHILD(n, i+2)); /* value */
com_addbyte(c, ROT_TWO);
com_node(c, CHILD(n, i)); /* key */
com_addbyte(c, STORE_SUBSCR);
+ com_pop(c, 3);
}
}
ch = CHILD(n, 0);
switch (TYPE(ch)) {
case LPAR:
- if (TYPE(CHILD(n, 1)) == RPAR)
+ if (TYPE(CHILD(n, 1)) == RPAR) {
com_addoparg(c, BUILD_TUPLE, 0);
+ com_push(c, 1);
+ }
else
com_node(c, CHILD(n, 1));
break;
case LSQB:
- if (TYPE(CHILD(n, 1)) == RSQB)
+ if (TYPE(CHILD(n, 1)) == RSQB) {
com_addoparg(c, BUILD_LIST, 0);
+ com_push(c, 1);
+ }
else
com_list_constructor(c, CHILD(n, 1));
break;
case LBRACE: /* '{' [dictmaker] '}' */
com_addoparg(c, BUILD_MAP, 0);
+ com_push(c, 1);
if (TYPE(CHILD(n, 1)) != RBRACE)
com_dictmaker(c, CHILD(n, 1));
break;
DECREF(v);
}
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
break;
case STRING:
v = parsestrplus(n);
DECREF(v);
}
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
break;
case NAME:
com_addopname(c, LOAD_NAME, ch);
+ com_push(c, 1);
break;
default:
- fprintf(stderr, "node type %d\n", TYPE(ch));
+ /* XXX fprintf(stderr, "node type %d\n", TYPE(ch)); */
com_error(c, SystemError, "com_atom: unexpected node type");
}
}
com_node(c, CHILD(n, 1));
com_addbyte(c, op+2);
}
+ com_pop(c, 1);
}
else {
com_node(c, CHILD(n, 0));
com_node(c, CHILD(n, 2));
com_addbyte(c, op+3);
+ com_pop(c, 2);
}
}
object **pkeywords;
{
node *m;
- REQ(n, argument); /* [test '='] test; really [ keyword '='] keyword */
+ REQ(n, argument); /* [test '='] test; really [keyword '='] test */
if (NCH(n) == 1) {
if (*pkeywords != NULL) {
com_error(c, SyntaxError,
if (dict2insert(*pkeywords, v, v) != 0)
c->c_errors++;
com_addoparg(c, LOAD_CONST, com_addconst(c, v));
+ com_push(c, 1);
DECREF(v);
}
}
com_error(c, SyntaxError, "more than 255 arguments");
}
com_addoparg(c, CALL_FUNCTION, na | (nk << 8));
+ com_pop(c, na + 2*nk);
}
}
/* first argument */
if (TYPE(CHILD(n,i)) == COLON) {
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
i++;
}
else {
com_node(c, CHILD(n,i));
i++;
}
- else com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ else {
+ com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
+ }
/* remaining arguments */
for (; i < NCH(n); i++) {
ns++;
if (NCH(ch) == 1) {
/* right argument of ':' missing */
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
}
else
com_node(c, CHILD(ch,1));
}
com_addoparg(c, BUILD_SLICE, ns);
+ com_pop(c, 1 + (ns == 3));
}
static void
REQ(n, subscript);
ch = CHILD(n,0);
/* check for rubber index */
- if (TYPE(ch) == DOT && TYPE(CHILD(n,1)) == DOT)
+ if (TYPE(ch) == DOT && TYPE(CHILD(n,1)) == DOT) {
com_addoparg(c, LOAD_CONST, com_addconst(c, Py_Ellipsis));
+ com_push(c, 1);
+ }
else {
/* check for slice */
if ((TYPE(ch) == COLON || NCH(n) > 1))
if (NCH(n) == 1) {
node *sub = CHILD(n, 0); /* subscript */
/* Make it is a simple slice.
- should have exactly one colon. */
+ Should have exactly one colon. */
if ((TYPE(CHILD(sub, 0)) == COLON
|| (NCH(sub) > 1 && TYPE(CHILD(sub, 1)) == COLON))
- && (TYPE(CHILD(sub,NCH(sub)-1)) != sliceop)) {
+ && (TYPE(CHILD(sub,NCH(sub)-1)) != sliceop))
+ {
if (assigning == OP_APPLY)
op = SLICE;
else
op = ((assigning == OP_ASSIGN) ? STORE_SLICE : DELETE_SLICE);
com_slice(c, sub, op);
+ if (op == STORE_SLICE)
+ com_pop(c, 2);
+ else if (op == DELETE_SLICE)
+ com_pop(c, 1);
return;
}
}
for (i = 0; i < NCH(n); i += 2)
com_subscript(c, CHILD(n, i));
/* Put multiple subscripts into a tuple */
- if (NCH(n) > 1)
- com_addoparg(c, BUILD_TUPLE, (NCH(n)+1) / 2);
- if (assigning == OP_APPLY)
+ if (NCH(n) > 1) {
+ i = (NCH(n)+1) / 2;
+ com_addoparg(c, BUILD_TUPLE, i);
+ com_pop(c, i-1);
+ }
+ if (assigning == OP_APPLY) {
op = BINARY_SUBSCR;
- else
- op = ((assigning == OP_ASSIGN) ? STORE_SUBSCR : DELETE_SUBSCR);
+ i = 1;
+ }
+ else if (assigning == OP_ASSIGN) {
+ op = STORE_SUBSCR;
+ i = 3;
+ }
+ else {
+ op = DELETE_SUBSCR;
+ i = 2;
+ }
com_addbyte(c, op);
+ com_pop(c, i);
}
static void
if (TYPE(CHILD(n, i)) == DOUBLESTAR) {
com_factor(c, CHILD(n, i+1));
com_addbyte(c, BINARY_POWER);
+ com_pop(c, 1);
break;
}
else
op = 255;
}
com_addbyte(c, op);
+ com_pop(c, 1);
}
}
op = 255;
}
com_addbyte(c, op);
+ com_pop(c, 1);
}
}
op = 255;
}
com_addbyte(c, op);
+ com_pop(c, 1);
}
}
op = 255;
}
com_addbyte(c, op);
+ com_pop(c, 1);
}
}
op = 255;
}
com_addbyte(c, op);
+ com_pop(c, 1);
}
}
op = 255;
}
com_addbyte(c, op);
+ com_pop(c, 1);
}
}
L1: b, 0 ROT_TWO
0, b POP_TOP
0
- L2:
+ L2: 0-or-1
****************************************************************/
anchor = 0;
com_expr(c, CHILD(n, i));
if (i+2 < NCH(n)) {
com_addbyte(c, DUP_TOP);
+ com_push(c, 1);
com_addbyte(c, ROT_THREE);
}
op = cmp_type(CHILD(n, i-1));
"com_comparison: unknown comparison op");
}
com_addoparg(c, COMPARE_OP, op);
+ com_pop(c, 1);
if (i+2 < NCH(n)) {
com_addfwref(c, JUMP_IF_FALSE, &anchor);
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
}
}
break;
com_addfwref(c, JUMP_IF_FALSE, &anchor);
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
}
if (anchor)
com_backpatch(c, anchor);
struct compiling *c;
node *n;
{
- REQ(n, test); /* and_test ('and' and_test)* | lambdef */
+ REQ(n, test); /* and_test ('or' and_test)* | lambdef */
if (NCH(n) == 1 && TYPE(CHILD(n, 0)) == lambdef) {
object *v;
int i;
DECREF(v);
}
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
com_addoparg(c, MAKE_FUNCTION, ndefs);
+ com_pop(c, ndefs);
}
else {
int anchor = 0;
break;
com_addfwref(c, JUMP_IF_TRUE, &anchor);
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
}
if (anchor)
com_backpatch(c, anchor);
for (i = 0; i < NCH(n); i += 2)
com_node(c, CHILD(n, i));
com_addoparg(c, BUILD_TUPLE, len);
+ com_pop(c, len-1);
}
}
int assigning;
{
com_addopname(c, assigning ? STORE_ATTR : DELETE_ATTR, n);
+ com_pop(c, assigning ? 2 : 1);
}
static void
int i;
if (TYPE(n) != testlist)
REQ(n, exprlist);
- if (assigning)
- com_addoparg(c, UNPACK_TUPLE, (NCH(n)+1)/2);
+ if (assigning) {
+ i = (NCH(n)+1)/2;
+ com_addoparg(c, UNPACK_TUPLE, i);
+ com_push(c, i-1);
+ }
for (i = 0; i < NCH(n); i += 2)
com_assign(c, CHILD(n, i), assigning);
}
int assigning;
{
int i;
- if (assigning)
- com_addoparg(c, UNPACK_LIST, (NCH(n)+1)/2);
+ if (assigning) {
+ i = (NCH(n)+1)/2;
+ com_addoparg(c, UNPACK_LIST, i);
+ com_push(c, i-1);
+ }
for (i = 0; i < NCH(n); i += 2)
com_assign(c, CHILD(n, i), assigning);
}
{
REQ(n, NAME);
com_addopname(c, assigning ? STORE_NAME : DELETE_NAME, n);
+ if (assigning)
+ com_pop(c, 1);
}
static void
return;
default:
- fprintf(stderr, "node type %d\n", TYPE(n));
+ /* XXX fprintf(stderr, "node type %d\n", TYPE(n)); */
com_error(c, SystemError, "com_assign: bad node");
return;
}
}
}
+/* Forward */ static node *get_rawdocstring PROTO((node *));
static void
com_expr_stmt(c, n)
node *n;
{
REQ(n, expr_stmt); /* testlist ('=' testlist)* */
+ /* Forget it if we have just a doc string here */
+ if (NCH(n) == 1 && get_rawdocstring(n) != NULL)
+ return;
com_node(c, CHILD(n, NCH(n)-1));
if (NCH(n) == 1) {
if (c->c_interactive)
com_addbyte(c, PRINT_EXPR);
else
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
}
else {
int i;
for (i = 0; i < NCH(n)-2; i+=2) {
- if (i+2 < NCH(n)-2)
+ if (i+2 < NCH(n)-2) {
com_addbyte(c, DUP_TOP);
+ com_push(c, 1);
+ }
com_assign(c, CHILD(n, i), OP_ASSIGN);
}
}
for (i = 1; i < NCH(n); i += 2) {
com_node(c, CHILD(n, i));
com_addbyte(c, PRINT_ITEM);
+ com_pop(c, 1);
}
if (TYPE(CHILD(n, NCH(n)-1)) != COMMA)
com_addbyte(c, PRINT_NEWLINE);
if (!c->c_infunction) {
com_error(c, SyntaxError, "'return' outside function");
}
- if (NCH(n) < 2)
+ if (NCH(n) < 2) {
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
+ }
else
com_node(c, CHILD(n, 1));
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
}
static void
struct compiling *c;
node *n;
{
+ int i;
REQ(n, raise_stmt); /* 'raise' test [',' test [',' test]] */
com_node(c, CHILD(n, 1));
if (NCH(n) > 3) {
if (NCH(n) > 5)
com_node(c, CHILD(n, 5));
}
- com_addoparg(c, RAISE_VARARGS, NCH(n)/2);
+ i = NCH(n)/2;
+ com_addoparg(c, RAISE_VARARGS, i);
+ com_pop(c, i);
}
static void
/* 'from' dotted_name 'import' ... */
REQ(CHILD(n, 1), dotted_name);
com_addopname(c, IMPORT_NAME, CHILD(n, 1));
+ com_push(c, 1);
for (i = 3; i < NCH(n); i += 2)
com_addopname(c, IMPORT_FROM, CHILD(n, i));
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
}
else {
/* 'import' ... */
for (i = 1; i < NCH(n); i += 2) {
REQ(CHILD(n, i), dotted_name);
com_addopname(c, IMPORT_NAME, CHILD(n, i));
+ com_push(c, 1);
com_addopname(c, STORE_NAME, CHILD(CHILD(n, i), 0));
+ com_pop(c, 1);
}
}
}
return i;
}
+#ifdef SUPPORT_OBSOLETE_ACCESS
+
#define strequ(a, b) (strcmp((a), (b)) == 0)
-#ifdef SUPPORT_OBSOLETE_ACCESS
static void
com_access_stmt(c, n)
struct compiling *c;
com_node(c, CHILD(n, 1));
if (NCH(n) >= 4)
com_node(c, CHILD(n, 3));
- else
+ else {
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
+ }
if (NCH(n) >= 6)
com_node(c, CHILD(n, 5));
- else
+ else {
com_addbyte(c, DUP_TOP);
+ com_push(c, 1);
+ }
com_addbyte(c, EXEC_STMT);
+ com_pop(c, 3);
}
static void
com_node(c, CHILD(n, i+1));
com_addfwref(c, JUMP_IF_FALSE, &a);
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
com_node(c, CHILD(n, i+3));
com_addfwref(c, JUMP_FORWARD, &anchor);
com_backpatch(c, a);
+ /* We jump here with an extra entry which we now pop */
com_addbyte(c, POP_TOP);
}
if (i+2 < NCH(n))
com_node(c, CHILD(n, 1));
com_addfwref(c, JUMP_IF_FALSE, &anchor);
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
c->c_loops++;
com_node(c, CHILD(n, 3));
c->c_loops--;
com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
c->c_begin = save_begin;
com_backpatch(c, anchor);
+ /* We jump here with one entry more on the stack */
com_addbyte(c, POP_TOP);
com_addbyte(c, POP_BLOCK);
block_pop(c, SETUP_LOOP);
if (v == NULL)
c->c_errors++;
com_addoparg(c, LOAD_CONST, com_addconst(c, v));
+ com_push(c, 1);
XDECREF(v);
c->c_begin = c->c_nexti;
com_addoparg(c, SET_LINENO, n->n_lineno);
com_addfwref(c, FOR_LOOP, &anchor);
+ com_push(c, 1);
com_assign(c, CHILD(n, 1), OP_ASSIGN);
c->c_loops++;
com_node(c, CHILD(n, 5));
com_addoparg(c, JUMP_ABSOLUTE, c->c_begin);
c->c_begin = save_begin;
com_backpatch(c, anchor);
+ com_pop(c, 2); /* FOR_LOOP has popped these */
com_addbyte(c, POP_BLOCK);
block_pop(c, SETUP_LOOP);
if (NCH(n) > 8)
for (i = 3;
i < NCH(n) && TYPE(ch = CHILD(n, i)) == except_clause;
i += 3) {
- /* except_clause: 'except' [expr [',' expr]] */
+ /* except_clause: 'except' [expr [',' var]] */
if (except_anchor == 0) {
com_error(c, SyntaxError,
"default 'except:' must be last");
break;
}
except_anchor = 0;
+ com_push(c, 3); /* tb, val, exc pushed by exception */
com_addoparg(c, SET_LINENO, ch->n_lineno);
if (NCH(ch) > 1) {
com_addbyte(c, DUP_TOP);
+ com_push(c, 1);
com_node(c, CHILD(ch, 1));
com_addoparg(c, COMPARE_OP, EXC_MATCH);
+ com_pop(c, 1);
com_addfwref(c, JUMP_IF_FALSE, &except_anchor);
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
}
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
if (NCH(ch) > 3)
com_assign(c, CHILD(ch, 3), OP_ASSIGN);
- else
+ else {
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
+ }
com_addbyte(c, POP_TOP);
+ com_pop(c, 1);
com_node(c, CHILD(n, i+2));
com_addfwref(c, JUMP_FORWARD, &end_anchor);
if (except_anchor) {
com_backpatch(c, except_anchor);
+ /* We come in with [tb, val, exc, 0] on the
+ stack; one pop and it's the same as
+ expected at the start of the loop */
com_addbyte(c, POP_TOP);
}
}
+ /* We actually come in here with [tb, val, exc] but the
+ END_FINALLY will zap those and jump around.
+ The c_stacklevel does not reflect them so we need not pop
+ anything. */
com_addbyte(c, END_FINALLY);
com_backpatch(c, else_anchor);
if (i < NCH(n))
block_pop(c, SETUP_FINALLY);
block_push(c, END_FINALLY);
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ /* While the generated code pushes only one item,
+ the try-finally handling can enter here with
+ up to three items. OK, here are the details:
+ 3 for an exception, 2 for RETURN, 1 for BREAK. */
+ com_push(c, 3);
com_backpatch(c, finally_anchor);
ch = CHILD(n, NCH(n)-1);
com_addoparg(c, SET_LINENO, ch->n_lineno);
com_node(c, ch);
com_addbyte(c, END_FINALLY);
block_pop(c, END_FINALLY);
+ com_pop(c, 3); /* Matches the com_push above */
}
static void
com_try_except(c, n);
}
-static object *
-get_docstring(n)
+static node *
+get_rawdocstring(n)
node *n;
{
int i;
+ /* Label to avoid tail recursion */
+ next:
switch (TYPE(n)) {
case suite:
- if (NCH(n) == 1)
- return get_docstring(CHILD(n, 0));
- else {
- for (i = 0; i < NCH(n); i++) {
- node *ch = CHILD(n, i);
- if (TYPE(ch) == stmt)
- return get_docstring(ch);
- }
+ if (NCH(n) == 1) {
+ n = CHILD(n, 0);
+ goto next;
}
- break;
-
+ /* Fall through */
case file_input:
for (i = 0; i < NCH(n); i++) {
node *ch = CHILD(n, i);
- if (TYPE(ch) == stmt)
- return get_docstring(ch);
+ if (TYPE(ch) == stmt) {
+ n = ch;
+ goto next;
+ }
}
break;
case stmt:
case simple_stmt:
case small_stmt:
- return get_docstring(CHILD(n, 0));
+ n = CHILD(n, 0);
+ goto next;
case expr_stmt:
case testlist:
case term:
case factor:
case power:
- if (NCH(n) == 1)
- return get_docstring(CHILD(n, 0));
+ if (NCH(n) == 1) {
+ n = CHILD(n, 0);
+ goto next;
+ }
break;
case atom:
if (TYPE(CHILD(n, 0)) == STRING)
- return parsestrplus(n);
+ return n;
break;
}
return NULL;
}
+static object *
+get_docstring(n)
+ node *n;
+{
+ n = get_rawdocstring(n);
+ if (n == NULL)
+ return NULL;
+ return parsestrplus(n);
+}
+
static void
com_suite(c, n)
struct compiling *c;
if (ndefs) {
com_addoparg(c, LOAD_CONST,
com_addconst(c, None));
+ com_push(c, 1);
ndefs++;
}
}
int i = com_addconst(c, v);
int ndefs = com_argdefs(c, n);
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
com_addoparg(c, MAKE_FUNCTION, ndefs);
+ com_pop(c, ndefs);
com_addopname(c, STORE_NAME, CHILD(n, 1));
+ com_pop(c, 1);
DECREF(v);
}
}
/* testlist: test (',' test)* [','] */
for (i = 0; i < NCH(n); i += 2)
com_node(c, CHILD(n, i));
- com_addoparg(c, BUILD_TUPLE, (NCH(n)+1) / 2);
+ i = (NCH(n)+1) / 2;
+ com_addoparg(c, BUILD_TUPLE, i);
+ com_pop(c, i-1);
}
static void
/* Push the class name on the stack */
i = com_addconst(c, v);
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
DECREF(v);
/* Push the tuple of base classes on the stack */
- if (TYPE(CHILD(n, 2)) != LPAR)
+ if (TYPE(CHILD(n, 2)) != LPAR) {
com_addoparg(c, BUILD_TUPLE, 0);
+ com_push(c, 1);
+ }
else
com_bases(c, CHILD(n, 3));
v = (object *)icompile(n, c);
else {
i = com_addconst(c, v);
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
com_addoparg(c, MAKE_FUNCTION, 0);
com_addoparg(c, CALL_FUNCTION, 0);
com_addbyte(c, BUILD_CLASS);
+ com_pop(c, 2);
com_addopname(c, STORE_NAME, CHILD(n, 1));
DECREF(v);
}
break;
default:
- fprintf(stderr, "node type %d\n", TYPE(n));
+ /* XXX fprintf(stderr, "node type %d\n", TYPE(n)); */
com_error(c, SystemError, "com_node: unexpected node type");
}
}
REQ(n, fpdef); /* fpdef: NAME | '(' fplist ')' */
if (TYPE(CHILD(n, 0)) == LPAR)
com_fplist(c, CHILD(n, 1));
- else
+ else {
com_addoparg(c, STORE_FAST, com_newlocal(c, STR(CHILD(n, 0))));
+ com_pop(c, 1);
+ }
}
static void
com_fpdef(c, CHILD(n, 0));
}
else {
- int i;
- com_addoparg(c, UNPACK_TUPLE, (NCH(n)+1)/2);
+ int i = (NCH(n)+1)/2;
+ com_addoparg(c, UNPACK_TUPLE, i);
+ com_push(c, i-1);
for (i = 0; i < NCH(n); i += 2)
com_fpdef(c, CHILD(n, i));
}
fp = CHILD(ch, 0);
if (TYPE(fp) != NAME) {
com_addoparg(c, LOAD_FAST, ilocal);
+ com_push(c, 1);
com_fpdef(c, ch);
}
ilocal++;
int i = com_addconst(c, doc);
DECREF(doc);
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
com_addopnamestr(c, STORE_NAME, "__doc__");
+ com_pop(c, 1);
}
for (i = 0; i < NCH(n); i++) {
node *ch = CHILD(n, i);
com_node(c, CHILD(n, 4));
c->c_infunction = 0;
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
}
static void
ch = CHILD(n, 2);
com_node(c, ch);
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
}
static void
int i = com_addconst(c, doc);
DECREF(doc);
com_addoparg(c, LOAD_CONST, i);
+ com_push(c, 1);
com_addopnamestr(c, STORE_NAME, "__doc__");
+ com_pop(c, 1);
}
else
(void) com_addconst(c, None);
com_node(c, ch);
com_addbyte(c, LOAD_LOCALS);
+ com_push(c, 1);
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
}
static void
if (TYPE(n) != NEWLINE)
com_node(c, n);
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
c->c_interactive--;
break;
case file_input: /* A whole file, or built-in function exec() */
com_file_input(c, n);
com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_push(c, 1);
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
break;
case eval_input: /* Built-in function input() */
com_node(c, CHILD(n, 0));
com_addbyte(c, RETURN_VALUE);
+ com_pop(c, 1);
break;
case lambdef: /* anonymous function definition */
break;
default:
- fprintf(stderr, "node type %d\n", TYPE(n));
+ /* XXX fprintf(stderr, "node type %d\n", TYPE(n)); */
com_error(c, SystemError,
"compile_node: unexpected node type");
}
if (!err_occurred())
co = newcodeobject(sc.c_argcount,
sc.c_nlocals,
+ sc.c_maxstacklevel,
sc.c_flags,
sc.c_code,
consts,
projects / python / commitdiff