return f;
}
+#define GETUSTRINGVALUE(s) ((unsigned char *)GETSTRINGVALUE(s))
+
#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 Nextbyte(f) (GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti++])
+#define Peekbyte(f) (GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti])
+#define Peekint(f) \
+ (GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti] + \
+ GETUSTRINGVALUE((f)->f_code->co_code)[(f)->f_nexti+1])
+#define Prevbyte(f) (GETUSTRINGVALUE((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)))
printf("ran off end of instructions\n");
abort();
}
- return GETSTRINGVALUE(code)[f->f_nexti++];
+ return GETUSTRINGVALUE(code)[f->f_nexti++];
+}
+
+static int
+nextint(f)
+ frameobject *f;
+{
+ int a, b;
+#ifdef NDEBUG
+ a = Nextbyte(f);
+ b = Nextbyte(f);
+#else
+ a = nextbyte(f);
+ b = nextbyte(f);
+#endif
+ return a + (b << 8);
}
/* Tracing versions */
if (op < HAVE_ARGUMENT)
printf("op %3d\n", op);
else {
- arg = Peekbyte(f);
- printf("op %3d arg %3d\n", op, arg);
+ arg = Peekint(f);
+ printf("op %d arg %d\n", op, arg);
}
return op;
}
return v;
}
+static void
+import_from(ctx, v, name)
+ context *ctx;
+ object *v;
+ char *name;
+{
+ object *w, *x;
+ w = getmoduledict(v);
+ if (name[0] == '*') {
+ int i;
+ int n = getdictsize(w);
+ for (i = 0; i < n; i++) {
+ name = getdictkey(w, i);
+ if (name == NULL || name[0] == '_')
+ continue;
+ x = dictlookup(w, name);
+ if (x == NULL) {
+ /* XXX can't happen? */
+ name_error(ctx, name);
+ break;
+ }
+ if (dictinsert(ctx->ctx_locals, name, x) != 0) {
+ puterrno(ctx);
+ break;
+ }
+ }
+ }
+ else {
+ x = dictlookup(w, name);
+ if (x == NULL)
+ name_error(ctx, name);
+ else if (dictinsert(ctx->ctx_locals, name, x) != 0)
+ puterrno(ctx);
+ }
+}
+
+static object *
+build_class(ctx, v, w)
+ context *ctx;
+ object *v; /* None or tuple containing base classes */
+ object *w; /* dictionary */
+{
+ if (is_tupleobject(v)) {
+ int i;
+ for (i = gettuplesize(v); --i >= 0; ) {
+ object *x = gettupleitem(v, i);
+ if (!is_classobject(x)) {
+ type_error(ctx, "base is not a class object");
+ return NULL;
+ }
+ }
+ }
+ else {
+ v = NULL;
+ }
+ if (!is_dictobject(w)) {
+ sys_error(ctx, "build_class with non-dictionary");
+ return NULL;
+ }
+ return checkerror(ctx, newclassobject(v, w));
+}
+
static object *
eval_compiled(ctx, co, arg, needvalue)
context *ctx;
register object *u;
register object *x;
char *name;
- int n, i;
- enum cmp_op op;
+ int i, op;
FILE *fp;
#ifndef NDEBUG
int trace = dictlookup(ctx->ctx_globals, "__trace") != NULL;
#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
while (f->f_nexti < getstringsize((object *)f->f_code->co_code) &&
!ctx->ctx_exception) {
-
- switch (NEXTOP()) {
+#ifdef NDEBUG
+ op = Nextbyte(f);
+#else
+ op = trace ? trace_nextop(f) : nextbyte(f);
+#endif
+ if (op >= HAVE_ARGUMENT)
+ i = nextint(f);
+ switch (op) {
case DUP_TOP:
v = TOP();
case UNARY_CALL:
v = POP();
- if (is_classmemberobject(v) || is_funcobject(v))
+ if (is_classmethodobject(v) || is_funcobject(v))
u = call_function(ctx, v, (object *)NULL);
else
u = call_builtin(ctx, v, (object *)NULL);
case BINARY_CALL:
w = POP();
v = POP();
- if (is_classmemberobject(v) || is_funcobject(v))
+ if (is_classmethodobject(v) || is_funcobject(v))
u = call_function(ctx, v, w);
else
u = call_builtin(ctx, v, 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+0:
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();
+ op -= SLICE;
+ if (op & 2)
+ w = POP();
+ else
+ w = NULL;
+ if (op & 1)
+ v = POP();
+ else
+ v = NULL;
u = POP();
x = apply_slice(ctx, u, v, w);
DECREF(u);
- DECREF(v);
- DECREF(w);
+ XDECREF(v);
+ XDECREF(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+0:
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();
+ op -= SLICE;
+ if (op & 2)
+ w = POP();
+ else
+ w = NULL;
+ if (op & 1)
+ v = POP();
+ else
+ v = NULL;
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);
+ XDECREF(v);
+ XDECREF(w);
break;
+ case DELETE_SLICE+0:
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();
+ op -= SLICE;
+ if (op & 2)
+ w = POP();
+ else
+ w = NULL;
+ if (op & 1)
+ v = POP();
+ else
+ v = NULL;
u = POP();
x = NULL;
assign_slice(ctx, u, v, w, x); /* del u[v:w] */
DECREF(u);
- DECREF(v);
- DECREF(w);
+ XDECREF(v);
+ XDECREF(w);
break;
case STORE_SUBSCR:
}
break;
+ case LOAD_LOCALS:
+ v = ctx->ctx_locals;
+ INCREF(v);
+ PUSH(v);
+ break;
+
case RETURN_VALUE:
v = POP();
raise_pseudo(ctx, RETURN_PSEUDO);
}
break;
+ case BUILD_CLASS:
+ w = POP();
+ v = POP();
+ x = build_class(ctx, v, w);
+ PUSH(x);
+ DECREF(v);
+ DECREF(w);
+ break;
+
case STORE_NAME:
- i = NEXTI();
name = GETNAME(i);
v = POP();
if (dictinsert(ctx->ctx_locals, name, v) != 0)
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) {
+ else if (gettuplesize(v) != i) {
error(ctx, "unpack tuple of wrong size");
}
else {
- for (i = n; --i >= 0; ) {
+ for (; --i >= 0; ) {
w = gettupleitem(v, i);
INCREF(w);
PUSH(w);
break;
case UNPACK_LIST:
- n = NEXTI();
v = POP();
if (!is_listobject(v)) {
type_error(ctx, "unpack non-list");
}
- else if (getlistsize(v) != n) {
+ else if (getlistsize(v) != i) {
error(ctx, "unpack tuple of wrong size");
}
else {
- for (i = n; --i >= 0; ) {
+ for (; --i >= 0; ) {
w = getlistitem(v, i);
INCREF(w);
PUSH(w);
break;
case STORE_ATTR:
- i = NEXTI();
name = GETNAME(i);
v = POP();
u = POP();
break;
case DELETE_ATTR:
- i = NEXTI();
name = GETNAME(i);
v = POP();
/* del v.name */
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) {
break;
case BUILD_TUPLE:
- n = NEXTI();
- v = checkerror(ctx, newtupleobject(n));
+ v = checkerror(ctx, newtupleobject(i));
if (v != NULL) {
- for (i = n; --i >= 0;) {
+ for (; --i >= 0;) {
w = POP();
settupleitem(v, i, w);
}
break;
case BUILD_LIST:
- n = NEXTI();
- v = checkerror(ctx, newlistobject(n));
+ v = checkerror(ctx, newlistobject(i));
if (v != NULL) {
- for (i = n; --i >= 0;) {
+ for (; --i >= 0;) {
w = POP();
setlistitem(v, i, w);
}
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) {
break;
case COMPARE_OP:
- op = NEXTI();
w = POP();
v = POP();
- u = cmp_outcome(ctx, op, v, w);
+ u = cmp_outcome(ctx, (enum cmp_op)i, 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) {
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);
+ import_from(ctx, v, name);
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);
+ JUMPBY(i);
break;
case JUMP_IF_FALSE:
- n = NEXTI();
if (!testbool(ctx, TOP()))
- JUMPBY(n);
+ JUMPBY(i);
break;
case JUMP_IF_TRUE:
- n = NEXTI();
if (testbool(ctx, TOP()))
- JUMPBY(n);
+ JUMPBY(i);
break;
case JUMP_ABSOLUTE:
- n = NEXTI();
- JUMPTO(n);
+ JUMPTO(i);
/* XXX Should check for interrupts more often? */
if (intrcheck())
intr_error(ctx);
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();
+ s, i are popped, and we jump */
w = POP(); /* Loop index */
v = POP(); /* Sequence object */
x = loop_subscript(ctx, v, w);
else {
DECREF(v);
DECREF(w);
- JUMPBY(n);
+ JUMPBY(i);
}
break;
case SETUP_LOOP:
- n = NEXTI();
- setup_block(f, SETUP_LOOP, n);
+ setup_block(f, SETUP_LOOP, i);
break;
case SETUP_EXCEPT:
- n = NEXTI();
- setup_block(f, SETUP_EXCEPT, n);
+ setup_block(f, SETUP_EXCEPT, i);
break;
case SETUP_FINALLY:
- n = NEXTI();
- setup_block(f, SETUP_FINALLY, n);
+ setup_block(f, SETUP_FINALLY, i);
break;
default:
- printf("opcode %d\n", Prevbyte(f));
+ printf("opcode %d\n", op);
sys_error(ctx, "eval_compiled: unknown opcode");
break;
#undef JUMPTO
#undef JUMPBY
-#undef NEXTOP
-#undef NEXTI
#undef POP
#undef TOP
#undef PUSH
{
object *v;
codeobject *co = compile(n);
+ freenode(n); /* XXX A rather strange place to do this! */
if (co == NULL) {
puterrno(ctx);
return NULL;
projects / thirdparty / Python / cpython.git / commitdiff
