--- /dev/null
+/* Evaluate compiled expression nodes */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "string.h"
+
+#include "PROTO.h"
+#include "object.h"
+#include "objimpl.h"
+#include "intobject.h"
+#include "stringobject.h"
+#include "tupleobject.h"
+#include "listobject.h"
+#include "dictobject.h"
+#include "builtinobject.h"
+#include "methodobject.h"
+#include "moduleobject.h"
+#include "context.h"
+#include "funcobject.h"
+#include "classobject.h"
+#include "token.h"
+#include "graminit.h"
+#include "run.h"
+#include "import.h"
+#include "support.h"
+#include "sysmodule.h"
+#include "compile.h"
+#include "opcode.h"
+
+/* List access macros */
+#ifdef NDEBUG
+#define GETITEM(v, i) GETLISTITEM((listobject *)(v), (i))
+#define GETITEMNAME(v, i) GETSTRINGVALUE((stringobject *)GETITEM((v), (i)))
+#else
+#define GETITEM(v, i) getlistitem((v), (i))
+#define GETITEMNAME(v, i) getstringvalue(getlistitem((v), (i)))
+#endif
+
+typedef struct {
+ int b_type; /* what kind of block this is */
+ int b_handler; /* where to jump to find handler */
+ int b_level; /* value stack level to pop to */
+} block;
+
+typedef struct _frame {
+ OB_HEAD
+ struct _frame *f_back; /* previous frame, or NULL */
+ codeobject *f_code; /* code segment */
+ object *f_locals; /* local symbol table (dictobject) */
+ object *f_globals; /* global symbol table (dictobject) */
+ object **f_valuestack; /* malloc'ed array */
+ block *f_blockstack; /* malloc'ed array */
+ int f_nvalues; /* size of f_valuestack */
+ int f_nblocks; /* size of f_blockstack */
+ int f_ivalue; /* index in f_valuestack */
+ int f_iblock; /* index in f_blockstack */
+ int f_nexti; /* index in f_code (next instruction) */
+} frameobject;
+
+#define is_frameobject(op) ((op)->ob_type == &Frametype)
+
+static void
+frame_dealloc(f)
+ frameobject *f;
+{
+ XDECREF(f->f_back);
+ XDECREF(f->f_code);
+ XDECREF(f->f_locals);
+ XDECREF(f->f_globals);
+ XDEL(f->f_valuestack);
+ XDEL(f->f_blockstack);
+ DEL(f);
+}
+typeobject Frametype = {
+ OB_HEAD_INIT(&Typetype)
+ 0,
+ "frame",
+ sizeof(frameobject),
+ 0,
+ frame_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+};
+
+static frameobject * newframeobject PROTO(
+ (frameobject *, codeobject *, object *, object *, int, int));
+
+static frameobject *
+newframeobject(back, code, locals, globals, nvalues, nblocks)
+ frameobject *back;
+ codeobject *code;
+ object *locals;
+ object *globals;
+ int nvalues;
+ int nblocks;
+{
+ frameobject *f;
+ if ((back != NULL && !is_frameobject(back)) ||
+ code == NULL || !is_codeobject(code) ||
+ locals == NULL || !is_dictobject(locals) ||
+ globals == NULL || !is_dictobject(globals) ||
+ nvalues < 0 || nblocks < 0) {
+ err_badcall();
+ return NULL;
+ }
+ f = NEWOBJ(frameobject, &Frametype);
+ if (f != NULL) {
+ if (back)
+ INCREF(back);
+ f->f_back = back;
+ INCREF(code);
+ f->f_code = code;
+ INCREF(locals);
+ f->f_locals = locals;
+ INCREF(globals);
+ f->f_globals = globals;
+ f->f_valuestack = NEW(object *, nvalues+1);
+ f->f_blockstack = NEW(block, nblocks+1);
+ f->f_nvalues = nvalues;
+ f->f_nblocks = nblocks;
+ f->f_ivalue = f->f_iblock = f->f_nexti = 0;
+ if (f->f_valuestack == NULL || f->f_blockstack == NULL) {
+ err_nomem();
+ DECREF(f);
+ f = NULL;
+ }
+ }
+ return f;
+}
+
+#define Push(f, v) ((f)->f_valuestack[(f)->f_ivalue++] = (v))
+#define Pop(f) ((f)->f_valuestack[--(f)->f_ivalue])
+#define Top(f) ((f)->f_valuestack[(f)->f_ivalue-1])
+#define Empty(f) ((f)->f_ivalue == 0)
+#define Full(f) ((f)->f_ivalue == (f)->f_nvalues)
+#define Nextbyte(f) (GETSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti++])
+#define Peekbyte(f) (GETSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti])
+#define Prevbyte(f) (GETSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti-1])
+#define Jumpto(f, x) ((f)->f_nexti = (x))
+#define Jumpby(f, x) ((f)->f_nexti += (x))
+#define Getconst(f, i) (GETITEM((f)->f_code->co_consts, (i)))
+#define Getname(f, i) (GETITEMNAME((f)->f_code->co_names, (i)))
+
+/* Corresponding functions, for debugging */
+
+static void
+push(f, v)
+ frameobject *f;
+ object *v;
+{
+ if (Full(f)) {
+ printf("stack overflow\n");
+ abort();
+ }
+ Push(f, v);
+}
+
+static object *
+pop(f)
+ frameobject *f;
+{
+ if (Empty(f)) {
+ printf("stack underflow\n");
+ abort();
+ }
+ return Pop(f);
+}
+
+static object *
+top(f)
+ frameobject *f;
+{
+ if (Empty(f)) {
+ printf("stack underflow\n");
+ abort();
+ }
+ return Top(f);
+}
+
+static int
+nextbyte(f)
+ frameobject *f;
+{
+ stringobject *code = (f)->f_code->co_code;
+ if (f->f_nexti >= getstringsize((object *)code)) {
+ printf("ran off end of instructions\n");
+ abort();
+ }
+ return GETSTRINGVALUE(code)[f->f_nexti++];
+}
+
+/* Tracing versions */
+
+static void
+trace_push(f, v)
+ frameobject *f;
+ object *v;
+{
+ printf("\tpush ");
+ printobject(v, stdout, 0);
+ printf("\n");
+ push(f, v);
+}
+
+static object *
+trace_pop(f)
+ frameobject *f;
+{
+ object *v;
+ v = pop(f);
+ printf("\tpop ");
+ printobject(v, stdout, 0);
+ printf("\n");
+ return v;
+}
+
+static object *
+trace_top(f)
+ frameobject *f;
+{
+ object *v;
+ v = top(f);
+ printf("\ttop ");
+ printobject(v, stdout, 0);
+ printf("\n");
+ return v;
+}
+
+static int
+trace_nextop(f)
+ frameobject *f;
+{
+ int op;
+ int arg;
+
+ printf("%d: ", f->f_nexti);
+ op = nextbyte(f);
+ if (op < HAVE_ARGUMENT)
+ printf("op %3d\n", op);
+ else {
+ arg = Peekbyte(f);
+ printf("op %3d arg %3d\n", op, arg);
+ }
+ return op;
+}
+
+/* Block management */
+
+static void
+setup_block(f, type, handler)
+ frameobject *f;
+ int type;
+ int handler;
+{
+ block *b;
+ if (f->f_iblock >= f->f_nblocks) {
+ printf("block stack overflow\n");
+ abort();
+ }
+ b = &f->f_blockstack[f->f_iblock++];
+ b->b_type = type;
+ b->b_level = f->f_ivalue;
+ b->b_handler = handler + f->f_nexti;
+}
+
+static block *
+pop_block(f)
+ frameobject *f;
+{
+ block *b;
+ if (f->f_iblock <= 0) {
+ printf("block stack underflow\n");
+ abort();
+ }
+ b = &f->f_blockstack[--f->f_iblock];
+ while (f->f_ivalue > b->b_level) {
+ object *v = Pop(f);
+ XDECREF(v);
+ }
+ return b;
+}
+
+
+/* XXX Mixing "print ...," and direct file I/O on stdin/stdout
+ XXX has some bad consequences. The needspace flag should
+ XXX really be part of the file object. */
+
+static int needspace;
+
+void
+flushline()
+{
+ FILE *fp = sysgetfile("stdout", stdout);
+ if (needspace) {
+ fprintf(fp, "\n");
+ needspace = 0;
+ }
+}
+
+static object *
+checkerror(ctx, v)
+ context *ctx;
+ object *v;
+{
+ if (v == NULL)
+ puterrno(ctx);
+ return v;
+}
+
+static object *
+add(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ if (v->ob_type->tp_as_number != NULL)
+ v = (*v->ob_type->tp_as_number->nb_add)(v, w);
+ else if (v->ob_type->tp_as_sequence != NULL)
+ v = (*v->ob_type->tp_as_sequence->sq_concat)(v, w);
+ else {
+ type_error(ctx, "+ not supported by operands");
+ return NULL;
+ }
+ return checkerror(ctx, v);
+}
+
+static object *
+sub(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ if (v->ob_type->tp_as_number != NULL)
+ return checkerror(ctx,
+ (*v->ob_type->tp_as_number->nb_subtract)(v, w));
+ type_error(ctx, "bad operand type(s) for -");
+ return NULL;
+}
+
+static object *
+mul(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ typeobject *tp;
+ if (is_intobject(v) && w->ob_type->tp_as_sequence != NULL) {
+ /* int*sequence -- swap v and w */
+ object *tmp = v;
+ v = w;
+ w = tmp;
+ }
+ tp = v->ob_type;
+ if (tp->tp_as_number != NULL)
+ return checkerror(ctx, (*tp->tp_as_number->nb_multiply)(v, w));
+ if (tp->tp_as_sequence != NULL) {
+ if (!is_intobject(w)) {
+ type_error(ctx, "can't multiply sequence with non-int");
+ return NULL;
+ }
+ if (tp->tp_as_sequence->sq_repeat == NULL) {
+ type_error(ctx, "sequence does not support *");
+ return NULL;
+ }
+ return checkerror(ctx, (*tp->tp_as_sequence->sq_repeat)
+ (v, (int)getintvalue(w)));
+ }
+ type_error(ctx, "bad operand type(s) for *");
+ return NULL;
+}
+
+static object *
+div(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ if (v->ob_type->tp_as_number != NULL)
+ return checkerror(ctx,
+ (*v->ob_type->tp_as_number->nb_divide)(v, w));
+ type_error(ctx, "bad operand type(s) for /");
+ return NULL;
+}
+
+static object *
+rem(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ if (v->ob_type->tp_as_number != NULL)
+ return checkerror(ctx,
+ (*v->ob_type->tp_as_number->nb_remainder)(v, w));
+ type_error(ctx, "bad operand type(s) for %");
+ return NULL;
+}
+
+static object *
+neg(ctx, v)
+ context *ctx;
+ object *v;
+{
+ if (v->ob_type->tp_as_number != NULL)
+ return checkerror(ctx,
+ (*v->ob_type->tp_as_number->nb_negative)(v));
+ type_error(ctx, "bad operand type(s) for unary -");
+ return NULL;
+}
+
+static object *
+pos(ctx, v)
+ context *ctx;
+ object *v;
+{
+ if (v->ob_type->tp_as_number != NULL)
+ return checkerror(ctx,
+ (*v->ob_type->tp_as_number->nb_positive)(v));
+ type_error(ctx, "bad operand type(s) for unary +");
+ return NULL;
+}
+
+static object *
+not(ctx, v)
+ context *ctx;
+ object *v;
+{
+ int outcome = testbool(ctx, v);
+ if (ctx->ctx_exception)
+ return NULL;
+ return checkerror(ctx, newintobject((long) !outcome));
+}
+
+static object *
+call_builtin(ctx, func, args)
+ context *ctx;
+ object *func;
+ object *args;
+{
+ if (is_builtinobject(func)) {
+ function funcptr = getbuiltinfunction(func);
+ return (*funcptr)(ctx, args);
+ }
+ if (is_methodobject(func)) {
+ method meth = getmethod(func);
+ object *self = getself(func);
+ return checkerror(ctx, (*meth)(self, args));
+ }
+ if (is_classobject(func)) {
+ if (args != NULL) {
+ type_error(ctx, "classobject() allows no arguments");
+ return NULL;
+ }
+ return checkerror(ctx, newclassmemberobject(func));
+ }
+ type_error(ctx, "call of non-function");
+ return NULL;
+}
+
+static object *eval_compiled PROTO((context *, codeobject *, object *, int));
+
+/* XXX Eventually, this should not call eval_compiled recursively
+ but create a new frame */
+
+static object *
+call_function(ctx, func, args)
+ context *ctx;
+ object *func;
+ object *args;
+{
+ object *newargs = NULL;
+ object *savelocals, *newlocals, *saveglobals;
+ object *c, *v;
+
+ if (is_classmethodobject(func)) {
+ object *self = classmethodgetself(func);
+ func = classmethodgetfunc(func);
+ if (args == NULL) {
+ args = self;
+ }
+ else {
+ newargs = checkerror(ctx, newtupleobject(2));
+ if (newargs == NULL)
+ return NULL;
+ INCREF(self);
+ INCREF(args);
+ settupleitem(newargs, 0, self);
+ settupleitem(newargs, 1, args);
+ args = newargs;
+ }
+ }
+ else {
+ if (!is_funcobject(func)) {
+ type_error(ctx, "call of non-function");
+ return NULL;
+ }
+ }
+
+ c = checkerror(ctx, getfunccode(func));
+ if (c == NULL) {
+ XDECREF(newargs);
+ return NULL;
+ }
+ if (!is_codeobject(c)) {
+ printf("Bad code\n");
+ abort();
+ }
+ newlocals = checkerror(ctx, newdictobject());
+ if (newlocals == NULL) {
+ XDECREF(newargs);
+ return NULL;
+ }
+
+ savelocals = ctx->ctx_locals;
+ ctx->ctx_locals = newlocals;
+ saveglobals = ctx->ctx_globals;
+ ctx->ctx_globals = getfuncglobals(func);
+
+ v = eval_compiled(ctx, (codeobject *)c, args, 1);
+
+ DECREF(ctx->ctx_locals);
+ ctx->ctx_locals = savelocals;
+ ctx->ctx_globals = saveglobals;
+
+ XDECREF(newargs);
+
+ return v;
+}
+
+static object *
+apply_subscript(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ typeobject *tp = v->ob_type;
+ if (tp->tp_as_sequence == NULL && tp->tp_as_mapping == NULL) {
+ type_error(ctx, "unsubscriptable object");
+ return NULL;
+ }
+ if (tp->tp_as_sequence != NULL) {
+ int i;
+ if (!is_intobject(w)) {
+ type_error(ctx, "sequence subscript not int");
+ return NULL;
+ }
+ i = getintvalue(w);
+ return checkerror(ctx, (*tp->tp_as_sequence->sq_item)(v, i));
+ }
+ return checkerror(ctx, (*tp->tp_as_mapping->mp_subscript)(v, w));
+}
+
+static object *
+loop_subscript(ctx, v, w)
+ context *ctx;
+ object *v, *w;
+{
+ sequence_methods *sq = v->ob_type->tp_as_sequence;
+ int i, n;
+ if (sq == NULL) {
+ type_error(ctx, "loop over non-sequence");
+ return NULL;
+ }
+ i = getintvalue(w);
+ n = (*sq->sq_length)(v);
+ if (i >= n)
+ return NULL; /* End of loop */
+ return checkerror(ctx, (*sq->sq_item)(v, i));
+}
+
+static int
+slice_index(ctx, v, isize, pi)
+ context *ctx;
+ object *v;
+ int isize;
+ int *pi;
+{
+ if (v != NULL) {
+ if (!is_intobject(v)) {
+ type_error(ctx, "slice index must be int");
+ return 0;
+ }
+ *pi = getintvalue(v);
+ if (*pi < 0)
+ *pi += isize;
+ }
+ return 1;
+}
+
+static object *
+apply_slice(ctx, u, v, w) /* u[v:w] */
+ context *ctx;
+ object *u, *v, *w;
+{
+ typeobject *tp = u->ob_type;
+ int ilow, ihigh, isize;
+ if (tp->tp_as_sequence == NULL) {
+ type_error(ctx, "only sequences can be sliced");
+ return NULL;
+ }
+ ilow = 0;
+ isize = ihigh = (*tp->tp_as_sequence->sq_length)(u);
+ if (!slice_index(ctx, v, isize, &ilow))
+ return NULL;
+ if (!slice_index(ctx, w, isize, &ihigh))
+ return NULL;
+ return checkerror(ctx, (*tp->tp_as_sequence->sq_slice)(u, ilow, ihigh));
+}
+static void
+assign_subscript(ctx, w, key, v)
+ context *ctx;
+ object *w;
+ object *key;
+ object *v;
+{
+ typeobject *tp = w->ob_type;
+ sequence_methods *sq;
+ mapping_methods *mp;
+ int (*func)();
+ int err;
+ if ((sq = tp->tp_as_sequence) != NULL &&
+ (func = sq->sq_ass_item) != NULL) {
+ if (!is_intobject(key)) {
+ type_error(ctx, "sequence subscript must be integer");
+ return;
+ }
+ err = (*func)(w, (int)getintvalue(key), v);
+ }
+ else if ((mp = tp->tp_as_mapping) != NULL &&
+ (func = mp->mp_ass_subscript) != NULL) {
+ err = (*func)(w, key, v);
+ }
+ else {
+ type_error(ctx, "can't assign to this subscripted object");
+ return;
+ }
+ if (err != 0)
+ puterrno(ctx);
+}
+
+static void
+assign_slice(ctx, u, v, w, x) /* u[v:w] = x */
+ context *ctx;
+ object *u, *v, *w, *x;
+{
+ typeobject *tp = u->ob_type;
+ int ilow, ihigh, isize;
+ if (tp->tp_as_sequence == NULL ||
+ tp->tp_as_sequence->sq_ass_slice == NULL) {
+ type_error(ctx, "unassignable slice");
+ return;
+ }
+ ilow = 0;
+ isize = ihigh = (*tp->tp_as_sequence->sq_length)(u);
+ if (!slice_index(ctx, v, isize, &ilow))
+ return;
+ if (!slice_index(ctx, w, isize, &ihigh))
+ return;
+ if ((*tp->tp_as_sequence->sq_ass_slice)(u, ilow, ihigh, x) != 0)
+ puterrno(ctx);
+}
+
+static int
+cmp_exception(err, v)
+ object *err, *v;
+{
+ if (is_tupleobject(v)) {
+ int i, n;
+ n = gettuplesize(v);
+ for (i = 0; i < n; i++) {
+ if (err == gettupleitem(v, i))
+ return 1;
+ }
+ return 0;
+ }
+ return err == v;
+}
+
+static object *
+cmp_outcome(ctx, op, v, w)
+ register context *ctx;
+ enum cmp_op op;
+ register object *v;
+ register object *w;
+{
+ register int cmp;
+ register int res = 0;
+ switch (op) {
+ case IN:
+ case NOT_IN:
+ cmp = cmp_member(ctx, v, w);
+ break;
+ case IS:
+ case IS_NOT:
+ cmp = (v == w);
+ break;
+ case EXC_MATCH:
+ cmp = cmp_exception(v, w);
+ break;
+ default:
+ cmp = cmp_values(ctx, v, w);
+ }
+ if (ctx->ctx_exception)
+ return NULL;
+ switch (op) {
+ case EXC_MATCH:
+ case IS:
+ case IN: res = cmp; break;
+ case IS_NOT:
+ case NOT_IN: res = !cmp; break;
+ case LT: res = cmp < 0; break;
+ case LE: res = cmp <= 0; break;
+ case EQ: res = cmp == 0; break;
+ case NE: res = cmp != 0; break;
+ case GT: res = cmp > 0; break;
+ case GE: res = cmp >= 0; break;
+ /* XXX no default? */
+ }
+ v = res ? True : False;
+ INCREF(v);
+ return v;
+}
+
+static object *
+eval_compiled(ctx, co, arg, needvalue)
+ context *ctx;
+ codeobject *co;
+ object *arg;
+ int needvalue;
+{
+ frameobject *f;
+ register object *v;
+ register object *w;
+ register object *u;
+ register object *x;
+ char *name;
+ int n, i;
+ enum cmp_op op;
+ FILE *fp;
+#ifndef NDEBUG
+ int trace = dictlookup(ctx->ctx_globals, "__trace") != NULL;
+#endif
+
+ f = newframeobject(
+ (frameobject *)NULL, /*back*/
+ co, /*code*/
+ ctx->ctx_locals, /*locals*/
+ ctx->ctx_globals, /*globals*/
+ 50, /*nvalues*/
+ 20); /*nblocks*/
+ if (f == NULL) {
+ puterrno(ctx);
+ return NULL;
+ }
+
+#define EMPTY() Empty(f)
+#define FULL() Full(f)
+#define GETCONST(i) Getconst(f, i)
+#define GETNAME(i) Getname(f, i)
+#define JUMPTO(x) Jumpto(f, x)
+#define JUMPBY(x) Jumpby(f, x)
+
+#ifdef NDEBUG
+
+#define PUSH(v) Push(f, v)
+#define TOP() Top(f)
+#define POP() Pop(f)
+#define NEXTOP() Nextbyte(f)
+#define NEXTI() Nextbyte(f)
+
+#else
+
+#define PUSH(v) if(trace) trace_push(f, v); else push(f, v)
+#define TOP() (trace ? trace_top(f) : top(f))
+#define POP() (trace ? trace_pop(f) : pop(f))
+#define NEXTOP() (trace ? trace_nextop(f) : nextbyte(f))
+#define NEXTI() (nextbyte(f))
+
+#endif
+
+ if (arg != NULL) {
+ INCREF(arg);
+ PUSH(arg);
+ }
+
+ while (f->f_nexti < getstringsize((object *)f->f_code->co_code) &&
+ !ctx->ctx_exception) {
+
+ switch (NEXTOP()) {
+
+ case DUP_TOP:
+ v = TOP();
+ INCREF(v);
+ PUSH(v);
+ break;
+
+ case POP_TOP:
+ v = POP();
+ DECREF(v);
+ break;
+
+ case ROT_TWO:
+ v = POP();
+ w = POP();
+ PUSH(v);
+ PUSH(w);
+ break;
+
+ case ROT_THREE:
+ v = POP();
+ w = POP();
+ x = POP();
+ PUSH(v);
+ PUSH(x);
+ PUSH(w);
+ break;
+
+ case UNARY_POSITIVE:
+ v = POP();
+ u = pos(ctx, v);
+ DECREF(v);
+ PUSH(u);
+ break;
+
+ case UNARY_NEGATIVE:
+ v = POP();
+ u = neg(ctx, v);
+ DECREF(v);
+ PUSH(u);
+ break;
+
+ case UNARY_NOT:
+ v = POP();
+ u = not(ctx, v);
+ DECREF(v);
+ PUSH(u);
+ break;
+
+ case UNARY_CONVERT:
+ v = POP();
+ u = checkerror(ctx, reprobject(v));
+ DECREF(v);
+ PUSH(u);
+ break;
+
+ case UNARY_CALL:
+ v = POP();
+ if (is_classmemberobject(v) || is_funcobject(v))
+ u = call_function(ctx, v, (object *)NULL);
+ else
+ u = call_builtin(ctx, v, (object *)NULL);
+ DECREF(v);
+ PUSH(u);
+ break;
+
+ case BINARY_MULTIPLY:
+ w = POP();
+ v = POP();
+ u = mul(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case BINARY_DIVIDE:
+ w = POP();
+ v = POP();
+ u = div(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case BINARY_MODULO:
+ w = POP();
+ v = POP();
+ u = rem(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case BINARY_ADD:
+ w = POP();
+ v = POP();
+ u = add(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case BINARY_SUBTRACT:
+ w = POP();
+ v = POP();
+ u = sub(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case BINARY_SUBSCR:
+ w = POP();
+ v = POP();
+ u = apply_subscript(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case BINARY_CALL:
+ w = POP();
+ v = POP();
+ if (is_classmemberobject(v) || is_funcobject(v))
+ u = call_function(ctx, v, w);
+ else
+ u = call_builtin(ctx, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case SLICE:
+ w = NULL;
+ v = NULL;
+ u = POP();
+ x = apply_slice(ctx, u, v, w);
+ DECREF(u);
+ PUSH(x);
+ break;
+
+ case SLICE+1:
+ w = NULL;
+ v = POP();
+ u = POP();
+ x = apply_slice(ctx, u, v, w);
+ DECREF(u);
+ DECREF(v);
+ PUSH(x);
+ break;
+
+ case SLICE+2:
+ w = POP();
+ v = NULL;
+ u = POP();
+ x = apply_slice(ctx, u, v, w);
+ DECREF(u);
+ DECREF(w);
+ PUSH(x);
+ break;
+
+ case SLICE+3:
+ w = POP();
+ v = POP();
+ u = POP();
+ x = apply_slice(ctx, u, v, w);
+ DECREF(u);
+ DECREF(v);
+ DECREF(w);
+ PUSH(x);
+ break;
+
+ case STORE_SLICE:
+ w = NULL;
+ v = NULL;
+ u = POP();
+ x = POP();
+ assign_slice(ctx, u, v, w, x); /* u[:] = x */
+ DECREF(x);
+ DECREF(u);
+ break;
+
+ case STORE_SLICE+1:
+ w = NULL;
+ v = POP();
+ u = POP();
+ x = POP();
+ assign_slice(ctx, u, v, w, x); /* u[v:] = x */
+ DECREF(x);
+ DECREF(u);
+ DECREF(v);
+ break;
+
+ case STORE_SLICE+2:
+ w = POP();
+ v = NULL;
+ u = POP();
+ x = POP();
+ assign_slice(ctx, u, v, w, x); /* u[:w] = x */
+ DECREF(x);
+ DECREF(u);
+ DECREF(w);
+ break;
+
+ case STORE_SLICE+3:
+ w = POP();
+ v = POP();
+ u = POP();
+ x = POP();
+ assign_slice(ctx, u, v, w, x); /* u[v:w] = x */
+ DECREF(x);
+ DECREF(u);
+ DECREF(v);
+ DECREF(w);
+ break;
+
+ case DELETE_SLICE:
+ w = NULL;
+ v = NULL;
+ u = POP();
+ x = NULL;
+ assign_slice(ctx, u, v, w, x); /* del u[:] */
+ DECREF(u);
+ break;
+
+ case DELETE_SLICE+1:
+ w = NULL;
+ v = POP();
+ u = POP();
+ x = NULL;
+ assign_slice(ctx, u, v, w, x); /* del u[v:] */
+ DECREF(u);
+ DECREF(v);
+ break;
+
+ case DELETE_SLICE+2:
+ w = POP();
+ v = NULL;
+ u = POP();
+ x = NULL;
+ assign_slice(ctx, u, v, w, x); /* del u[:w] */
+ DECREF(u);
+ DECREF(w);
+ break;
+
+ case DELETE_SLICE+3:
+ w = POP();
+ v = POP();
+ u = POP();
+ x = NULL;
+ assign_slice(ctx, u, v, w, x); /* del u[v:w] */
+ DECREF(u);
+ DECREF(v);
+ DECREF(w);
+ break;
+
+ case STORE_SUBSCR:
+ w = POP();
+ v = POP();
+ u = POP();
+ /* v[w] = u */
+ assign_subscript(ctx, v, w, u);
+ DECREF(u);
+ DECREF(v);
+ DECREF(w);
+ break;
+
+ case DELETE_SUBSCR:
+ w = POP();
+ v = POP();
+ /* del v[w] */
+ assign_subscript(ctx, v, w, (object *)NULL);
+ DECREF(v);
+ DECREF(w);
+ break;
+
+ case PRINT_EXPR:
+ v = POP();
+ fp = sysgetfile("stdout", stdout);
+ /* Print value except if procedure result */
+ if (v != None) {
+ flushline();
+ printobject(v, fp, 0);
+ fprintf(fp, "\n");
+ }
+ DECREF(v);
+ break;
+
+ case PRINT_ITEM:
+ v = POP();
+ fp = sysgetfile("stdout", stdout);
+ if (needspace)
+ fprintf(fp, " ");
+ if (is_stringobject(v)) {
+ char *s = getstringvalue(v);
+ int len = getstringsize(v);
+ fwrite(s, 1, len, fp);
+ if (len > 0 && s[len-1] == '\n')
+ needspace = 0;
+ else
+ needspace = 1;
+ }
+ else {
+ printobject(v, fp, 0);
+ needspace = 1;
+ }
+ DECREF(v);
+ break;
+
+ case PRINT_NEWLINE:
+ fp = sysgetfile("stdout", stdout);
+ fprintf(fp, "\n");
+ needspace = 0;
+ break;
+
+ case BREAK_LOOP:
+ raise_pseudo(ctx, BREAK_PSEUDO);
+ break;
+
+ case RAISE_EXCEPTION:
+ v = POP();
+ w = POP();
+ if (!is_stringobject(w)) {
+ DECREF(v);
+ DECREF(v);
+ type_error(ctx, "exceptions must be strings");
+ }
+ else {
+ raise_exception(ctx, w, v);
+ }
+ break;
+
+ case RETURN_VALUE:
+ v = POP();
+ raise_pseudo(ctx, RETURN_PSEUDO);
+ ctx->ctx_errval = v;
+ break;
+
+ case REQUIRE_ARGS:
+ if (EMPTY())
+ type_error(ctx,
+ "function expects argument(s)");
+ break;
+
+ case REFUSE_ARGS:
+ if (!EMPTY())
+ type_error(ctx,
+ "function expects no argument(s)");
+ break;
+
+ case BUILD_FUNCTION:
+ v = POP();
+ x = checkerror(ctx, newfuncobject(v, ctx->ctx_globals));
+ DECREF(v);
+ PUSH(x);
+ break;
+
+ case POP_BLOCK:
+ (void) pop_block(f);
+ break;
+
+ case END_FINALLY:
+ v = POP();
+ w = POP();
+ if (is_intobject(v)) {
+ raise_pseudo(ctx, (int)getintvalue(v));
+ DECREF(v);
+ if (w == None)
+ DECREF(w);
+ else
+ ctx->ctx_errval = w;
+ }
+ else if (is_stringobject(v))
+ raise_exception(ctx, v, w);
+ else if (v == None) {
+ DECREF(v);
+ DECREF(w);
+ }
+ else {
+ sys_error(ctx, "'finally' pops bad exception");
+ }
+ break;
+
+ case STORE_NAME:
+ i = NEXTI();
+ name = GETNAME(i);
+ v = POP();
+ if (dictinsert(ctx->ctx_locals, name, v) != 0)
+ mem_error(ctx, "insert in symbol table");
+ DECREF(v);
+ break;
+
+ case DELETE_NAME:
+ i = NEXTI();
+ name = GETNAME(i);
+ if (dictremove(ctx->ctx_locals, name) != 0)
+ name_error(ctx, name);
+ break;
+
+ case UNPACK_TUPLE:
+ n = NEXTI();
+ v = POP();
+ if (!is_tupleobject(v)) {
+ type_error(ctx, "unpack non-tuple");
+ }
+ else if (gettuplesize(v) != n) {
+ error(ctx, "unpack tuple of wrong size");
+ }
+ else {
+ for (i = n; --i >= 0; ) {
+ w = gettupleitem(v, i);
+ INCREF(w);
+ PUSH(w);
+ }
+ }
+ DECREF(v);
+ break;
+
+ case UNPACK_LIST:
+ n = NEXTI();
+ v = POP();
+ if (!is_listobject(v)) {
+ type_error(ctx, "unpack non-list");
+ }
+ else if (getlistsize(v) != n) {
+ error(ctx, "unpack tuple of wrong size");
+ }
+ else {
+ for (i = n; --i >= 0; ) {
+ w = getlistitem(v, i);
+ INCREF(w);
+ PUSH(w);
+ }
+ }
+ DECREF(v);
+ break;
+
+ case STORE_ATTR:
+ i = NEXTI();
+ name = GETNAME(i);
+ v = POP();
+ u = POP();
+ /* v.name = u */
+ if (v->ob_type->tp_setattr == NULL) {
+ type_error(ctx, "object without writable attributes");
+ }
+ else {
+ if ((*v->ob_type->tp_setattr)(v, name, u) != 0)
+ puterrno(ctx);
+ }
+ DECREF(v);
+ DECREF(u);
+ break;
+
+ case DELETE_ATTR:
+ i = NEXTI();
+ name = GETNAME(i);
+ v = POP();
+ /* del v.name */
+ if (v->ob_type->tp_setattr == NULL) {
+ type_error(ctx,
+ "object without writable attributes");
+ }
+ else {
+ if ((*v->ob_type->tp_setattr)
+ (v, name, (object *)NULL) != 0)
+ puterrno(ctx);
+ }
+ DECREF(v);
+ break;
+
+ case LOAD_CONST:
+ i = NEXTI();
+ v = GETCONST(i);
+ INCREF(v);
+ PUSH(v);
+ break;
+
+ case LOAD_NAME:
+ i = NEXTI();
+ name = GETNAME(i);
+ v = dictlookup(ctx->ctx_locals, name);
+ if (v == NULL) {
+ v = dictlookup(ctx->ctx_globals, name);
+ if (v == NULL)
+ v = dictlookup(ctx->ctx_builtins, name);
+ }
+ if (v == NULL)
+ name_error(ctx, name);
+ /* XXX could optimize */
+ else
+ INCREF(v);
+ PUSH(v);
+ break;
+
+ case BUILD_TUPLE:
+ n = NEXTI();
+ v = checkerror(ctx, newtupleobject(n));
+ if (v != NULL) {
+ for (i = n; --i >= 0;) {
+ w = POP();
+ settupleitem(v, i, w);
+ }
+ }
+ PUSH(v);
+ break;
+
+ case BUILD_LIST:
+ n = NEXTI();
+ v = checkerror(ctx, newlistobject(n));
+ if (v != NULL) {
+ for (i = n; --i >= 0;) {
+ w = POP();
+ setlistitem(v, i, w);
+ }
+ }
+ PUSH(v);
+ break;
+
+ case BUILD_MAP:
+ (void) NEXTI();
+ v = checkerror(ctx, newdictobject());
+ PUSH(v);
+ break;
+
+ case LOAD_ATTR:
+ i = NEXTI();
+ name = GETNAME(i);
+ v = POP();
+ if (v->ob_type->tp_getattr == NULL) {
+ type_error(ctx, "attribute-less object");
+ u = NULL;
+ }
+ else {
+ u = checkerror(ctx,
+ (*v->ob_type->tp_getattr)(v, name));
+ }
+ DECREF(v);
+ PUSH(u);
+ break;
+
+ case COMPARE_OP:
+ op = NEXTI();
+ w = POP();
+ v = POP();
+ u = cmp_outcome(ctx, op, v, w);
+ DECREF(v);
+ DECREF(w);
+ PUSH(u);
+ break;
+
+ case IMPORT_NAME:
+ i = NEXTI();
+ name = GETNAME(i);
+ u = import_module(ctx, name);
+ if (u != NULL) {
+ INCREF(u);
+ PUSH(u);
+ }
+ break;
+
+ case IMPORT_FROM:
+ i = NEXTI();
+ name = GETNAME(i);
+ v = TOP();
+ w = getmoduledict(v);
+ x = dictlookup(w, name);
+ if (x == NULL)
+ name_error(ctx, name);
+ else if (dictinsert(ctx->ctx_locals, name, x) != 0)
+ puterrno(ctx);
+ break;
+
+ /* WARNING!
+ Don't assign an expression containing NEXTI() directly
+ to nexti. This expands to "nexti = ... + *nexti++"
+ which has undefined evaluation order. On some machines
+ (e.g., mips!) the nexti++ is done after the assignment
+ to nexti. */
+
+ case JUMP_FORWARD:
+ n = NEXTI();
+ JUMPBY(n);
+ break;
+
+ case JUMP_IF_FALSE:
+ n = NEXTI();
+ if (!testbool(ctx, TOP()))
+ JUMPBY(n);
+ break;
+
+ case JUMP_IF_TRUE:
+ n = NEXTI();
+ if (testbool(ctx, TOP()))
+ JUMPBY(n);
+ break;
+
+ case JUMP_ABSOLUTE:
+ n = NEXTI();
+ JUMPTO(n);
+ /* XXX Should check for interrupts more often? */
+ if (intrcheck())
+ intr_error(ctx);
+ break;
+
+ case FOR_LOOP:
+ /* for v in s: ...
+ On entry: stack contains s, i.
+ On exit: stack contains s, i+1, s[i];
+ but if loop exhausted:
+ s, i are popped, and we jump n bytes */
+ n = NEXTI();
+ w = POP(); /* Loop index */
+ v = POP(); /* Sequence object */
+ x = loop_subscript(ctx, v, w);
+ if (x != NULL) {
+ PUSH(v);
+ u = checkerror(ctx,
+ newintobject(getintvalue(w)+1));
+ PUSH(u);
+ DECREF(w);
+ PUSH(x);
+ }
+ else {
+ DECREF(v);
+ DECREF(w);
+ JUMPBY(n);
+ }
+ break;
+
+ case SETUP_LOOP:
+ n = NEXTI();
+ setup_block(f, SETUP_LOOP, n);
+ break;
+
+ case SETUP_EXCEPT:
+ n = NEXTI();
+ setup_block(f, SETUP_EXCEPT, n);
+ break;
+
+ case SETUP_FINALLY:
+ n = NEXTI();
+ setup_block(f, SETUP_FINALLY, n);
+ break;
+
+ default:
+ printf("opcode %d\n", Prevbyte(f));
+ sys_error(ctx, "eval_compiled: unknown opcode");
+ break;
+
+ }
+
+ /* Unwind block stack if an exception occurred */
+
+ while (ctx->ctx_exception && f->f_iblock > 0) {
+ block *b = pop_block(f);
+ if (b->b_type == SETUP_LOOP &&
+ ctx->ctx_exception == BREAK_PSEUDO) {
+ clear_exception(ctx);
+ JUMPTO(b->b_handler);
+ break;
+ }
+ else if (b->b_type == SETUP_FINALLY ||
+ b->b_type == SETUP_EXCEPT &&
+ ctx->ctx_exception == CATCHABLE_EXCEPTION) {
+ v = ctx->ctx_errval;
+ if (v == NULL)
+ v = None;
+ INCREF(v);
+ PUSH(v);
+ v = ctx->ctx_error;
+ if (v == NULL)
+ v = newintobject(ctx->ctx_exception);
+ else
+ INCREF(v);
+ PUSH(v);
+ clear_exception(ctx);
+ JUMPTO(b->b_handler);
+ break;
+ }
+ }
+ }
+
+ if (ctx->ctx_exception) {
+ while (!EMPTY()) {
+ v = POP();
+ XDECREF(v);
+ }
+ v = NULL;
+ if (ctx->ctx_exception == RETURN_PSEUDO) {
+ if (needvalue) {
+ v = ctx->ctx_errval;
+ INCREF(v);
+ clear_exception(ctx);
+ }
+ else {
+ /* XXX Can detect this statically! */
+ type_error(ctx, "unexpected return statement");
+ }
+ }
+ }
+ else {
+ if (needvalue)
+ v = POP();
+ else
+ v = NULL;
+ if (!EMPTY()) {
+ sys_error(ctx, "stack not cleaned up");
+ XDECREF(v);
+ while (!EMPTY()) {
+ v = POP();
+ XDECREF(v);
+ }
+ v = NULL;
+ }
+ }
+
+#undef EMPTY
+#undef FULL
+#undef GETCONST
+#undef GETNAME
+#undef JUMPTO
+#undef JUMPBY
+
+#undef NEXTOP
+#undef NEXTI
+#undef POP
+#undef TOP
+#undef PUSH
+
+ DECREF(f);
+ return v;
+
+}
+
+/* Provisional interface until everything is compilable */
+
+#include "node.h"
+
+static object *
+eval_or_exec(ctx, n, arg, needvalue)
+ context *ctx;
+ node *n;
+ object *arg;
+ int needvalue;
+{
+ object *v;
+ codeobject *co = compile(n);
+ if (co == NULL) {
+ puterrno(ctx);
+ return NULL;
+ }
+ v = eval_compiled(ctx, co, arg, needvalue);
+ DECREF(co);
+ return v;
+}
+
+object *
+eval_node(ctx, n)
+ context *ctx;
+ node *n;
+{
+ return eval_or_exec(ctx, n, (object *)NULL, 1/*needvalue*/);
+}
+
+void
+exec_node(ctx, n)
+ context *ctx;
+ node *n;
+{
+ (void) eval_or_exec(ctx, n, (object *)NULL, 0/*needvalue*/);
+}
--- /dev/null
+#define DEBUG
+/* Compile an expression node to intermediate code */
+
+#include <stdio.h>
+#include <ctype.h>
+#include "string.h"
+
+#include "PROTO.h"
+#include "object.h"
+#include "objimpl.h"
+#include "intobject.h"
+#include "floatobject.h"
+#include "stringobject.h"
+#include "listobject.h"
+#include "node.h"
+#include "token.h"
+#include "graminit.h"
+#include "errors.h"
+#include "compile.h"
+#include "opcode.h"
+
+static void
+code_dealloc(c)
+ codeobject *c;
+{
+ XDECREF(c->co_code);
+ XDECREF(c->co_consts);
+ XDECREF(c->co_names);
+ DEL(c);
+}
+
+typeobject Codetype = {
+ OB_HEAD_INIT(&Typetype)
+ 0,
+ "code",
+ sizeof(codeobject),
+ 0,
+ code_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+};
+
+static codeobject *newcodeobject PROTO((object *, object *, object *));
+
+static codeobject *
+newcodeobject(code, consts, names)
+ object *code;
+ object *consts;
+ object *names;
+{
+ codeobject *co;
+ int i;
+ /* Check argument types */
+ if (code == NULL || !is_stringobject(code) ||
+ consts == NULL || !is_listobject(consts) ||
+ names == NULL || !is_listobject(names)) {
+ err_badcall();
+ return NULL;
+ }
+ /* Make sure the list of names contains only strings */
+ for (i = getlistsize(names); --i >= 0; ) {
+ object *v = getlistitem(names, i);
+ if (v == NULL || !is_stringobject(v)) {
+ err_badcall();
+ return NULL;
+ }
+ }
+ co = NEWOBJ(codeobject, &Codetype);
+ if (co != NULL) {
+ INCREF(code);
+ co->co_code = (stringobject *)code;
+ INCREF(consts);
+ co->co_consts = consts;
+ INCREF(names);
+ co->co_names = names;
+ }
+ return co;
+}
+
+
+/* Data structure used internally */
+struct compiling {
+ object *c_code; /* string */
+ object *c_consts; /* list of objects */
+ object *c_names; /* list of strings (names) */
+ int c_nexti; /* index into c_code */
+ int c_errors; /* counts errors occurred */
+};
+
+/* Prototypes */
+static int com_init PROTO((struct compiling *));
+static void com_free PROTO((struct compiling *));
+static void com_done PROTO((struct compiling *));
+static void com_node PROTO((struct compiling *, struct _node *));
+static void com_addbyte PROTO((struct compiling *, int));
+static void com_addint PROTO((struct compiling *, int));
+static void com_addoparg PROTO((struct compiling *, int, int));
+static void com_addfwref PROTO((struct compiling *, int, int *));
+static void com_backpatch PROTO((struct compiling *, int));
+static int com_add PROTO((struct compiling *, object *, object *));
+static int com_addconst PROTO((struct compiling *, object *));
+static int com_addname PROTO((struct compiling *, object *));
+static void com_addopname PROTO((struct compiling *, int, node *));
+
+static int
+com_init(c)
+ struct compiling *c;
+{
+ if ((c->c_code = newsizedstringobject((char *)NULL, 0)) == NULL)
+ goto fail_3;
+ if ((c->c_consts = newlistobject(0)) == NULL)
+ goto fail_2;
+ if ((c->c_names = newlistobject(0)) == NULL)
+ goto fail_1;
+ c->c_nexti = 0;
+ c->c_errors = 0;
+ return 1;
+
+ fail_1:
+ DECREF(c->c_consts);
+ fail_2:
+ DECREF(c->c_code);
+ fail_3:
+ return 0;
+}
+
+static void
+com_free(c)
+ struct compiling *c;
+{
+ XDECREF(c->c_code);
+ XDECREF(c->c_consts);
+ XDECREF(c->c_names);
+}
+
+static void
+com_done(c)
+ struct compiling *c;
+{
+ if (c->c_code != NULL)
+ resizestring(&c->c_code, c->c_nexti);
+}
+
+static void
+com_addbyte(c, byte)
+ struct compiling *c;
+ int byte;
+{
+ int len;
+ if (byte < 0 || byte > 255) {
+ err_setstr(SystemError, "com_addbyte: byte out of range");
+ c->c_errors++;
+ }
+ if (c->c_code == NULL)
+ return;
+ len = getstringsize(c->c_code);
+ if (c->c_nexti >= len) {
+ if (resizestring(&c->c_code, len+1000) != 0) {
+ c->c_errors++;
+ return;
+ }
+ }
+ getstringvalue(c->c_code)[c->c_nexti++] = byte;
+}
+
+static void
+com_addint(c, x)
+ struct compiling *c;
+ int x;
+{
+ com_addbyte(c, x);
+}
+
+static void
+com_addoparg(c, op, arg)
+ struct compiling *c;
+ int op;
+ int arg;
+{
+ com_addbyte(c, op);
+ com_addint(c, arg);
+}
+
+static void
+com_addfwref(c, op, p_anchor)
+ struct compiling *c;
+ int op;
+ int *p_anchor;
+{
+ /* Compile a forward reference for backpatching */
+ int here;
+ int anchor;
+ com_addbyte(c, op);
+ here = c->c_nexti;
+ anchor = *p_anchor;
+ *p_anchor = here;
+ com_addint(c, anchor == 0 ? 0 : here - anchor);
+}
+
+static void
+com_backpatch(c, anchor)
+ struct compiling *c;
+ int anchor; /* Must be nonzero */
+{
+ unsigned char *code = (unsigned char *) getstringvalue(c->c_code);
+ int target = c->c_nexti;
+ int lastanchor = 0;
+ int dist;
+ int prev;
+ for (;;) {
+ /* Make the JUMP instruction at anchor point to target */
+ prev = code[anchor];
+ dist = target - (anchor+1);
+ if (dist > 255 && lastanchor &&
+ code[lastanchor-1] == code[anchor-1]) {
+ /* Attempt to jump to a similar jump closer by */
+/* XXX Show that it works */
+fprintf(stderr, "com_backpatch: huge jump rescued (?)\n");
+ target = lastanchor-1;
+ dist = target - (anchor+1);
+ lastanchor = 0;
+ }
+ if (dist > 255) {
+ err_setstr(SystemError, "relative jump > 255 bytes");
+ c->c_errors++;
+ }
+ code[anchor] = dist;
+ if (!prev)
+ break;
+ lastanchor = anchor;
+ anchor -= prev;
+ }
+}
+
+/* Handle constants and names uniformly */
+
+static int
+com_add(c, list, v)
+ struct compiling *c;
+ object *list;
+ object *v;
+{
+ /* XXX Should look through list for object with same value */
+ int i = getlistsize(list);
+ if (addlistitem(list, v) != 0)
+ c->c_errors++;
+ return i;
+}
+
+static int
+com_addconst(c, v)
+ struct compiling *c;
+ object *v;
+{
+ return com_add(c, c->c_consts, v);
+}
+
+static int
+com_addname(c, v)
+ struct compiling *c;
+ object *v;
+{
+ return com_add(c, c->c_names, v);
+}
+
+static void
+com_addopname(c, op, n)
+ struct compiling *c;
+ int op;
+ node *n;
+{
+ object *v;
+ int i;
+ char *name;
+ if (TYPE(n) == STAR)
+ name = "*";
+ else {
+ REQ(n, NAME);
+ name = STR(n);
+ }
+ if ((v = newstringobject(name)) == NULL) {
+ c->c_errors++;
+ i = 255;
+ }
+ else {
+ i = com_addname(c, v);
+ DECREF(v);
+ }
+ com_addoparg(c, op, i);
+}
+
+static object *
+parsenumber(s)
+ char *s;
+{
+ extern long strtol();
+ extern double atof();
+ char *end = s;
+ long x;
+ x = strtol(s, &end, 0);
+ if (*end == '\0')
+ return newintobject(x);
+ if (*end == '.' || *end == 'e' || *end == 'E')
+ return newfloatobject(atof(s));
+ err_setstr(RuntimeError, "bad number syntax");
+ return NULL;
+}
+
+static object *
+parsestr(s)
+ char *s;
+{
+ object *v;
+ int len;
+ char *buf;
+ char *p;
+ int c;
+ if (*s != '\'') {
+ err_badcall();
+ return NULL;
+ }
+ s++;
+ len = strlen(s);
+ if (s[--len] != '\'') {
+ err_badcall();
+ return NULL;
+ }
+ if (strchr(s, '\\') == NULL)
+ return newsizedstringobject(s, len);
+ v = newsizedstringobject((char *)NULL, len);
+ p = buf = getstringvalue(v);
+ while (*s != '\0' && *s != '\'') {
+ if (*s != '\\') {
+ *p++ = *s++;
+ continue;
+ }
+ s++;
+ switch (*s++) {
+ /* XXX This assumes ASCII! */
+ case '\\': *p++ = '\\'; break;
+ case '\'': *p++ = '\''; break;
+ case 'b': *p++ = '\b'; break;
+ case 'f': *p++ = '\014'; break; /* FF */
+ case 't': *p++ = '\t'; break;
+ case 'n': *p++ = '\n'; break;
+ case 'r': *p++ = '\r'; break;
+ case 'v': *p++ = '\013'; break; /* VT */
+ case 'E': *p++ = '\033'; break; /* ESC, not C */
+ case 'a': *p++ = '\007'; break; /* BEL, not classic C */
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ c = s[-1] - '0';
+ if ('0' <= *s && *s <= '7') {
+ c = (c<<3) + *s++ - '0';
+ if ('0' <= *s && *s <= '7')
+ c = (c<<3) + *s++ - '0';
+ }
+ *p++ = c;
+ break;
+ case 'x':
+ if (isxdigit(*s)) {
+ sscanf(s, "%x", &c);
+ *p++ = c;
+ do {
+ s++;
+ } while (isxdigit(*s));
+ break;
+ }
+ /* FALLTHROUGH */
+ default: *p++ = '\\'; *p++ = s[-1]; break;
+ }
+ }
+ resizestring(&v, (int)(p - buf));
+ return v;
+}
+
+static void
+com_list_constructor(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int len;
+ int i;
+ object *v, *w;
+ if (TYPE(n) != testlist)
+ REQ(n, exprlist);
+ /* exprlist: expr (',' expr)* [',']; likewise for testlist */
+ len = (NCH(n) + 1) / 2;
+ for (i = 0; i < NCH(n); i += 2)
+ com_node(c, CHILD(n, i));
+ com_addoparg(c, BUILD_LIST, len);
+}
+
+static void
+com_atom(c, n)
+ struct compiling *c;
+ node *n;
+{
+ node *ch;
+ object *v;
+ int i;
+ REQ(n, atom);
+ ch = CHILD(n, 0);
+ switch (TYPE(ch)) {
+ case LPAR:
+ if (TYPE(CHILD(n, 1)) == RPAR)
+ com_addoparg(c, BUILD_TUPLE, 0);
+ else
+ com_node(c, CHILD(n, 1));
+ break;
+ case LSQB:
+ if (TYPE(CHILD(n, 1)) == RSQB)
+ com_addoparg(c, BUILD_LIST, 0);
+ else
+ com_list_constructor(c, CHILD(n, 1));
+ break;
+ case LBRACE:
+ com_addoparg(c, BUILD_MAP, 0);
+ break;
+ case BACKQUOTE:
+ com_node(c, CHILD(n, 1));
+ com_addbyte(c, UNARY_CONVERT);
+ break;
+ case NUMBER:
+ if ((v = parsenumber(STR(ch))) == NULL) {
+ c->c_errors++;
+ i = 255;
+ }
+ else {
+ i = com_addconst(c, v);
+ DECREF(v);
+ }
+ com_addoparg(c, LOAD_CONST, i);
+ break;
+ case STRING:
+ if ((v = parsestr(STR(ch))) == NULL) {
+ c->c_errors++;
+ i = 255;
+ }
+ else {
+ i = com_addconst(c, v);
+ DECREF(v);
+ }
+ com_addoparg(c, LOAD_CONST, i);
+ break;
+ case NAME:
+ com_addopname(c, LOAD_NAME, ch);
+ break;
+ default:
+ fprintf(stderr, "node type %d\n", TYPE(ch));
+ err_setstr(SystemError, "com_atom: unexpected node type");
+ c->c_errors++;
+ }
+}
+
+static void
+com_slice(c, n, op)
+ struct compiling *c;
+ node *n;
+ int op;
+{
+ if (NCH(n) == 1) {
+ com_addbyte(c, op);
+ }
+ else if (NCH(n) == 2) {
+ if (TYPE(CHILD(n, 0)) != COLON) {
+ com_node(c, CHILD(n, 0));
+ com_addbyte(c, op+1);
+ }
+ else {
+ com_node(c, CHILD(n, 1));
+ com_addbyte(c, op+2);
+ }
+ }
+ else {
+ com_node(c, CHILD(n, 0));
+ com_node(c, CHILD(n, 2));
+ com_addbyte(c, op+3);
+ }
+}
+
+static void
+com_apply_subscript(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, subscript);
+ if (NCH(n) == 1 && TYPE(CHILD(n, 0)) != COLON) {
+ /* It's a single subscript */
+ com_node(c, CHILD(n, 0));
+ com_addbyte(c, BINARY_SUBSCR);
+ }
+ else {
+ /* It's a slice: [expr] ':' [expr] */
+ com_slice(c, n, SLICE);
+ }
+}
+
+static void
+com_call_function(c, n)
+ struct compiling *c;
+ node *n; /* EITHER testlist OR ')' */
+{
+ if (TYPE(n) == RPAR) {
+ com_addbyte(c, UNARY_CALL);
+ }
+ else {
+ com_node(c, n);
+ com_addbyte(c, BINARY_CALL);
+ }
+}
+
+static void
+com_select_member(c, n)
+ struct compiling *c;
+ node *n;
+{
+ com_addopname(c, LOAD_ATTR, n);
+}
+
+static void
+com_apply_trailer(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, trailer);
+ switch (TYPE(CHILD(n, 0))) {
+ case LPAR:
+ com_call_function(c, CHILD(n, 1));
+ break;
+ case DOT:
+ com_select_member(c, CHILD(n, 1));
+ break;
+ case LSQB:
+ com_apply_subscript(c, CHILD(n, 1));
+ break;
+ default:
+ err_setstr(SystemError,
+ "com_apply_trailer: unknown trailer type");
+ c->c_errors++;
+ }
+}
+
+static void
+com_factor(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ REQ(n, factor);
+ if (TYPE(CHILD(n, 0)) == PLUS) {
+ com_factor(c, CHILD(n, 1));
+ com_addbyte(c, UNARY_POSITIVE);
+ }
+ else if (TYPE(CHILD(n, 0)) == MINUS) {
+ com_factor(c, CHILD(n, 1));
+ com_addbyte(c, UNARY_NEGATIVE);
+ }
+ else {
+ com_atom(c, CHILD(n, 0));
+ for (i = 1; i < NCH(n); i++)
+ com_apply_trailer(c, CHILD(n, i));
+ }
+}
+
+static void
+com_term(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ int op;
+ REQ(n, term);
+ com_factor(c, CHILD(n, 0));
+ for (i = 2; i < NCH(n); i += 2) {
+ com_factor(c, CHILD(n, i));
+ switch (TYPE(CHILD(n, i-1))) {
+ case STAR:
+ op = BINARY_MULTIPLY;
+ break;
+ case SLASH:
+ op = BINARY_DIVIDE;
+ break;
+ case PERCENT:
+ op = BINARY_MODULO;
+ break;
+ default:
+ err_setstr(SystemError,
+ "com_term: term operator not *, / or %");
+ c->c_errors++;
+ op = 255;
+ }
+ com_addbyte(c, op);
+ }
+}
+
+static void
+com_expr(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ int op;
+ REQ(n, expr);
+ com_term(c, CHILD(n, 0));
+ for (i = 2; i < NCH(n); i += 2) {
+ com_term(c, CHILD(n, i));
+ switch (TYPE(CHILD(n, i-1))) {
+ case PLUS:
+ op = BINARY_ADD;
+ break;
+ case MINUS:
+ op = BINARY_SUBTRACT;
+ break;
+ default:
+ err_setstr(SystemError,
+ "com_expr: expr operator not + or -");
+ c->c_errors++;
+ op = 255;
+ }
+ com_addbyte(c, op);
+ }
+}
+
+static enum cmp_op
+cmp_type(n)
+ node *n;
+{
+ REQ(n, comp_op);
+ /* comp_op: '<' | '>' | '=' | '>' '=' | '<' '=' | '<' '>'
+ | 'in' | 'not' 'in' | 'is' | 'is' not' */
+ if (NCH(n) == 1) {
+ n = CHILD(n, 0);
+ switch (TYPE(n)) {
+ case LESS: return LT;
+ case GREATER: return GT;
+ case EQUAL: return EQ;
+ case NAME: if (strcmp(STR(n), "in") == 0) return IN;
+ if (strcmp(STR(n), "is") == 0) return IS;
+ }
+ }
+ else if (NCH(n) == 2) {
+ int t2 = TYPE(CHILD(n, 1));
+ switch (TYPE(CHILD(n, 0))) {
+ case LESS: if (t2 == EQUAL) return LE;
+ if (t2 == GREATER) return NE;
+ break;
+ case GREATER: if (t2 == EQUAL) return GE;
+ break;
+ case NAME: if (strcmp(STR(CHILD(n, 1)), "in") == 0)
+ return NOT_IN;
+ if (strcmp(STR(CHILD(n, 0)), "is") == 0)
+ return IS_NOT;
+ }
+ }
+ return BAD;
+}
+
+static void
+com_comparison(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ enum cmp_op op;
+ int anchor;
+ REQ(n, comparison); /* comparison: expr (comp_op expr)* */
+ com_expr(c, CHILD(n, 0));
+ if (NCH(n) == 1)
+ return;
+
+ /****************************************************************
+ The following code is generated for all but the last
+ comparison in a chain:
+
+ label: on stack: opcode: jump to:
+
+ a <code to load b>
+ a, b DUP_TOP
+ a, b, b ROT_THREE
+ b, a, b COMPARE_OP
+ b, 0-or-1 JUMP_IF_FALSE L1
+ b, 1 POP_TOP
+ b
+
+ We are now ready to repeat this sequence for the next
+ comparison in the chain.
+
+ For the last we generate:
+
+ b <code to load c>
+ b, c COMPARE_OP
+ 0-or-1
+
+ If there were any jumps to L1 (i.e., there was more than one
+ comparison), we generate:
+
+ 0-or-1 JUMP_FORWARD L2
+ L1: b, 0 ROT_TWO
+ 0, b POP_TOP
+ 0
+ L2:
+ ****************************************************************/
+
+ anchor = 0;
+
+ for (i = 2; i < NCH(n); i += 2) {
+ com_expr(c, CHILD(n, i));
+ if (i+2 < NCH(n)) {
+ com_addbyte(c, DUP_TOP);
+ com_addbyte(c, ROT_THREE);
+ }
+ op = cmp_type(CHILD(n, i-1));
+ if (op == BAD) {
+ err_setstr(SystemError,
+ "com_comparison: unknown comparison op");
+ c->c_errors++;
+ }
+ com_addoparg(c, COMPARE_OP, op);
+ if (i+2 < NCH(n)) {
+ com_addfwref(c, JUMP_IF_FALSE, &anchor);
+ com_addbyte(c, POP_TOP);
+ }
+ }
+
+ if (anchor) {
+ int anchor2 = 0;
+ com_addfwref(c, JUMP_FORWARD, &anchor2);
+ com_backpatch(c, anchor);
+ com_addbyte(c, ROT_TWO);
+ com_addbyte(c, POP_TOP);
+ com_backpatch(c, anchor2);
+ }
+}
+
+static void
+com_not_test(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, not_test); /* 'not' not_test | comparison */
+ if (NCH(n) == 1) {
+ com_comparison(c, CHILD(n, 0));
+ }
+ else {
+ com_not_test(c, CHILD(n, 1));
+ com_addbyte(c, UNARY_NOT);
+ }
+}
+
+static void
+com_and_test(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ int anchor;
+ REQ(n, and_test); /* not_test ('and' not_test)* */
+ anchor = 0;
+ i = 0;
+ for (;;) {
+ com_not_test(c, CHILD(n, i));
+ if ((i += 2) >= NCH(n))
+ break;
+ com_addfwref(c, JUMP_IF_FALSE, &anchor);
+ com_addbyte(c, POP_TOP);
+ }
+ if (anchor)
+ com_backpatch(c, anchor);
+}
+
+static void
+com_test(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ int anchor;
+ REQ(n, test); /* and_test ('and' and_test)* */
+ anchor = 0;
+ i = 0;
+ for (;;) {
+ com_and_test(c, CHILD(n, i));
+ if ((i += 2) >= NCH(n))
+ break;
+ com_addfwref(c, JUMP_IF_TRUE, &anchor);
+ com_addbyte(c, POP_TOP);
+ }
+ if (anchor)
+ com_backpatch(c, anchor);
+}
+
+static void
+com_list(c, n)
+ struct compiling *c;
+ node *n;
+{
+ /* exprlist: expr (',' expr)* [',']; likewise for testlist */
+ if (NCH(n) == 1) {
+ com_node(c, CHILD(n, 0));
+ }
+ else {
+ int i;
+ int len;
+ len = (NCH(n) + 1) / 2;
+ for (i = 0; i < NCH(n); i += 2)
+ com_node(c, CHILD(n, i));
+ com_addoparg(c, BUILD_TUPLE, len);
+ }
+}
+
+
+/* Begin of assignment compilation */
+
+static void com_assign_name PROTO((struct compiling *, node *, int));
+static void com_assign PROTO((struct compiling *, node *, int));
+
+static void
+com_assign_attr(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ com_addopname(c, assigning ? STORE_ATTR : DELETE_ATTR, n);
+}
+
+static void
+com_assign_slice(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ com_slice(c, n, assigning ? STORE_SLICE : DELETE_SLICE);
+}
+
+static void
+com_assign_subscript(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ com_node(c, n);
+ com_addbyte(c, assigning ? STORE_SUBSCR : DELETE_SUBSCR);
+}
+
+static void
+com_assign_trailer(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ char *name;
+ REQ(n, trailer);
+ switch (TYPE(CHILD(n, 0))) {
+ case LPAR: /* '(' [exprlist] ')' */
+ err_setstr(TypeError, "can't assign to function call");
+ c->c_errors++;
+ break;
+ case DOT: /* '.' NAME */
+ com_assign_attr(c, CHILD(n, 1), assigning);
+ break;
+ case LSQB: /* '[' subscript ']' */
+ n = CHILD(n, 1);
+ REQ(n, subscript); /* subscript: expr | [expr] ':' [expr] */
+ if (NCH(n) > 1 || TYPE(CHILD(n, 0)) == COLON)
+ com_assign_slice(c, n, assigning);
+ else
+ com_assign_subscript(c, CHILD(n, 0), assigning);
+ break;
+ default:
+ err_setstr(TypeError, "unknown trailer type");
+ c->c_errors++;
+ }
+}
+
+static void
+com_assign_tuple(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ int i;
+ if (TYPE(n) != testlist)
+ REQ(n, exprlist);
+ if (assigning)
+ com_addoparg(c, UNPACK_TUPLE, (NCH(n)+1)/2);
+ for (i = 0; i < NCH(n); i += 2)
+ com_assign(c, CHILD(n, i), assigning);
+}
+
+static void
+com_assign_list(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ int i;
+ if (assigning)
+ com_addoparg(c, UNPACK_LIST, (NCH(n)+1)/2);
+ for (i = 0; i < NCH(n); i += 2)
+ com_assign(c, CHILD(n, i), assigning);
+}
+
+static void
+com_assign_name(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ REQ(n, NAME);
+ com_addopname(c, assigning ? STORE_NAME : DELETE_NAME, n);
+}
+
+static void
+com_assign(c, n, assigning)
+ struct compiling *c;
+ node *n;
+ int assigning;
+{
+ /* Loop to avoid trivial recursion */
+ for (;;) {
+ switch (TYPE(n)) {
+ case exprlist:
+ case testlist:
+ if (NCH(n) > 1) {
+ com_assign_tuple(c, n, assigning);
+ return;
+ }
+ n = CHILD(n, 0);
+ break;
+ case test:
+ case and_test:
+ case not_test:
+ if (NCH(n) > 1) {
+ err_setstr(TypeError,
+ "can't assign to operator");
+ c->c_errors++;
+ return;
+ }
+ n = CHILD(n, 0);
+ break;
+ case comparison:
+ if (NCH(n) > 1) {
+ err_setstr(TypeError,
+ "can't assign to operator");
+ c->c_errors++;
+ return;
+ }
+ n = CHILD(n, 0);
+ break;
+ case expr:
+ if (NCH(n) > 1) {
+ err_setstr(TypeError,
+ "can't assign to operator");
+ c->c_errors++;
+ return;
+ }
+ n = CHILD(n, 0);
+ break;
+ case term:
+ if (NCH(n) > 1) {
+ err_setstr(TypeError,
+ "can't assign to operator");
+ c->c_errors++;
+ return;
+ }
+ n = CHILD(n, 0);
+ break;
+ case factor: /* ('+'|'-') factor | atom trailer* */
+ if (TYPE(CHILD(n, 0)) != atom) { /* '+' | '-' */
+ err_setstr(TypeError,
+ "can't assign to operator");
+ c->c_errors++;
+ return;
+ }
+ if (NCH(n) > 1) { /* trailer present */
+ int i;
+ com_node(c, CHILD(n, 0));
+ for (i = 1; i+1 < NCH(n); i++) {
+ com_apply_trailer(c, CHILD(n, i));
+ } /* NB i is still alive */
+ com_assign_trailer(c,
+ CHILD(n, i), assigning);
+ return;
+ }
+ n = CHILD(n, 0);
+ break;
+ case atom:
+ switch (TYPE(CHILD(n, 0))) {
+ case LPAR:
+ n = CHILD(n, 1);
+ if (TYPE(n) == RPAR) {
+ /* XXX Should allow () = () ??? */
+ err_setstr(TypeError,
+ "can't assign to ()");
+ c->c_errors++;
+ return;
+ }
+ break;
+ case LSQB:
+ n = CHILD(n, 1);
+ if (TYPE(n) == RSQB) {
+ err_setstr(TypeError,
+ "can't assign to []");
+ c->c_errors++;
+ return;
+ }
+ com_assign_list(c, n, assigning);
+ return;
+ case NAME:
+ com_assign_name(c, CHILD(n, 0), assigning);
+ return;
+ default:
+ err_setstr(TypeError,
+ "can't assign to constant");
+ c->c_errors++;
+ return;
+ }
+ break;
+ default:
+ fprintf(stderr, "node type %d\n", TYPE(n));
+ err_setstr(SystemError, "com_assign: bad node");
+ c->c_errors++;
+ return;
+ }
+ }
+}
+
+static void
+com_expr_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, expr_stmt); /* exprlist ('=' exprlist)* NEWLINE */
+ com_node(c, CHILD(n, NCH(n)-2));
+ if (NCH(n) == 2) {
+ com_addbyte(c, PRINT_EXPR);
+ }
+ else {
+ int i;
+ for (i = 0; i < NCH(n)-3; i+=2) {
+ if (i+2 < NCH(n)-3)
+ com_addbyte(c, DUP_TOP);
+ com_assign(c, CHILD(n, i), 1/*assign*/);
+ }
+ }
+}
+
+static void
+com_print_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ REQ(n, print_stmt); /* 'print' (test ',')* [test] NEWLINE */
+ for (i = 1; i+1 < NCH(n); i += 2) {
+ com_node(c, CHILD(n, i));
+ com_addbyte(c, PRINT_ITEM);
+ }
+ if (TYPE(CHILD(n, NCH(n)-2)) != COMMA)
+ com_addbyte(c, PRINT_NEWLINE);
+}
+
+static void
+com_return_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, return_stmt); /* 'return' [testlist] NEWLINE */
+ if (NCH(n) == 2)
+ com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ else
+ com_node(c, CHILD(n, 1));
+ com_addbyte(c, RETURN_VALUE);
+}
+
+static void
+com_raise_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, raise_stmt); /* 'raise' expr [',' expr] NEWLINE */
+ com_node(c, CHILD(n, 1));
+ if (NCH(n) > 3)
+ com_node(c, CHILD(n, 3));
+ else
+ com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_addbyte(c, RAISE_EXCEPTION);
+}
+
+static void
+com_import_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ REQ(n, import_stmt);
+ /* 'import' NAME (',' NAME)* NEWLINE |
+ 'from' NAME 'import' ('*' | NAME (',' NAME)*) NEWLINE */
+ if (STR(CHILD(n, 0))[0] == 'f') {
+ /* 'from' NAME 'import' ... */
+ REQ(CHILD(n, 1), NAME);
+ com_addopname(c, IMPORT_NAME, CHILD(n, 1));
+ for (i = 3; i < NCH(n); i += 2)
+ com_addopname(c, IMPORT_FROM, CHILD(n, i));
+ com_addbyte(c, POP_TOP);
+ }
+ else {
+ for (i = 1; i < NCH(n); i += 2) {
+ com_addopname(c, IMPORT_NAME, CHILD(n, i));
+ com_addopname(c, STORE_NAME, CHILD(n, i));
+ }
+ }
+}
+
+static void
+com_if_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ int anchor = 0;
+ REQ(n, if_stmt);
+ /*'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] */
+ for (i = 0; i+3 < NCH(n); i+=4) {
+ int a = 0;
+ com_node(c, CHILD(n, i+1));
+ com_addfwref(c, JUMP_IF_FALSE, &a);
+ com_addbyte(c, POP_TOP);
+ com_node(c, CHILD(n, i+3));
+ com_addfwref(c, JUMP_FORWARD, &anchor);
+ com_backpatch(c, a);
+ com_addbyte(c, POP_TOP);
+ }
+ if (i+2 < NCH(n))
+ com_node(c, CHILD(n, i+2));
+ com_backpatch(c, anchor);
+}
+
+static void
+com_while_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int break_anchor = 0;
+ int anchor = 0;
+ int begin;
+ REQ(n, while_stmt); /* 'while' test ':' suite ['else' ':' suite] */
+ com_addfwref(c, SETUP_LOOP, &break_anchor);
+ begin = c->c_nexti;
+ com_node(c, CHILD(n, 1));
+ com_addfwref(c, JUMP_IF_FALSE, &anchor);
+ com_addbyte(c, POP_TOP);
+ com_node(c, CHILD(n, 3));
+ com_addoparg(c, JUMP_ABSOLUTE, begin);
+ com_backpatch(c, anchor);
+ com_addbyte(c, POP_TOP);
+ com_addbyte(c, POP_BLOCK);
+ if (NCH(n) > 4)
+ com_node(c, CHILD(n, 6));
+ com_backpatch(c, break_anchor);
+}
+
+static void
+com_for_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ object *v;
+ int break_anchor = 0;
+ int anchor = 0;
+ int begin;
+ REQ(n, for_stmt);
+ /* 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] */
+ com_addfwref(c, SETUP_LOOP, &break_anchor);
+ com_node(c, CHILD(n, 3));
+ v = newintobject(0L);
+ if (v == NULL)
+ c->c_errors++;
+ com_addoparg(c, LOAD_CONST, com_addconst(c, v));
+ XDECREF(v);
+ begin = c->c_nexti;
+ com_addfwref(c, FOR_LOOP, &anchor);
+ com_assign(c, CHILD(n, 1), 1/*assigning*/);
+ com_node(c, CHILD(n, 5));
+ com_addoparg(c, JUMP_ABSOLUTE, begin);
+ com_backpatch(c, anchor);
+ com_addbyte(c, POP_BLOCK);
+ if (NCH(n) > 8)
+ com_node(c, CHILD(n, 8));
+ com_backpatch(c, break_anchor);
+}
+
+static void
+com_try_stmt(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int finally_anchor = 0;
+ int except_anchor = 0;
+ REQ(n, try_stmt);
+ /* 'try' ':' suite (except_clause ':' suite)* ['finally' ':' suite] */
+ if (NCH(n) > 3 && TYPE(CHILD(n, NCH(n)-3)) != except_clause) {
+ /* Have a 'finally' clause */
+ com_addfwref(c, SETUP_FINALLY, &finally_anchor);
+ }
+ if (NCH(n) > 3 && TYPE(CHILD(n, 3)) == except_clause) {
+ /* Have an 'except' clause */
+ com_addfwref(c, SETUP_EXCEPT, &except_anchor);
+ }
+ com_node(c, CHILD(n, 2));
+ if (except_anchor) {
+ int end_anchor = 0;
+ int i;
+ node *ch;
+ com_addbyte(c, POP_BLOCK);
+ com_addfwref(c, JUMP_FORWARD, &end_anchor);
+ com_backpatch(c, except_anchor);
+ for (i = 3;
+ i < NCH(n) && TYPE(ch = CHILD(n, i)) == except_clause;
+ i += 3) {
+ /* except_clause: 'except' [expr [',' expr]] */
+ int next_anchor = 0;
+ if (NCH(ch) > 1) {
+ com_addbyte(c, DUP_TOP);
+ com_node(c, CHILD(ch, 1));
+ com_addoparg(c, COMPARE_OP, EXC_MATCH);
+ com_addfwref(c, JUMP_IF_FALSE, &next_anchor);
+ com_addbyte(c, POP_TOP);
+ }
+ com_addbyte(c, POP_TOP);
+ if (NCH(ch) > 3)
+ com_assign(c, CHILD(ch, 3), 1/*assigning*/);
+ else
+ com_addbyte(c, POP_TOP);
+ com_node(c, CHILD(n, i+2));
+ com_addfwref(c, JUMP_FORWARD, &end_anchor);
+ if (next_anchor)
+ com_backpatch(c, next_anchor);
+ }
+ com_addbyte(c, END_FINALLY);
+ com_backpatch(c, end_anchor);
+ }
+ if (finally_anchor) {
+ com_addbyte(c, POP_BLOCK);
+ com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_backpatch(c, finally_anchor);
+ com_node(c, CHILD(n, NCH(n)-1));
+ com_addbyte(c, END_FINALLY);
+ }
+}
+
+static void
+com_suite(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, suite);
+ /* simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT */
+ if (NCH(n) == 1) {
+ com_node(c, CHILD(n, 0));
+ }
+ else {
+ int i;
+ for (i = 0; i < NCH(n); i++) {
+ node *ch = CHILD(n, i);
+ if (TYPE(ch) == stmt)
+ com_node(c, ch);
+ }
+ }
+}
+
+static void
+com_funcdef(c, n)
+ struct compiling *c;
+ node *n;
+{
+ object *v;
+ REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
+ v = (object *)compile(n);
+ if (v == NULL)
+ c->c_errors++;
+ else {
+ int i = com_addconst(c, v);
+ com_addoparg(c, LOAD_CONST, i);
+ com_addbyte(c, BUILD_FUNCTION);
+ com_addopname(c, STORE_NAME, CHILD(n, 1));
+ DECREF(v);
+ }
+}
+
+static void
+com_classdef(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, classdef);
+ /*
+ classdef: 'class' NAME parameters ['=' baselist] ':' suite
+ baselist: atom arguments (',' atom arguments)*
+ arguments: '(' [testlist] ')'
+ */
+ err_setstr(SystemError, "can't compile 'class' yet");
+ c->c_errors++;
+}
+
+static void
+com_node(c, n)
+ struct compiling *c;
+ node *n;
+{
+ switch (TYPE(n)) {
+
+ /* Definition nodes */
+
+ case funcdef:
+ com_funcdef(c, n);
+ break;
+ case classdef:
+ com_classdef(c, n);
+ break;
+
+ /* Trivial parse tree nodes */
+
+ case stmt:
+ case simple_stmt:
+ case flow_stmt:
+ case compound_stmt:
+ com_node(c, CHILD(n, 0));
+ break;
+
+ /* Statement nodes */
+
+ case expr_stmt:
+ com_expr_stmt(c, n);
+ break;
+ case print_stmt:
+ com_print_stmt(c, n);
+ break;
+ case del_stmt: /* 'del' exprlist NEWLINE */
+ com_assign(c, CHILD(n, 1), 0/*delete*/);
+ break;
+ case pass_stmt:
+ break;
+ case break_stmt:
+ com_addbyte(c, BREAK_LOOP);
+ break;
+ case return_stmt:
+ com_return_stmt(c, n);
+ break;
+ case raise_stmt:
+ com_raise_stmt(c, n);
+ break;
+ case import_stmt:
+ com_import_stmt(c, n);
+ break;
+ case if_stmt:
+ com_if_stmt(c, n);
+ break;
+ case while_stmt:
+ com_while_stmt(c, n);
+ break;
+ case for_stmt:
+ com_for_stmt(c, n);
+ break;
+ case try_stmt:
+ com_try_stmt(c, n);
+ break;
+ case suite:
+ com_suite(c, n);
+ break;
+
+ /* Expression nodes */
+
+ case testlist:
+ com_list(c, n);
+ break;
+ case test:
+ com_test(c, n);
+ break;
+ case and_test:
+ com_and_test(c, n);
+ break;
+ case not_test:
+ com_not_test(c, n);
+ break;
+ case comparison:
+ com_comparison(c, n);
+ break;
+ case exprlist:
+ com_list(c, n);
+ break;
+ case expr:
+ com_expr(c, n);
+ break;
+ case term:
+ com_term(c, n);
+ break;
+ case factor:
+ com_factor(c, n);
+ break;
+ case atom:
+ com_atom(c, n);
+ break;
+
+ default:
+ fprintf(stderr, "node type %d\n", TYPE(n));
+ err_setstr(SystemError, "com_node: unexpected node type");
+ c->c_errors++;
+ }
+}
+
+static void com_fplist PROTO((struct compiling *, node *));
+
+static void
+com_fpdef(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, fpdef); /* fpdef: NAME | '(' fplist ')' */
+ if (TYPE(CHILD(n, 0)) == LPAR)
+ com_fplist(c, CHILD(n, 1));
+ else
+ com_addopname(c, STORE_NAME, CHILD(n, 0));
+}
+
+static void
+com_fplist(c, n)
+ struct compiling *c;
+ node *n;
+{
+ REQ(n, fplist); /* fplist: fpdef (',' fpdef)* */
+ if (NCH(n) == 1) {
+ com_fpdef(c, CHILD(n, 0));
+ }
+ else {
+ int i;
+ com_addoparg(c, UNPACK_TUPLE, (NCH(n)+1)/2);
+ for (i = 0; i < NCH(n); i += 2)
+ com_fpdef(c, CHILD(n, i));
+ }
+}
+
+static void
+com_file_input(c, n)
+ struct compiling *c;
+ node *n;
+{
+ int i;
+ REQ(n, file_input); /* (NEWLINE | stmt)* ENDMARKER */
+ for (i = 0; i < NCH(n); i++) {
+ node *ch = CHILD(n, i);
+ if (TYPE(ch) != ENDMARKER && TYPE(ch) != NEWLINE)
+ com_node(c, ch);
+ }
+}
+
+/* Top-level compile-node interface */
+
+static void
+compile_funcdef(c, n)
+ struct compiling *c;
+ node *n;
+{
+ node *ch;
+ REQ(n, funcdef); /* funcdef: 'def' NAME parameters ':' suite */
+ ch = CHILD(n, 2); /* parameters: '(' [fplist] ')' */
+ ch = CHILD(ch, 1); /* ')' | fplist */
+ if (TYPE(ch) == RPAR)
+ com_addbyte(c, REFUSE_ARGS);
+ else {
+ com_addbyte(c, REQUIRE_ARGS);
+ com_fplist(c, ch);
+ }
+ com_node(c, CHILD(n, 4));
+ com_addoparg(c, LOAD_CONST, com_addconst(c, None));
+ com_addbyte(c, RETURN_VALUE);
+}
+
+static void
+compile_node(c, n)
+ struct compiling *c;
+ node *n;
+{
+ switch (TYPE(n)) {
+
+ case single_input:
+ /* NEWLINE | simple_stmt | compound_stmt NEWLINE */
+ n = CHILD(n, 0);
+ if (TYPE(n) != NEWLINE)
+ com_node(c, n);
+ break;
+
+ case file_input:
+ com_file_input(c, n);
+ break;
+
+ case expr_input:
+ case eval_input:
+ com_node(c, CHILD(n, 0));
+ break;
+
+ case funcdef:
+ compile_funcdef(c, n);
+ break;
+
+ default:
+ fprintf(stderr, "node type %d\n", TYPE(n));
+ err_setstr(SystemError, "compile_node: unexpected node type");
+ c->c_errors++;
+ }
+}
+
+codeobject *
+compile(n)
+ node *n;
+{
+ struct compiling sc;
+ codeobject *co;
+ if (!com_init(&sc))
+ return NULL;
+ compile_node(&sc, n);
+ com_done(&sc);
+ if (sc.c_errors == 0)
+ co = newcodeobject(sc.c_code, sc.c_consts, sc.c_names);
+ else
+ co = NULL;
+ com_free(&sc);
+ return co;
+}
projects / thirdparty / Python / cpython.git / commitdiff
