Python/ceval.c

   1 /***********************************************************
   2 Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
   3 Amsterdam, The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 /* Execute compiled code */
  26
  27 #include "allobjects.h"
  28
  29 #include "import.h"
  30 #include "sysmodule.h"
  31 #include "compile.h"
  32 #include "frameobject.h"
  33 #include "eval.h"
  34 #include "ceval.h"
  35 #include "opcode.h"
  36 #include "bltinmodule.h"
  37 #include "traceback.h"
  38 #include "graminit.h"
  39 #include "pythonrun.h"
  40
  41 #include <ctype.h>
  42
  43 /* Turn this on if your compiler chokes on the big switch: */
  44 /* #define CASE_TOO_BIG 1       /**/
  45
  46 /* Turn this on if you want to debug the interpreter: */
  47 /* (This can be on even if NDEBUG is defined) */
  48 /* #define DEBUG 1              /**/
  49
  50 #if defined(DEBUG) || !defined(NDEBUG)
  51 /* For debugging the interpreter: */
  52 #define LLTRACE  1      /* Low-level trace feature */
  53 #define CHECKEXC 1      /* Double-check exception checking */
  54 #endif
  55
  56 /* Global option, may be set by main() */
  57 int killprint;
  58
  59
  60 /* Forward declarations */
  61
  62 #ifdef LLTRACE
  63 static int prtrace PROTO((object *, char *));
  64 #endif
  65 static void call_exc_trace PROTO((object **, object**, frameobject *));
  66 static int call_trace
  67         PROTO((object **, object **, frameobject *, char *, object *));
  68 static object *add PROTO((object *, object *));
  69 static object *sub PROTO((object *, object *));
  70 static object *mul PROTO((object *, object *));
  71 static object *divide PROTO((object *, object *));
  72 static object *rem PROTO((object *, object *));
  73 static object *neg PROTO((object *));
  74 static object *pos PROTO((object *));
  75 static object *not PROTO((object *));
  76 static object *invert PROTO((object *));
  77 static object *lshift PROTO((object *, object *));
  78 static object *rshift PROTO((object *, object *));
  79 static object *and PROTO((object *, object *));
  80 static object *xor PROTO((object *, object *));
  81 static object *or PROTO((object *, object *));
  82 static object *call_builtin PROTO((object *, object *));
  83 static object *call_function PROTO((object *, object *));
  84 static object *apply_subscript PROTO((object *, object *));
  85 static object *loop_subscript PROTO((object *, object *));
  86 static int slice_index PROTO((object *, int, int *));
  87 static object *apply_slice PROTO((object *, object *, object *));
  88 static int assign_subscript PROTO((object *, object *, object *));
  89 static int assign_slice PROTO((object *, object *, object *, object *));
  90 static int cmp_exception PROTO((object *, object *));
  91 static int cmp_member PROTO((object *, object *));
  92 static object *cmp_outcome PROTO((int, object *, object *));
  93 static int import_from PROTO((object *, object *, object *));
  94 static object *build_class PROTO((object *, object *, object *));
  95 static void locals_2_fast PROTO((frameobject *, int));
  96 static void fast_2_locals PROTO((frameobject *));
  97 static int access_statement PROTO((object *, object *, frameobject *));
  98 static int exec_statement PROTO((object *, object *, object *));
  99 static void mergelocals PROTO(());
 100
 101
 102 /* Pointer to current frame, used to link new frames to */
 103
 104 static frameobject *current_frame;
 105
 106 #ifdef WITH_THREAD
 107
 108 #include <errno.h>
 109 #include "thread.h"
 110
 111 static type_lock interpreter_lock;
 112
 113 void
 114 init_save_thread()
 115 {
 116         if (interpreter_lock)
 117                 return;
 118         interpreter_lock = allocate_lock();
 119         acquire_lock(interpreter_lock, 1);
 120 }
 121
 122 #endif
 123
 124 /* Functions save_thread and restore_thread are always defined so
 125    dynamically loaded modules needn't be compiled separately for use
 126    with and without threads: */
 127
 128 object *
 129 save_thread()
 130 {
 131 #ifdef WITH_THREAD
 132         if (interpreter_lock) {
 133                 object *res;
 134                 res = (object *)current_frame;
 135                 current_frame = NULL;
 136                 release_lock(interpreter_lock);
 137                 return res;
 138         }
 139 #endif
 140         return NULL;
 141 }
 142
 143 void
 144 restore_thread(x)
 145         object *x;
 146 {
 147 #ifdef WITH_THREAD
 148         if (interpreter_lock) {
 149                 int err;
 150                 err = errno;
 151                 acquire_lock(interpreter_lock, 1);
 152                 errno = err;
 153                 current_frame = (frameobject *)x;
 154         }
 155 #endif
 156 }
 157
 158
 159 /* Status code for main loop (reason for stack unwind) */
 160
 161 enum why_code {
 162                 WHY_NOT,        /* No error */
 163                 WHY_EXCEPTION,  /* Exception occurred */
 164                 WHY_RERAISE,    /* Exception re-raised by 'finally' */
 165                 WHY_RETURN,     /* 'return' statement */
 166                 WHY_BREAK       /* 'break' statement */
 167 };
 168
 169
 170 /* Interpreter main loop */
 171
 172 object *
 173 eval_code(co, globals, locals, owner, arg)
 174         codeobject *co;
 175         object *globals;
 176         object *locals;
 177         object *owner;
 178         object *arg;
 179 {
 180         register unsigned char *next_instr;
 181         register int opcode;    /* Current opcode */
 182         register int oparg;     /* Current opcode argument, if any */
 183         register object **stack_pointer;
 184         register enum why_code why; /* Reason for block stack unwind */
 185         register int err;       /* Error status -- nonzero if error */
 186         register object *x;     /* Result object -- NULL if error */
 187         register object *v;     /* Temporary objects popped off stack */
 188         register object *w;
 189         register object *u;
 190         register object *t;
 191         register frameobject *f; /* Current frame */
 192         register listobject *fastlocals = NULL;
 193         object *trace = NULL;   /* Trace function or NULL */
 194         object *retval;         /* Return value iff why == WHY_RETURN */
 195         char *name;             /* Name used by some instructions */
 196         int needmerge = 0;      /* Set if need to merge locals back at end */
 197         int defmode = 0;        /* Default access mode for new variables */
 198 #ifdef LLTRACE
 199         int lltrace;
 200 #endif
 201 #ifdef DEBUG
 202         /* Make it easier to find out where we are with dbx */
 203         char *filename = getstringvalue(co->co_filename);
 204 #endif
 205
 206 /* Code access macros */
 207
 208 #define GETCONST(i)     Getconst(f, i)
 209 #define GETNAME(i)      Getname(f, i)
 210 #define GETNAMEV(i)     Getnamev(f, i)
 211 #define FIRST_INSTR()   (GETUSTRINGVALUE(f->f_code->co_code))
 212 #define INSTR_OFFSET()  (next_instr - FIRST_INSTR())
 213 #define NEXTOP()        (*next_instr++)
 214 #define NEXTARG()       (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
 215 #define JUMPTO(x)       (next_instr = FIRST_INSTR() + (x))
 216 #define JUMPBY(x)       (next_instr += (x))
 217
 218 /* Stack manipulation macros */
 219
 220 #define STACK_LEVEL()   (stack_pointer - f->f_valuestack)
 221 #define EMPTY()         (STACK_LEVEL() == 0)
 222 #define TOP()           (stack_pointer[-1])
 223 #define BASIC_PUSH(v)   (*stack_pointer++ = (v))
 224 #define BASIC_POP()     (*--stack_pointer)
 225
 226 #define CHECK_STACK(n)  (STACK_LEVEL() + (n) < f->f_nvalues || \
 227                           (stack_pointer = extend_stack(f, STACK_LEVEL(), n)))
 228
 229 #ifdef LLTRACE
 230 #define PUSH(v)         (BASIC_PUSH(v), lltrace && prtrace(TOP(), "push"))
 231 #define POP()           (lltrace && prtrace(TOP(), "pop"), BASIC_POP())
 232 #else
 233 #define PUSH(v)         BASIC_PUSH(v)
 234 #define POP()           BASIC_POP()
 235 #endif
 236
 237         if (globals == NULL) {
 238                 globals = getglobals();
 239                 if (locals == NULL) {
 240                         locals = getlocals();
 241                         needmerge = 1;
 242                 }
 243         }
 244         else {
 245                 if (locals == NULL)
 246                         locals = globals;
 247         }
 248
 249 #ifdef LLTRACE
 250         lltrace = dictlookup(globals, "__lltrace__") != NULL;
 251 #endif
 252
 253         f = newframeobject(
 254                         current_frame,          /*back*/
 255                         co,                     /*code*/
 256                         globals,                /*globals*/
 257                         locals,                 /*locals*/
 258                         owner,                  /*owner*/
 259                         50,                     /*nvalues*/
 260                         20);                    /*nblocks*/
 261         if (f == NULL)
 262                 return NULL;
 263
 264         current_frame = f;
 265
 266         if (sys_trace != NULL) {
 267                 /* sys_trace, if defined, is a function that will
 268                    be called  on *every* entry to a code block.
 269                    Its return value, if not None, is a function that
 270                    will be called at the start of each executed line
 271                    of code.  (Actually, the function must return
 272                    itself in order to continue tracing.)
 273                    The trace functions are called with three arguments:
 274                    a pointer to the current frame, a string indicating
 275                    why the function is called, and an argument which
 276                    depends on the situation.  The global trace function
 277                    (sys.trace) is also called whenever an exception
 278                    is detected. */
 279                 if (call_trace(&sys_trace, &trace, f, "call", arg)) {
 280                         /* Trace function raised an error */
 281                         current_frame = f->f_back;
 282                         DECREF(f);
 283                         return NULL;
 284                 }
 285         }
 286
 287         if (sys_profile != NULL) {
 288                 /* Similar for sys_profile, except it needn't return
 289                    itself and isn't called for "line" events */
 290                 if (call_trace(&sys_profile, (object**)0, f, "call", arg)) {
 291                         current_frame = f->f_back;
 292                         DECREF(f);
 293                         return NULL;
 294                 }
 295         }
 296
 297         next_instr = GETUSTRINGVALUE(f->f_code->co_code);
 298         stack_pointer = f->f_valuestack;
 299
 300         if (arg != NULL) {
 301                 INCREF(arg);
 302                 PUSH(arg);
 303         }
 304
 305         why = WHY_NOT;
 306         err = 0;
 307         x = None;       /* Not a reference, just anything non-NULL */
 308
 309         for (;;) {
 310                 static int ticker;
 311
 312                 /* Do periodic things.
 313                    Doing this every time through the loop would add
 314                    too much overhead (a function call per instruction).
 315                    So we do it only every tenth instruction. */
 316
 317                 if (--ticker < 0) {
 318                         ticker = 10;
 319                         if (intrcheck()) {
 320                                 err_set(KeyboardInterrupt);
 321                                 why = WHY_EXCEPTION;
 322                                 goto on_error;
 323                         }
 324
 325 #ifdef WITH_THREAD
 326                         if (interpreter_lock) {
 327                                 /* Give another thread a chance */
 328
 329                                 current_frame = NULL;
 330                                 release_lock(interpreter_lock);
 331
 332                                 /* Other threads may run now */
 333
 334                                 acquire_lock(interpreter_lock, 1);
 335                                 current_frame = f;
 336                         }
 337 #endif
 338                 }
 339
 340                 /* Extract opcode and argument */
 341
 342 #ifdef DEBUG
 343                 f->f_lasti = INSTR_OFFSET();
 344 #endif
 345
 346                 opcode = NEXTOP();
 347                 if (HAS_ARG(opcode))
 348                         oparg = NEXTARG();
 349
 350 #ifdef LLTRACE
 351                 /* Instruction tracing */
 352
 353                 if (lltrace) {
 354                         if (HAS_ARG(opcode)) {
 355                                 printf("%d: %d, %d\n",
 356                                         (int) (INSTR_OFFSET() - 3),
 357                                         opcode, oparg);
 358                         }
 359                         else {
 360                                 printf("%d: %d\n",
 361                                         (int) (INSTR_OFFSET() - 1), opcode);
 362                         }
 363                 }
 364 #endif
 365
 366                 if (!CHECK_STACK(3)) {
 367                         x = NULL;
 368                         break;
 369                 }
 370
 371                 /* Main switch on opcode */
 372
 373                 switch (opcode) {
 374
 375                 /* BEWARE!
 376                    It is essential that any operation that fails sets either
 377                    x to NULL, err to nonzero, or why to anything but WHY_NOT,
 378                    and that no operation that succeeds does this! */
 379
 380                 /* case STOP_CODE: this is an error! */
 381
 382                 case POP_TOP:
 383                         v = POP();
 384                         DECREF(v);
 385                         break;
 386
 387                 case ROT_TWO:
 388                         v = POP();
 389                         w = POP();
 390                         PUSH(v);
 391                         PUSH(w);
 392                         break;
 393
 394                 case ROT_THREE:
 395                         v = POP();
 396                         w = POP();
 397                         x = POP();
 398                         PUSH(v);
 399                         PUSH(x);
 400                         PUSH(w);
 401                         break;
 402
 403                 case DUP_TOP:
 404                         v = TOP();
 405                         INCREF(v);
 406                         PUSH(v);
 407                         break;
 408
 409                 case UNARY_POSITIVE:
 410                         v = POP();
 411                         x = pos(v);
 412                         DECREF(v);
 413                         PUSH(x);
 414                         break;
 415
 416                 case UNARY_NEGATIVE:
 417                         v = POP();
 418                         x = neg(v);
 419                         DECREF(v);
 420                         PUSH(x);
 421                         break;
 422
 423                 case UNARY_NOT:
 424                         v = POP();
 425                         x = not(v);
 426                         DECREF(v);
 427                         PUSH(x);
 428                         break;
 429
 430                 case UNARY_CONVERT:
 431                         v = POP();
 432                         x = reprobject(v);
 433                         DECREF(v);
 434                         PUSH(x);
 435                         break;
 436
 437                 case UNARY_CALL:
 438                         v = POP();
 439                         f->f_lasti = INSTR_OFFSET() - 1; /* For tracing */
 440                         x = call_object(v, (object *)NULL);
 441                         DECREF(v);
 442                         PUSH(x);
 443                         break;
 444
 445                 case UNARY_INVERT:
 446                         v = POP();
 447                         x = invert(v);
 448                         DECREF(v);
 449                         PUSH(x);
 450                         break;
 451
 452                 case BINARY_MULTIPLY:
 453                         w = POP();
 454                         v = POP();
 455                         x = mul(v, w);
 456                         DECREF(v);
 457                         DECREF(w);
 458                         PUSH(x);
 459                         break;
 460
 461                 case BINARY_DIVIDE:
 462                         w = POP();
 463                         v = POP();
 464                         x = divide(v, w);
 465                         DECREF(v);
 466                         DECREF(w);
 467                         PUSH(x);
 468                         break;
 469
 470                 case BINARY_MODULO:
 471                         w = POP();
 472                         v = POP();
 473                         x = rem(v, w);
 474                         DECREF(v);
 475                         DECREF(w);
 476                         PUSH(x);
 477                         break;
 478
 479                 case BINARY_ADD:
 480                         w = POP();
 481                         v = POP();
 482                         x = add(v, w);
 483                         DECREF(v);
 484                         DECREF(w);
 485                         PUSH(x);
 486                         break;
 487
 488                 case BINARY_SUBTRACT:
 489                         w = POP();
 490                         v = POP();
 491                         x = sub(v, w);
 492                         DECREF(v);
 493                         DECREF(w);
 494                         PUSH(x);
 495                         break;
 496
 497                 case BINARY_SUBSCR:
 498                         w = POP();
 499                         v = POP();
 500                         x = apply_subscript(v, w);
 501                         DECREF(v);
 502                         DECREF(w);
 503                         PUSH(x);
 504                         break;
 505
 506                 case BINARY_CALL:
 507                         w = POP();
 508                         v = POP();
 509                         f->f_lasti = INSTR_OFFSET() - 1; /* For tracing */
 510                         x = call_object(v, w);
 511                         DECREF(v);
 512                         DECREF(w);
 513                         PUSH(x);
 514                         break;
 515
 516                 case BINARY_LSHIFT:
 517                         w = POP();
 518                         v = POP();
 519                         x = lshift(v, w);
 520                         DECREF(v);
 521                         DECREF(w);
 522                         PUSH(x);
 523                         break;
 524
 525                 case BINARY_RSHIFT:
 526                         w = POP();
 527                         v = POP();
 528                         x = rshift(v, w);
 529                         DECREF(v);
 530                         DECREF(w);
 531                         PUSH(x);
 532                         break;
 533
 534                 case BINARY_AND:
 535                         w = POP();
 536                         v = POP();
 537                         x = and(v, w);
 538                         DECREF(v);
 539                         DECREF(w);
 540                         PUSH(x);
 541                         break;
 542
 543                 case BINARY_XOR:
 544                         w = POP();
 545                         v = POP();
 546                         x = xor(v, w);
 547                         DECREF(v);
 548                         DECREF(w);
 549                         PUSH(x);
 550                         break;
 551
 552                 case BINARY_OR:
 553                         w = POP();
 554                         v = POP();
 555                         x = or(v, w);
 556                         DECREF(v);
 557                         DECREF(w);
 558                         PUSH(x);
 559                         break;
 560
 561                 case SLICE+0:
 562                 case SLICE+1:
 563                 case SLICE+2:
 564                 case SLICE+3:
 565                         if ((opcode-SLICE) & 2)
 566                                 w = POP();
 567                         else
 568                                 w = NULL;
 569                         if ((opcode-SLICE) & 1)
 570                                 v = POP();
 571                         else
 572                                 v = NULL;
 573                         u = POP();
 574                         x = apply_slice(u, v, w);
 575                         DECREF(u);
 576                         XDECREF(v);
 577                         XDECREF(w);
 578                         PUSH(x);
 579                         break;
 580
 581                 case STORE_SLICE+0:
 582                 case STORE_SLICE+1:
 583                 case STORE_SLICE+2:
 584                 case STORE_SLICE+3:
 585                         if ((opcode-STORE_SLICE) & 2)
 586                                 w = POP();
 587                         else
 588                                 w = NULL;
 589                         if ((opcode-STORE_SLICE) & 1)
 590                                 v = POP();
 591                         else
 592                                 v = NULL;
 593                         u = POP();
 594                         t = POP();
 595                         err = assign_slice(u, v, w, t); /* u[v:w] = t */
 596                         DECREF(t);
 597                         DECREF(u);
 598                         XDECREF(v);
 599                         XDECREF(w);
 600                         break;
 601
 602                 case DELETE_SLICE+0:
 603                 case DELETE_SLICE+1:
 604                 case DELETE_SLICE+2:
 605                 case DELETE_SLICE+3:
 606                         if ((opcode-DELETE_SLICE) & 2)
 607                                 w = POP();
 608                         else
 609                                 w = NULL;
 610                         if ((opcode-DELETE_SLICE) & 1)
 611                                 v = POP();
 612                         else
 613                                 v = NULL;
 614                         u = POP();
 615                         err = assign_slice(u, v, w, (object *)NULL);
 616                                                         /* del u[v:w] */
 617                         DECREF(u);
 618                         XDECREF(v);
 619                         XDECREF(w);
 620                         break;
 621
 622                 case STORE_SUBSCR:
 623                         w = POP();
 624                         v = POP();
 625                         u = POP();
 626                         /* v[w] = u */
 627                         err = assign_subscript(v, w, u);
 628                         DECREF(u);
 629                         DECREF(v);
 630                         DECREF(w);
 631                         break;
 632
 633                 case DELETE_SUBSCR:
 634                         w = POP();
 635                         v = POP();
 636                         /* del v[w] */
 637                         err = assign_subscript(v, w, (object *)NULL);
 638                         DECREF(v);
 639                         DECREF(w);
 640                         break;
 641
 642                 case PRINT_EXPR:
 643                         v = POP();
 644                         /* Print value except if procedure result */
 645                         if (v != None) {
 646                                 flushline();
 647                                 x = sysget("stdout");
 648                                 softspace(x, 1);
 649                                 err = writeobject(v, x, 0);
 650                                 flushline();
 651                                 if (killprint) {
 652                                         err_setstr(RuntimeError,
 653                                               "printing expression statement");
 654                                         x = 0;
 655                                 }
 656                         }
 657                         DECREF(v);
 658                         break;
 659
 660                 case PRINT_ITEM:
 661                         v = POP();
 662                         w = sysget("stdout");
 663                         if (softspace(w, 1))
 664                                 writestring(" ", w);
 665                         err = writeobject(v, w, PRINT_RAW);
 666                         if (err == 0 && is_stringobject(v)) {
 667                                 /* XXX move into writeobject() ? */
 668                                 char *s = getstringvalue(v);
 669                                 int len = getstringsize(v);
 670                                 if (len > 0 && isspace(s[len-1]) &&
 671                                     s[len-1] != ' ')
 672                                         softspace(w, 0);
 673                         }
 674                         DECREF(v);
 675                         break;
 676
 677                 case PRINT_NEWLINE:
 678                         x = sysget("stdout");
 679                         if (x == NULL)
 680                                 err_setstr(RuntimeError, "lost sys.stdout");
 681                         else {
 682                                 writestring("\n", x);
 683                                 softspace(x, 0);
 684                         }
 685                         break;
 686
 687                 case BREAK_LOOP:
 688                         why = WHY_BREAK;
 689                         break;
 690
 691                 case RAISE_EXCEPTION:
 692                         v = POP();
 693                         w = POP();
 694                         /* A tuple is equivalent to its first element here */
 695                         while (is_tupleobject(w)) {
 696                                 u = w;
 697                                 w = gettupleitem(u, 0);
 698                                 DECREF(u);
 699                         }
 700                         if (!is_stringobject(w))
 701                                 err_setstr(TypeError,
 702                                         "exceptions must be strings");
 703                         else
 704                                 err_setval(w, v);
 705                         DECREF(v);
 706                         DECREF(w);
 707                         why = WHY_EXCEPTION;
 708                         break;
 709
 710                 case LOAD_LOCALS:
 711                         v = f->f_locals;
 712                         INCREF(v);
 713                         PUSH(v);
 714                         break;
 715
 716                 case RETURN_VALUE:
 717                         retval = POP();
 718                         why = WHY_RETURN;
 719                         break;
 720
 721                 case LOAD_GLOBALS:
 722                         v = f->f_locals;
 723                         INCREF(v);
 724                         PUSH(v);
 725                         break;
 726
 727                 case EXEC_STMT:
 728                         w = POP();
 729                         v = POP();
 730                         u = POP();
 731                         err = exec_statement(u, v, w);
 732                         DECREF(u);
 733                         DECREF(v);
 734                         DECREF(w);
 735                         break;
 736
 737                 case BUILD_FUNCTION:
 738                         v = POP();
 739                         x = newfuncobject(v, f->f_globals);
 740                         DECREF(v);
 741                         PUSH(x);
 742                         break;
 743
 744                 case POP_BLOCK:
 745                         {
 746                                 block *b = pop_block(f);
 747                                 while (STACK_LEVEL() > b->b_level) {
 748                                         v = POP();
 749                                         DECREF(v);
 750                                 }
 751                         }
 752                         break;
 753
 754                 case END_FINALLY:
 755                         v = POP();
 756                         if (is_intobject(v)) {
 757                                 why = (enum why_code) getintvalue(v);
 758                                 if (why == WHY_RETURN)
 759                                         retval = POP();
 760                         }
 761                         else if (is_stringobject(v)) {
 762                                 w = POP();
 763                                 err_setval(v, w);
 764                                 DECREF(w);
 765                                 w = POP();
 766                                 tb_store(w);
 767                                 DECREF(w);
 768                                 why = WHY_RERAISE;
 769                         }
 770                         else if (v != None) {
 771                                 err_setstr(SystemError,
 772                                         "'finally' pops bad exception");
 773                                 why = WHY_EXCEPTION;
 774                         }
 775                         DECREF(v);
 776                         break;
 777
 778                 case BUILD_CLASS:
 779                         u = POP();
 780                         v = POP();
 781                         w = POP();
 782                         x = build_class(u, v, w);
 783                         PUSH(x);
 784                         DECREF(u);
 785                         DECREF(v);
 786                         DECREF(w);
 787                         break;
 788
 789                 case STORE_NAME:
 790                         w = GETNAMEV(oparg);
 791                         v = POP();
 792                         u = dict2lookup(f->f_locals, w);
 793                         if (u == NULL) {
 794                                 if (defmode != 0) {
 795                                         if (v != None)
 796                                                 u = (object *)v->ob_type;
 797                                         else
 798                                                 u = NULL;
 799                                         x = newaccessobject(v, f->f_locals,
 800                                                             (typeobject *)u,
 801                                                             defmode);
 802                                         DECREF(v);
 803                                         if (x == NULL)
 804                                                 break;
 805                                         v = x;
 806                                 }
 807                         }
 808                         else if (is_accessobject(u)) {
 809                                 err = setaccessvalue(u, f->f_locals, v);
 810                                 DECREF(v);
 811                                 break;
 812                         }
 813                         err = dict2insert(f->f_locals, w, v);
 814                         DECREF(v);
 815                         break;
 816
 817                 case DELETE_NAME:
 818                         w = GETNAMEV(oparg);
 819                         u = dict2lookup(f->f_locals, w);
 820                         if (u != NULL && is_accessobject(u)) {
 821                                 err = setaccessvalue(u, f->f_locals,
 822                                                      (object *)NULL);
 823                                 break;
 824                         }
 825                         if ((err = dict2remove(f->f_locals, w)) != 0)
 826                                 err_setval(NameError, w);
 827                         break;
 828
 829 #ifdef CASE_TOO_BIG
 830                 default: switch (opcode) {
 831 #endif
 832
 833                 case UNPACK_VARARG:
 834                         if (EMPTY()) {
 835                                 err_setstr(TypeError,
 836                                            "no argument list");
 837                                 why = WHY_EXCEPTION;
 838                                 break;
 839                         }
 840                         v = POP();
 841                         if (!is_tupleobject(v)) {
 842                                 err_setstr(TypeError,
 843                                            "bad argument list");
 844                                 why = WHY_EXCEPTION;
 845                         }
 846                         else if (gettuplesize(v) < oparg) {
 847                                 err_setstr(TypeError,
 848                                         "not enough arguments");
 849                                 why = WHY_EXCEPTION;
 850                         }
 851                         else if (oparg == 0) {
 852                                 PUSH(v);
 853                                 break;
 854                         }
 855                         else {
 856                                 x = gettupleslice(v, oparg, gettuplesize(v));
 857                                 if (x != NULL) {
 858                                         PUSH(x);
 859                                         if (!CHECK_STACK(oparg)) {
 860                                                 x = NULL;
 861                                                 break;
 862                                         }
 863                                         for (; --oparg >= 0; ) {
 864                                                 w = gettupleitem(v, oparg);
 865                                                 INCREF(w);
 866                                                 PUSH(w);
 867                                         }
 868                                 }
 869                         }
 870                         DECREF(v);
 871                         break;
 872
 873                 case UNPACK_ARG:
 874                         {
 875                                 int n;
 876                                 if (EMPTY()) {
 877                                         err_setstr(TypeError,
 878                                                    "no argument list");
 879                                         why = WHY_EXCEPTION;
 880                                         break;
 881                                 }
 882                                 v = POP();
 883                                 if (!is_tupleobject(v)) {
 884                                         err_setstr(TypeError,
 885                                                    "bad argument list");
 886                                         why = WHY_EXCEPTION;
 887                                         break;
 888                                 }
 889                                 n = gettuplesize(v);
 890 #ifdef COMPAT_HACKS
 891 /* Implement various compatibility hacks (for 0.9.4 or earlier):
 892    (a) f(a,b,...) accepts f((1,2,...))
 893    (b) f((a,b,...)) accepts f(1,2,...)
 894    (c) f(self,(a,b,...)) accepts f(x,1,2,...)
 895 */
 896                                 if (n == 1 && oparg != 1) {
 897                                         /* Rule (a) */
 898                                         w = gettupleitem(v, 0);
 899                                         if (is_tupleobject(w)) {
 900                                                 INCREF(w);
 901                                                 DECREF(v);
 902                                                 v = w;
 903                                                 n = gettuplesize(v);
 904                                         }
 905                                 }
 906                                 else if (n != 1 && oparg == 1) {
 907                                         /* Rule (b) */
 908                                         PUSH(v);
 909                                         break;
 910                                         /* Don't fall through */
 911                                 }
 912                                 else if (n > 2 && oparg == 2) {
 913                                         /* Rule (c) */
 914                                         int i;
 915                                         w = newtupleobject(n-1);
 916                                         u = newtupleobject(2);
 917                                         if (u == NULL || w == NULL) {
 918                                                 XDECREF(w);
 919                                                 XDECREF(u);
 920                                                 DECREF(v);
 921                                                 why = WHY_EXCEPTION;
 922                                                 break;
 923                                         }
 924                                         t = gettupleitem(v, 0);
 925                                         INCREF(t);
 926                                         settupleitem(u, 0, t);
 927                                         for (i = 1; i < n; i++) {
 928                                                 t = gettupleitem(v, i);
 929                                                 INCREF(t);
 930                                                 settupleitem(w, i-1, t);
 931                                         }
 932                                         settupleitem(u, 1, w);
 933                                         DECREF(v);
 934                                         v = u;
 935                                         n = 2;
 936                                 }
 937 #endif /* Disabled compatibility hacks */
 938                                 if (n != oparg) {
 939                                         err_setstr(TypeError,
 940                                                 "arg count mismatch");
 941                                         why = WHY_EXCEPTION;
 942                                         DECREF(v);
 943                                         break;
 944                                 }
 945                                 PUSH(v);
 946                         }
 947                         /* Fall through */
 948                 case UNPACK_TUPLE:
 949                         v = POP();
 950                         if (!is_tupleobject(v)) {
 951                                 err_setstr(TypeError, "unpack non-tuple");
 952                                 why = WHY_EXCEPTION;
 953                         }
 954                         else if (gettuplesize(v) != oparg) {
 955                                 err_setstr(ValueError,
 956                                         "unpack tuple of wrong size");
 957                                 why = WHY_EXCEPTION;
 958                         }
 959                         else {
 960                                 if (!CHECK_STACK(oparg)) {
 961                                         x = NULL;
 962                                         break;
 963                                 }
 964                                 for (; --oparg >= 0; ) {
 965                                         w = gettupleitem(v, oparg);
 966                                         INCREF(w);
 967                                         PUSH(w);
 968                                 }
 969                         }
 970                         DECREF(v);
 971                         break;
 972
 973                 case UNPACK_LIST:
 974                         v = POP();
 975                         if (!is_listobject(v)) {
 976                                 err_setstr(TypeError, "unpack non-list");
 977                                 why = WHY_EXCEPTION;
 978                         }
 979                         else if (getlistsize(v) != oparg) {
 980                                 err_setstr(ValueError,
 981                                         "unpack list of wrong size");
 982                                 why = WHY_EXCEPTION;
 983                         }
 984                         else {
 985                                 if (!CHECK_STACK(oparg)) {
 986                                         x = NULL;
 987                                         break;
 988                                 }
 989                                 for (; --oparg >= 0; ) {
 990                                         w = getlistitem(v, oparg);
 991                                         INCREF(w);
 992                                         PUSH(w);
 993                                 }
 994                         }
 995                         DECREF(v);
 996                         break;
 997
 998                 case STORE_ATTR:
 999                         w = GETNAMEV(oparg);
1000                         v = POP();
1001                         u = POP();
1002                         err = setattro(v, w, u); /* v.w = u */
1003                         DECREF(v);
1004                         DECREF(u);
1005                         break;
1006
1007                 case DELETE_ATTR:
1008                         w = GETNAMEV(oparg);
1009                         v = POP();
1010                         err = setattro(v, w, (object *)NULL); /* del v.w */
1011                         DECREF(v);
1012                         break;
1013
1014                 case STORE_GLOBAL:
1015                         w = GETNAMEV(oparg);
1016                         v = POP();
1017                         u = dict2lookup(f->f_locals, w);
1018                         if (u != NULL && is_accessobject(u)) {
1019                                 err = setaccessvalue(u, f->f_globals, v);
1020                                 DECREF(v);
1021                                 break;
1022                         }
1023                         err = dict2insert(f->f_globals, w, v);
1024                         DECREF(v);
1025                         break;
1026
1027                 case DELETE_GLOBAL:
1028                         w = GETNAMEV(oparg);
1029                         u = dict2lookup(f->f_locals, w);
1030                         if (u != NULL && is_accessobject(u)) {
1031                                 err = setaccessvalue(u, f->f_globals,
1032                                                      (object *)NULL);
1033                                 break;
1034                         }
1035                         if ((err = dict2remove(f->f_globals, w)) != 0)
1036                                 err_setval(NameError, w);
1037                         break;
1038
1039                 case LOAD_CONST:
1040                         x = GETCONST(oparg);
1041                         INCREF(x);
1042                         PUSH(x);
1043                         break;
1044
1045                 case LOAD_NAME:
1046                         w = GETNAMEV(oparg);
1047                         x = dict2lookup(f->f_locals, w);
1048                         if (x == NULL) {
1049                                 err_clear();
1050                                 x = dict2lookup(f->f_globals, w);
1051                                 if (x == NULL) {
1052                                         err_clear();
1053                                         x = getbuiltin(w);
1054                                         if (x == NULL) {
1055                                                 err_setval(NameError, w);
1056                                                 break;
1057                                         }
1058                                 }
1059                         }
1060                         if (is_accessobject(x)) {
1061                                 x = getaccessvalue(x, f->f_globals /* XXX */);
1062                                 if (x == NULL)
1063                                         break;
1064                         }
1065                         else
1066                                 INCREF(x);
1067                         PUSH(x);
1068                         break;
1069
1070                 case LOAD_GLOBAL:
1071                         w = GETNAMEV(oparg);
1072                         x = dict2lookup(f->f_globals, w);
1073                         if (x == NULL) {
1074                                 err_clear();
1075                                 x = getbuiltin(w);
1076                                 if (x == NULL) {
1077                                         err_setval(NameError, w);
1078                                         break;
1079                                 }
1080                         }
1081                         if (is_accessobject(x)) {
1082                                 x = getaccessvalue(x, f->f_globals);
1083                                 if (x == NULL)
1084                                         break;
1085                         }
1086                         else
1087                                 INCREF(x);
1088                         PUSH(x);
1089                         break;
1090
1091                 case LOAD_LOCAL:
1092                         w = GETNAMEV(oparg);
1093                         x = dict2lookup(f->f_locals, w);
1094                         if (x == NULL) {
1095                                 err_setval(NameError, w);
1096                                 break;
1097                         }
1098                         if (is_accessobject(x)) {
1099                                 x = getaccessvalue(x, f->f_locals);
1100                                 if (x == NULL)
1101                                         break;
1102                         }
1103                         else
1104                                 INCREF(x);
1105                         PUSH(x);
1106                         break;
1107
1108                 case RESERVE_FAST:
1109                         x = GETCONST(oparg);
1110                         if (x == None)
1111                                 break;
1112                         if (x == NULL || !is_dictobject(x)) {
1113                                 fatal("bad RESERVE_FAST");
1114                                 err_setstr(SystemError, "bad RESERVE_FAST");
1115                                 x = NULL;
1116                                 break;
1117                         }
1118                         XDECREF(f->f_fastlocals);
1119                         XDECREF(f->f_localmap);
1120                         INCREF(x);
1121                         f->f_localmap = x;
1122                         f->f_fastlocals = x = newlistobject(
1123                             x->ob_type->tp_as_mapping->mp_length(x));
1124                         fastlocals = (listobject *) x;
1125                         break;
1126
1127                 case LOAD_FAST:
1128                         x = GETLISTITEM(fastlocals, oparg);
1129                         if (x == NULL) {
1130                                 err_setstr(NameError,
1131                                            "undefined local variable");
1132                                 break;
1133                         }
1134                         if (is_accessobject(x)) {
1135                                 x = getaccessvalue(x, f->f_locals);
1136                                 if (x == NULL)
1137                                         break;
1138                         }
1139                         else
1140                                 INCREF(x);
1141                         PUSH(x);
1142                         break;
1143
1144                 case STORE_FAST:
1145                         v = POP();
1146                         w = GETLISTITEM(fastlocals, oparg);
1147                         if (w != NULL && is_accessobject(w)) {
1148                                 err = setaccessvalue(w, f->f_locals, v);
1149                                 DECREF(v);
1150                                 break;
1151                         }
1152                         XDECREF(w);
1153                         GETLISTITEM(fastlocals, oparg) = v;
1154                         break;
1155
1156                 case DELETE_FAST:
1157                         x = GETLISTITEM(fastlocals, oparg);
1158                         if (x == NULL) {
1159                                 err_setstr(NameError,
1160                                            "undefined local variable");
1161                                 break;
1162                         }
1163                         if (w != NULL && is_accessobject(w)) {
1164                                 err = setaccessvalue(w, f->f_locals,
1165                                                      (object *)NULL);
1166                                 break;
1167                         }
1168                         DECREF(x);
1169                         GETLISTITEM(fastlocals, oparg) = NULL;
1170                         break;
1171
1172                 case BUILD_TUPLE:
1173                         x = newtupleobject(oparg);
1174                         if (x != NULL) {
1175                                 for (; --oparg >= 0;) {
1176                                         w = POP();
1177                                         err = settupleitem(x, oparg, w);
1178                                         if (err != 0)
1179                                                 break;
1180                                 }
1181                                 PUSH(x);
1182                         }
1183                         break;
1184
1185                 case BUILD_LIST:
1186                         x =  newlistobject(oparg);
1187                         if (x != NULL) {
1188                                 for (; --oparg >= 0;) {
1189                                         w = POP();
1190                                         err = setlistitem(x, oparg, w);
1191                                         if (err != 0)
1192                                                 break;
1193                                 }
1194                                 PUSH(x);
1195                         }
1196                         break;
1197
1198                 case BUILD_MAP:
1199                         x = newdictobject();
1200                         PUSH(x);
1201                         break;
1202
1203                 case LOAD_ATTR:
1204                         w = GETNAMEV(oparg);
1205                         v = POP();
1206                         x = getattro(v, w);
1207                         DECREF(v);
1208                         PUSH(x);
1209                         break;
1210
1211                 case COMPARE_OP:
1212                         w = POP();
1213                         v = POP();
1214                         x = cmp_outcome(oparg, v, w);
1215                         DECREF(v);
1216                         DECREF(w);
1217                         PUSH(x);
1218                         break;
1219
1220                 case IMPORT_NAME:
1221                         name = GETNAME(oparg);
1222                         x = import_module(name);
1223                         XINCREF(x);
1224                         PUSH(x);
1225                         break;
1226
1227                 case IMPORT_FROM:
1228                         w = GETNAMEV(oparg);
1229                         v = TOP();
1230                         err = import_from(f->f_locals, v, w);
1231                         locals_2_fast(f, 0);
1232                         break;
1233
1234                 case ACCESS_MODE:
1235                         v = POP();
1236                         w = GETNAMEV(oparg);
1237                         if (getstringvalue(w)[0] == '*')
1238                                 defmode = getintvalue(v);
1239                         else
1240                                 err = access_statement(w, v, f);
1241                         DECREF(v);
1242                         break;
1243
1244                 case JUMP_FORWARD:
1245                         JUMPBY(oparg);
1246                         break;
1247
1248                 case JUMP_IF_FALSE:
1249                         err = testbool(TOP());
1250                         if (err > 0)
1251                                 err = 0;
1252                         else if (err == 0)
1253                                 JUMPBY(oparg);
1254                         break;
1255
1256                 case JUMP_IF_TRUE:
1257                         err = testbool(TOP());
1258                         if (err > 0) {
1259                                 err = 0;
1260                                 JUMPBY(oparg);
1261                         }
1262                         break;
1263
1264                 case JUMP_ABSOLUTE:
1265                         JUMPTO(oparg);
1266                         break;
1267
1268                 case FOR_LOOP:
1269                         /* for v in s: ...
1270                            On entry: stack contains s, i.
1271                            On exit: stack contains s, i+1, s[i];
1272                            but if loop exhausted:
1273                                 s, i are popped, and we jump */
1274                         w = POP(); /* Loop index */
1275                         v = POP(); /* Sequence object */
1276                         u = loop_subscript(v, w);
1277                         if (u != NULL) {
1278                                 PUSH(v);
1279                                 x = newintobject(getintvalue(w)+1);
1280                                 PUSH(x);
1281                                 DECREF(w);
1282                                 PUSH(u);
1283                         }
1284                         else {
1285                                 DECREF(v);
1286                                 DECREF(w);
1287                                 /* A NULL can mean "s exhausted"
1288                                    but also an error: */
1289                                 if (err_occurred())
1290                                         why = WHY_EXCEPTION;
1291                                 else
1292                                         JUMPBY(oparg);
1293                         }
1294                         break;
1295
1296                 case SETUP_LOOP:
1297                 case SETUP_EXCEPT:
1298                 case SETUP_FINALLY:
1299                         setup_block(f, opcode, INSTR_OFFSET() + oparg,
1300                                                 STACK_LEVEL());
1301                         break;
1302
1303                 case SET_LINENO:
1304 #ifdef LLTRACE
1305                         if (lltrace)
1306                                 printf("--- Line %d ---\n", oparg);
1307 #endif
1308                         f->f_lineno = oparg;
1309                         if (trace != NULL) {
1310                                 /* Trace each line of code reached */
1311                                 f->f_lasti = INSTR_OFFSET();
1312                                 err = call_trace(&trace, &trace,
1313                                                  f, "line", None);
1314                         }
1315                         break;
1316
1317                 default:
1318                         fprintf(stderr,
1319                                 "XXX lineno: %d, opcode: %d\n",
1320                                 f->f_lineno, opcode);
1321                         err_setstr(SystemError, "eval_code: unknown opcode");
1322                         why = WHY_EXCEPTION;
1323                         break;
1324
1325 #ifdef CASE_TOO_BIG
1326                 }
1327 #endif
1328
1329                 } /* switch */
1330
1331             on_error:
1332
1333                 /* Quickly continue if no error occurred */
1334
1335                 if (why == WHY_NOT) {
1336                         if (err == 0 && x != NULL)
1337                                 continue; /* Normal, fast path */
1338                         why = WHY_EXCEPTION;
1339                         x = None;
1340                         err = 0;
1341                 }
1342
1343 #ifdef CHECKEXC
1344                 /* Double-check exception status */
1345
1346                 if (why == WHY_EXCEPTION || why == WHY_RERAISE) {
1347                         if (!err_occurred()) {
1348                                 fprintf(stderr, "XXX ghost error\n");
1349                                 err_setstr(SystemError, "ghost error");
1350                                 why = WHY_EXCEPTION;
1351                         }
1352                 }
1353                 else {
1354                         if (err_occurred()) {
1355                                 fprintf(stderr, "XXX undetected error\n");
1356                                 abort();
1357                                 /* NOTREACHED */
1358                                 why = WHY_EXCEPTION;
1359                         }
1360                 }
1361 #endif
1362
1363                 /* Log traceback info if this is a real exception */
1364
1365                 if (why == WHY_EXCEPTION) {
1366                         f->f_lasti = INSTR_OFFSET() - 1;
1367                         if (HAS_ARG(opcode))
1368                                 f->f_lasti -= 2;
1369                         tb_here(f);
1370
1371                         if (trace)
1372                                 call_exc_trace(&trace, &trace, f);
1373                         if (sys_profile)
1374                                 call_exc_trace(&sys_profile, (object**)0, f);
1375                 }
1376
1377                 /* For the rest, treat WHY_RERAISE as WHY_EXCEPTION */
1378
1379                 if (why == WHY_RERAISE)
1380                         why = WHY_EXCEPTION;
1381
1382                 /* Unwind stacks if a (pseudo) exception occurred */
1383
1384                 while (why != WHY_NOT && f->f_iblock > 0) {
1385                         block *b = pop_block(f);
1386                         while (STACK_LEVEL() > b->b_level) {
1387                                 v = POP();
1388                                 XDECREF(v);
1389                         }
1390                         if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
1391                                 why = WHY_NOT;
1392                                 JUMPTO(b->b_handler);
1393                                 break;
1394                         }
1395                         if (b->b_type == SETUP_FINALLY ||
1396                                         b->b_type == SETUP_EXCEPT &&
1397                                         why == WHY_EXCEPTION) {
1398                                 if (why == WHY_EXCEPTION) {
1399                                         object *exc, *val;
1400                                         err_get(&exc, &val);
1401                                         if (val == NULL) {
1402                                                 val = None;
1403                                                 INCREF(val);
1404                                         }
1405                                         v = tb_fetch();
1406                                         /* Make the raw exception data
1407                                            available to the handler,
1408                                            so a program can emulate the
1409                                            Python main loop.  Don't do
1410                                            this for 'finally'. */
1411                                         if (b->b_type == SETUP_EXCEPT) {
1412                                                 sysset("exc_traceback", v);
1413                                                 sysset("exc_value", val);
1414                                                 sysset("exc_type", exc);
1415                                         }
1416                                         PUSH(v);
1417                                         PUSH(val);
1418                                         PUSH(exc);
1419                                 }
1420                                 else {
1421                                         if (why == WHY_RETURN)
1422                                                 PUSH(retval);
1423                                         v = newintobject((long)why);
1424                                         PUSH(v);
1425                                 }
1426                                 why = WHY_NOT;
1427                                 JUMPTO(b->b_handler);
1428                                 break;
1429                         }
1430                 } /* unwind stack */
1431
1432                 /* End the loop if we still have an error (or return) */
1433
1434                 if (why != WHY_NOT)
1435                         break;
1436
1437         } /* main loop */
1438
1439         /* Pop remaining stack entries */
1440
1441         while (!EMPTY()) {
1442                 v = POP();
1443                 XDECREF(v);
1444         }
1445
1446         if (why != WHY_RETURN)
1447                 retval = NULL;
1448
1449         if (trace) {
1450                 if (why == WHY_RETURN) {
1451                         if (call_trace(&trace, &trace, f, "return", retval)) {
1452                                 XDECREF(retval);
1453                                 retval = NULL;
1454                                 why = WHY_EXCEPTION;
1455                         }
1456                 }
1457                 XDECREF(trace);
1458         }
1459
1460         if (sys_profile && why == WHY_RETURN) {
1461                 if (call_trace(&sys_profile, (object**)0,
1462                                f, "return", retval)) {
1463                         XDECREF(retval);
1464                         retval = NULL;
1465                         why = WHY_EXCEPTION;
1466                 }
1467         }
1468
1469         if (fastlocals && (f->ob_refcnt > 1 || f->f_locals->ob_refcnt > 2))
1470                 fast_2_locals(f);
1471
1472         /* Restore previous frame and release the current one */
1473
1474         current_frame = f->f_back;
1475         DECREF(f);
1476
1477         if (needmerge)
1478                 locals_2_fast(current_frame, 1);
1479
1480         return retval;
1481 }
1482
1483 #ifdef LLTRACE
1484 static int
1485 prtrace(v, str)
1486         object *v;
1487         char *str;
1488 {
1489         printf("%s ", str);
1490         if (printobject(v, stdout, 0) != 0)
1491                 err_clear(); /* Don't know what else to do */
1492         printf("\n");
1493 }
1494 #endif
1495
1496 static void
1497 call_exc_trace(p_trace, p_newtrace, f)
1498         object **p_trace, **p_newtrace;
1499         frameobject *f;
1500 {
1501         object *type, *value, *traceback, *arg;
1502         int err;
1503         err_get(&type, &value);
1504         if (value == NULL) {
1505                 value = None;
1506                 INCREF(value);
1507         }
1508         traceback = tb_fetch();
1509         arg = newtupleobject(3);
1510         if (arg == NULL)
1511                 goto cleanup;
1512         settupleitem(arg, 0, type);
1513         settupleitem(arg, 1, value);
1514         settupleitem(arg, 2, traceback);
1515         err = call_trace(p_trace, p_newtrace, f, "exception", arg);
1516         if (!err) {
1517  cleanup:
1518                 /* Restore original exception */
1519                 err_setval(type, value);
1520                 tb_store(traceback);
1521         }
1522         XDECREF(arg);
1523 }
1524
1525 static int
1526 call_trace(p_trace, p_newtrace, f, msg, arg)
1527         object **p_trace; /* in/out; may not be NULL;
1528                              may not point to NULL variable initially */
1529         object **p_newtrace; /* in/out; may be NULL;
1530                                 may point to NULL variable;
1531                                 may be same variable as p_newtrace */
1532         frameobject *f;
1533         char *msg;
1534         object *arg;
1535 {
1536         object *arglist, *what;
1537         object *res = NULL;
1538         static int tracing = 0;
1539
1540         if (tracing) {
1541                 /* Don't do recursive traces */
1542                 if (p_newtrace) {
1543                         XDECREF(*p_newtrace);
1544                         *p_newtrace = NULL;
1545                 }
1546                 return 0;
1547         }
1548
1549         arglist = newtupleobject(3);
1550         if (arglist == NULL)
1551                 goto cleanup;
1552         what = newstringobject(msg);
1553         if (what == NULL)
1554                 goto cleanup;
1555         INCREF(f);
1556         settupleitem(arglist, 0, (object *)f);
1557         settupleitem(arglist, 1, what);
1558         if (arg == NULL)
1559                 arg = None;
1560         INCREF(arg);
1561         settupleitem(arglist, 2, arg);
1562         tracing++;
1563         fast_2_locals(f);
1564         res = call_object(*p_trace, arglist);
1565         locals_2_fast(f, 1);
1566         tracing--;
1567  cleanup:
1568         XDECREF(arglist);
1569         if (res == NULL) {
1570                 /* The trace proc raised an exception */
1571                 tb_here(f);
1572                 DECREF(*p_trace);
1573                 *p_trace = NULL;
1574                 if (p_newtrace) {
1575                         XDECREF(*p_newtrace);
1576                         *p_newtrace = NULL;
1577                 }
1578                 return -1;
1579         }
1580         else {
1581                 if (p_newtrace) {
1582                         XDECREF(*p_newtrace);
1583                         if (res == None)
1584                                 *p_newtrace = NULL;
1585                         else {
1586                                 INCREF(res);
1587                                 *p_newtrace = res;
1588                         }
1589                 }
1590                 DECREF(res);
1591                 return 0;
1592         }
1593 }
1594
1595 static void
1596 fast_2_locals(f)
1597         frameobject *f;
1598 {
1599         /* Merge f->f_fastlocals into f->f_locals */
1600         object *locals, *fast, *map;
1601         object *error_type, *error_value;
1602         int pos;
1603         object *key, *value;
1604         if (f == NULL)
1605                 return;
1606         locals = f->f_locals;
1607         fast = f->f_fastlocals;
1608         map = f->f_localmap;
1609         if (locals == NULL || fast == NULL || map == NULL)
1610                 return;
1611         if (!is_dictobject(locals) || !is_listobject(fast) ||
1612             !is_dictobject(map))
1613                 return;
1614         err_get(&error_type, &error_value);
1615         pos = 0;
1616         while (mappinggetnext(map, &pos, &key, &value)) {
1617                 int j;
1618                 if (!is_intobject(value))
1619                         continue;
1620                 j = getintvalue(value);
1621                 value = getlistitem(fast, j);
1622                 if (value == NULL) {
1623                         err_clear();
1624                         if (dict2remove(locals, key) != 0)
1625                                 err_clear();
1626                 }
1627                 else {
1628                         if (dict2insert(locals, key, value) != 0)
1629                                 err_clear();
1630                 }
1631         }
1632         err_setval(error_type, error_value);
1633 }
1634
1635 static void
1636 locals_2_fast(f, clear)
1637         frameobject *f;
1638         int clear;
1639 {
1640         /* Merge f->f_locals into f->f_fastlocals */
1641         object *locals, *fast, *map;
1642         object *error_type, *error_value;
1643         int pos;
1644         object *key, *value;
1645         if (f == NULL)
1646                 return;
1647         locals = f->f_locals;
1648         fast = f->f_fastlocals;
1649         map = f->f_localmap;
1650         if (locals == NULL || fast == NULL || map == NULL)
1651                 return;
1652         if (!is_dictobject(locals) || !is_listobject(fast) ||
1653             !is_dictobject(map))
1654                 return;
1655         err_get(&error_type, &error_value);
1656         pos = 0;
1657         while (mappinggetnext(map, &pos, &key, &value)) {
1658                 int j;
1659                 if (!is_intobject(value))
1660                         continue;
1661                 j = getintvalue(value);
1662                 value = dict2lookup(locals, key);
1663                 if (value == NULL)
1664                         err_clear();
1665                 else
1666                         INCREF(value);
1667                 if (value != NULL || clear)
1668                         if (setlistitem(fast, j, value) != 0)
1669                                 err_clear();
1670         }
1671         err_setval(error_type, error_value);
1672 }
1673
1674 static void
1675 mergelocals()
1676 {
1677         locals_2_fast(current_frame, 1);
1678 }
1679
1680 object *
1681 getlocals()
1682 {
1683         if (current_frame == NULL)
1684                 return NULL;
1685         fast_2_locals(current_frame);
1686         return current_frame->f_locals;
1687 }
1688
1689 object *
1690 getglobals()
1691 {
1692         if (current_frame == NULL)
1693                 return NULL;
1694         else
1695                 return current_frame->f_globals;
1696 }
1697
1698 object *
1699 getowner()
1700 {
1701         if (current_frame == NULL)
1702                 return NULL;
1703         else
1704                 return current_frame->f_owner;
1705 }
1706
1707 void
1708 printtraceback(f)
1709         object *f;
1710 {
1711         object *v = tb_fetch();
1712         if (v != NULL) {
1713                 tb_print(v, f);
1714                 DECREF(v);
1715         }
1716 }
1717
1718
1719 void
1720 flushline()
1721 {
1722         object *f = sysget("stdout");
1723         if (softspace(f, 0))
1724                 writestring("\n", f);
1725 }
1726
1727
1728 static object *
1729 or(v, w)
1730         object *v, *w;
1731 {
1732         if (v->ob_type->tp_as_number != NULL) {
1733                 object *x;
1734                 object * (*f) FPROTO((object *, object *));
1735                 if (coerce(&v, &w) != 0)
1736                         return NULL;
1737                 if ((f = v->ob_type->tp_as_number->nb_or) != NULL)
1738                         x = (*f)(v, w);
1739                 DECREF(v);
1740                 DECREF(w);
1741                 if (f != NULL)
1742                         return x;
1743         }
1744         err_setstr(TypeError, "bad operand type(s) for |");
1745         return NULL;
1746 }
1747
1748 static object *
1749 xor(v, w)
1750         object *v, *w;
1751 {
1752         if (v->ob_type->tp_as_number != NULL) {
1753                 object *x;
1754                 object * (*f) FPROTO((object *, object *));
1755                 if (coerce(&v, &w) != 0)
1756                         return NULL;
1757                 if ((f = v->ob_type->tp_as_number->nb_xor) != NULL)
1758                         x = (*f)(v, w);
1759                 DECREF(v);
1760                 DECREF(w);
1761                 if (f != NULL)
1762                         return x;
1763         }
1764         err_setstr(TypeError, "bad operand type(s) for ^");
1765         return NULL;
1766 }
1767
1768 static object *
1769 and(v, w)
1770         object *v, *w;
1771 {
1772         if (v->ob_type->tp_as_number != NULL) {
1773                 object *x;
1774                 object * (*f) FPROTO((object *, object *));
1775                 if (coerce(&v, &w) != 0)
1776                         return NULL;
1777                 if ((f = v->ob_type->tp_as_number->nb_and) != NULL)
1778                         x = (*f)(v, w);
1779                 DECREF(v);
1780                 DECREF(w);
1781                 if (f != NULL)
1782                         return x;
1783         }
1784         err_setstr(TypeError, "bad operand type(s) for &");
1785         return NULL;
1786 }
1787
1788 static object *
1789 lshift(v, w)
1790         object *v, *w;
1791 {
1792         if (v->ob_type->tp_as_number != NULL) {
1793                 object *x;
1794                 object * (*f) FPROTO((object *, object *));
1795                 if (coerce(&v, &w) != 0)
1796                         return NULL;
1797                 if ((f = v->ob_type->tp_as_number->nb_lshift) != NULL)
1798                         x = (*f)(v, w);
1799                 DECREF(v);
1800                 DECREF(w);
1801                 if (f != NULL)
1802                         return x;
1803         }
1804         err_setstr(TypeError, "bad operand type(s) for <<");
1805         return NULL;
1806 }
1807
1808 static object *
1809 rshift(v, w)
1810         object *v, *w;
1811 {
1812         if (v->ob_type->tp_as_number != NULL) {
1813                 object *x;
1814                 object * (*f) FPROTO((object *, object *));
1815                 if (coerce(&v, &w) != 0)
1816                         return NULL;
1817                 if ((f = v->ob_type->tp_as_number->nb_rshift) != NULL)
1818                         x = (*f)(v, w);
1819                 DECREF(v);
1820                 DECREF(w);
1821                 if (f != NULL)
1822                         return x;
1823         }
1824         err_setstr(TypeError, "bad operand type(s) for >>");
1825         return NULL;
1826 }
1827
1828 static object *
1829 add(v, w)
1830         object *v, *w;
1831 {
1832         if (v->ob_type->tp_as_sequence != NULL)
1833                 return (*v->ob_type->tp_as_sequence->sq_concat)(v, w);
1834         else if (v->ob_type->tp_as_number != NULL) {
1835                 object *x;
1836                 if (coerce(&v, &w) != 0)
1837                         return NULL;
1838                 x = (*v->ob_type->tp_as_number->nb_add)(v, w);
1839                 DECREF(v);
1840                 DECREF(w);
1841                 return x;
1842         }
1843         err_setstr(TypeError, "bad operand type(s) for +");
1844         return NULL;
1845 }
1846
1847 static object *
1848 sub(v, w)
1849         object *v, *w;
1850 {
1851         if (v->ob_type->tp_as_number != NULL) {
1852                 object *x;
1853                 if (coerce(&v, &w) != 0)
1854                         return NULL;
1855                 x = (*v->ob_type->tp_as_number->nb_subtract)(v, w);
1856                 DECREF(v);
1857                 DECREF(w);
1858                 return x;
1859         }
1860         err_setstr(TypeError, "bad operand type(s) for -");
1861         return NULL;
1862 }
1863
1864 static object *
1865 mul(v, w)
1866         object *v, *w;
1867 {
1868         typeobject *tp;
1869         tp = v->ob_type;
1870         if (tp->tp_as_number != NULL &&
1871             w->ob_type->tp_as_sequence != NULL &&
1872             !is_instanceobject(v)) {
1873                 /* number*sequence -- swap v and w */
1874                 object *tmp = v;
1875                 v = w;
1876                 w = tmp;
1877                 tp = v->ob_type;
1878         }
1879         if (tp->tp_as_number != NULL) {
1880                 object *x;
1881                 if (is_instanceobject(v)) {
1882                         /* Instances of user-defined classes get their
1883                            other argument uncoerced, so they may
1884                            implement sequence*number as well as
1885                            number*number. */
1886                         INCREF(v);
1887                         INCREF(w);
1888                 }
1889                 else if (coerce(&v, &w) != 0)
1890                         return NULL;
1891                 x = (*v->ob_type->tp_as_number->nb_multiply)(v, w);
1892                 DECREF(v);
1893                 DECREF(w);
1894                 return x;
1895         }
1896         if (tp->tp_as_sequence != NULL) {
1897                 if (!is_intobject(w)) {
1898                         err_setstr(TypeError,
1899                                 "can't multiply sequence with non-int");
1900                         return NULL;
1901                 }
1902                 return (*tp->tp_as_sequence->sq_repeat)
1903                                                 (v, (int)getintvalue(w));
1904         }
1905         err_setstr(TypeError, "bad operand type(s) for *");
1906         return NULL;
1907 }
1908
1909 static object *
1910 divide(v, w)
1911         object *v, *w;
1912 {
1913         if (v->ob_type->tp_as_number != NULL) {
1914                 object *x;
1915                 if (coerce(&v, &w) != 0)
1916                         return NULL;
1917                 x = (*v->ob_type->tp_as_number->nb_divide)(v, w);
1918                 DECREF(v);
1919                 DECREF(w);
1920                 return x;
1921         }
1922         err_setstr(TypeError, "bad operand type(s) for /");
1923         return NULL;
1924 }
1925
1926 static object *
1927 rem(v, w)
1928         object *v, *w;
1929 {
1930         if (v->ob_type->tp_as_number != NULL) {
1931                 object *x;
1932                 if (coerce(&v, &w) != 0)
1933                         return NULL;
1934                 x = (*v->ob_type->tp_as_number->nb_remainder)(v, w);
1935                 DECREF(v);
1936                 DECREF(w);
1937                 return x;
1938         }
1939         if (is_stringobject(v)) {
1940                 return formatstring(v, w);
1941         }
1942         err_setstr(TypeError, "bad operand type(s) for %");
1943         return NULL;
1944 }
1945
1946 static object *
1947 neg(v)
1948         object *v;
1949 {
1950         if (v->ob_type->tp_as_number != NULL)
1951                 return (*v->ob_type->tp_as_number->nb_negative)(v);
1952         err_setstr(TypeError, "bad operand type(s) for unary -");
1953         return NULL;
1954 }
1955
1956 static object *
1957 pos(v)
1958         object *v;
1959 {
1960         if (v->ob_type->tp_as_number != NULL)
1961                 return (*v->ob_type->tp_as_number->nb_positive)(v);
1962         err_setstr(TypeError, "bad operand type(s) for unary +");
1963         return NULL;
1964 }
1965
1966 static object *
1967 invert(v)
1968         object *v;
1969 {
1970         object * (*f) FPROTO((object *));
1971         if (v->ob_type->tp_as_number != NULL &&
1972                 (f = v->ob_type->tp_as_number->nb_invert) != NULL)
1973                 return (*f)(v);
1974         err_setstr(TypeError, "bad operand type(s) for unary ~");
1975         return NULL;
1976 }
1977
1978 static object *
1979 not(v)
1980         object *v;
1981 {
1982         int outcome = testbool(v);
1983         object *w;
1984         if (outcome < 0)
1985                 return NULL;
1986         if (outcome == 0)
1987                 w = True;
1988         else
1989                 w = False;
1990         INCREF(w);
1991         return w;
1992 }
1993
1994
1995 /* External interface to call any callable object. The arg may be NULL. */
1996
1997 object *
1998 call_object(func, arg)
1999         object *func;
2000         object *arg;
2001 {
2002         if (is_instancemethodobject(func) || is_funcobject(func))
2003                 return call_function(func, arg);
2004         else
2005                 return call_builtin(func, arg);
2006 }
2007
2008 static object *
2009 call_builtin(func, arg)
2010         object *func;
2011         object *arg;
2012 {
2013         if (is_methodobject(func)) {
2014                 method meth = getmethod(func);
2015                 object *self = getself(func);
2016                 if (!getvarargs(func) && arg != NULL && is_tupleobject(arg)) {
2017                         int size = gettuplesize(arg);
2018                         if (size == 1)
2019                                 arg = gettupleitem(arg, 0);
2020                         else if (size == 0)
2021                                 arg = NULL;
2022                 }
2023                 return (*meth)(self, arg);
2024         }
2025         if (is_classobject(func)) {
2026                 return newinstanceobject(func, arg);
2027         }
2028         err_setstr(TypeError, "call of non-function");
2029         return NULL;
2030 }
2031
2032 static object *
2033 call_function(func, arg)
2034         object *func;
2035         object *arg;
2036 {
2037         object *newarg = NULL;
2038         object *newlocals, *newglobals;
2039         object *class = NULL;
2040         object *co, *v;
2041
2042         if (is_instancemethodobject(func)) {
2043                 object *self = instancemethodgetself(func);
2044                 class = instancemethodgetclass(func);
2045                 func = instancemethodgetfunc(func);
2046                 if (self == NULL) {
2047                         /* Unbound methods must be called with an instance of
2048                            the class (or a derived class) as first argument */
2049                         if (arg != NULL && is_tupleobject(arg) &&
2050                             gettuplesize(arg) >= 1) {
2051                                 self = gettupleitem(arg, 0);
2052                                 if (self != NULL &&
2053                                     is_instanceobject(self) &&
2054                                     issubclass((object *)
2055                                       (((instanceobject *)self)->in_class),
2056                                                class))
2057                                         /* self = self */ ;
2058                                 else
2059                                         self = NULL;
2060                         }
2061                         if (self == NULL) {
2062                                 err_setstr(TypeError,
2063            "unbound method must be called with class instance argument");
2064                                 return NULL;
2065                         }
2066                 }
2067                 else {
2068                         int argcount;
2069                         if (arg == NULL)
2070                                 argcount = 0;
2071                         else if (is_tupleobject(arg))
2072                                 argcount = gettuplesize(arg);
2073                         else
2074                                 argcount = 1;
2075                         newarg = newtupleobject(argcount + 1);
2076                         if (newarg == NULL)
2077                                 return NULL;
2078                         INCREF(self);
2079                         settupleitem(newarg, 0, self);
2080                         if (arg != NULL && !is_tupleobject(arg)) {
2081                                 INCREF(arg);
2082                                 settupleitem(newarg, 1, arg);
2083                         }
2084                         else {
2085                                 int i;
2086                                 object *v;
2087                                 for (i = 0; i < argcount; i++) {
2088                                         v = gettupleitem(arg, i);
2089                                         XINCREF(v);
2090                                         settupleitem(newarg, i+1, v);
2091                                 }
2092                         }
2093                         arg = newarg;
2094                 }
2095         }
2096         else {
2097                 if (!is_funcobject(func)) {
2098                         err_setstr(TypeError, "call of non-function");
2099                         return NULL;
2100                 }
2101         }
2102
2103         co = getfunccode(func);
2104         if (co == NULL) {
2105                 XDECREF(newarg);
2106                 return NULL;
2107         }
2108         if (!is_codeobject(co)) {
2109                 fprintf(stderr, "XXX Bad code\n");
2110                 abort();
2111         }
2112         newlocals = newdictobject();
2113         if (newlocals == NULL) {
2114                 XDECREF(newarg);
2115                 return NULL;
2116         }
2117
2118         newglobals = getfuncglobals(func);
2119         INCREF(newglobals);
2120
2121         v = eval_code((codeobject *)co, newglobals, newlocals, class, arg);
2122
2123         DECREF(newlocals);
2124         DECREF(newglobals);
2125
2126         XDECREF(newarg);
2127
2128         return v;
2129 }
2130
2131 static object *
2132 apply_subscript(v, w)
2133         object *v, *w;
2134 {
2135         typeobject *tp = v->ob_type;
2136         if (tp->tp_as_sequence == NULL && tp->tp_as_mapping == NULL) {
2137                 err_setstr(TypeError, "unsubscriptable object");
2138                 return NULL;
2139         }
2140         if (tp->tp_as_mapping != NULL) {
2141                 return (*tp->tp_as_mapping->mp_subscript)(v, w);
2142         }
2143         else {
2144                 int i;
2145                 if (!is_intobject(w)) {
2146                         err_setstr(TypeError, "sequence subscript not int");
2147                         return NULL;
2148                 }
2149                 i = getintvalue(w);
2150                 if (i < 0) {
2151                         int len = (*tp->tp_as_sequence->sq_length)(v);
2152                         if (len < 0)
2153                                 return NULL;
2154                         i += len;
2155                 }
2156                 return (*tp->tp_as_sequence->sq_item)(v, i);
2157         }
2158 }
2159
2160 static object *
2161 loop_subscript(v, w)
2162         object *v, *w;
2163 {
2164         sequence_methods *sq = v->ob_type->tp_as_sequence;
2165         int i, n;
2166         if (sq == NULL) {
2167                 err_setstr(TypeError, "loop over non-sequence");
2168                 return NULL;
2169         }
2170         i = getintvalue(w);
2171         n = (*sq->sq_length)(v);
2172         if (n < 0)
2173                 return NULL; /* Exception */
2174         if (i >= n)
2175                 return NULL; /* End of loop */
2176         return (*sq->sq_item)(v, i);
2177 }
2178
2179 static int
2180 slice_index(v, isize, pi)
2181         object *v;
2182         int isize;
2183         int *pi;
2184 {
2185         if (v != NULL) {
2186                 if (!is_intobject(v)) {
2187                         err_setstr(TypeError, "slice index must be int");
2188                         return -1;
2189                 }
2190                 *pi = getintvalue(v);
2191                 if (*pi < 0)
2192                         *pi += isize;
2193         }
2194         return 0;
2195 }
2196
2197 static object *
2198 apply_slice(u, v, w) /* return u[v:w] */
2199         object *u, *v, *w;
2200 {
2201         typeobject *tp = u->ob_type;
2202         int ilow, ihigh, isize;
2203         if (tp->tp_as_sequence == NULL) {
2204                 err_setstr(TypeError, "only sequences can be sliced");
2205                 return NULL;
2206         }
2207         ilow = 0;
2208         isize = ihigh = (*tp->tp_as_sequence->sq_length)(u);
2209         if (isize < 0)
2210                 return NULL;
2211         if (slice_index(v, isize, &ilow) != 0)
2212                 return NULL;
2213         if (slice_index(w, isize, &ihigh) != 0)
2214                 return NULL;
2215         return (*tp->tp_as_sequence->sq_slice)(u, ilow, ihigh);
2216 }
2217
2218 static int
2219 assign_subscript(w, key, v) /* w[key] = v */
2220         object *w;
2221         object *key;
2222         object *v;
2223 {
2224         typeobject *tp = w->ob_type;
2225         sequence_methods *sq;
2226         mapping_methods *mp;
2227         int (*func)();
2228         if ((mp = tp->tp_as_mapping) != NULL &&
2229                         (func = mp->mp_ass_subscript) != NULL) {
2230                 return (*func)(w, key, v);
2231         }
2232         else if ((sq = tp->tp_as_sequence) != NULL &&
2233                         (func = sq->sq_ass_item) != NULL) {
2234                 if (!is_intobject(key)) {
2235                         err_setstr(TypeError,
2236                         "sequence subscript must be integer (assign or del)");
2237                         return -1;
2238                 }
2239                 else {
2240                         int i = getintvalue(key);
2241                         if (i < 0) {
2242                                 int len = (*sq->sq_length)(w);
2243                                 if (len < 0)
2244                                         return -1;
2245                                 i += len;
2246                         }
2247                         return (*func)(w, i, v);
2248                 }
2249         }
2250         else {
2251                 err_setstr(TypeError,
2252                                 "can't assign to this subscripted object");
2253                 return -1;
2254         }
2255 }
2256
2257 static int
2258 assign_slice(u, v, w, x) /* u[v:w] = x */
2259         object *u, *v, *w, *x;
2260 {
2261         sequence_methods *sq = u->ob_type->tp_as_sequence;
2262         int ilow, ihigh, isize;
2263         if (sq == NULL) {
2264                 err_setstr(TypeError, "assign to slice of non-sequence");
2265                 return -1;
2266         }
2267         if (sq == NULL || sq->sq_ass_slice == NULL) {
2268                 err_setstr(TypeError, "unassignable slice");
2269                 return -1;
2270         }
2271         ilow = 0;
2272         isize = ihigh = (*sq->sq_length)(u);
2273         if (isize < 0)
2274                 return -1;
2275         if (slice_index(v, isize, &ilow) != 0)
2276                 return -1;
2277         if (slice_index(w, isize, &ihigh) != 0)
2278                 return -1;
2279         return (*sq->sq_ass_slice)(u, ilow, ihigh, x);
2280 }
2281
2282 static int
2283 cmp_exception(err, v)
2284         object *err, *v;
2285 {
2286         if (is_tupleobject(v)) {
2287                 int i, n;
2288                 n = gettuplesize(v);
2289                 for (i = 0; i < n; i++) {
2290                         /* Test recursively */
2291                         if (cmp_exception(err, gettupleitem(v, i)))
2292                                 return 1;
2293                 }
2294                 return 0;
2295         }
2296         return err == v;
2297 }
2298
2299 static int
2300 cmp_member(v, w)
2301         object *v, *w;
2302 {
2303         int i, n, cmp;
2304         object *x;
2305         sequence_methods *sq;
2306         /* Special case for char in string */
2307         if (is_stringobject(w)) {
2308                 register char *s, *end;
2309                 register char c;
2310                 if (!is_stringobject(v) || getstringsize(v) != 1) {
2311                         err_setstr(TypeError,
2312                             "string member test needs char left operand");
2313                         return -1;
2314                 }
2315                 c = getstringvalue(v)[0];
2316                 s = getstringvalue(w);
2317                 end = s + getstringsize(w);
2318                 while (s < end) {
2319                         if (c == *s++)
2320                                 return 1;
2321                 }
2322                 return 0;
2323         }
2324         sq = w->ob_type->tp_as_sequence;
2325         if (sq == NULL) {
2326                 err_setstr(TypeError,
2327                         "'in' or 'not in' needs sequence right argument");
2328                 return -1;
2329         }
2330         n = (*sq->sq_length)(w);
2331         if (n < 0)
2332                 return -1;
2333         for (i = 0; i < n; i++) {
2334                 x = (*sq->sq_item)(w, i);
2335                 cmp = cmpobject(v, x);
2336                 XDECREF(x);
2337                 if (cmp == 0)
2338                         return 1;
2339         }
2340         return 0;
2341 }
2342
2343 static object *
2344 cmp_outcome(op, v, w)
2345         int op;
2346         register object *v;
2347         register object *w;
2348 {
2349         register int cmp;
2350         register int res = 0;
2351         switch (op) {
2352         case IS:
2353         case IS_NOT:
2354                 res = (v == w);
2355                 if (op == (int) IS_NOT)
2356                         res = !res;
2357                 break;
2358         case IN:
2359         case NOT_IN:
2360                 res = cmp_member(v, w);
2361                 if (res < 0)
2362                         return NULL;
2363                 if (op == (int) NOT_IN)
2364                         res = !res;
2365                 break;
2366         case EXC_MATCH:
2367                 res = cmp_exception(v, w);
2368                 break;
2369         default:
2370                 cmp = cmpobject(v, w);
2371                 switch (op) {
2372                 case LT: res = cmp <  0; break;
2373                 case LE: res = cmp <= 0; break;
2374                 case EQ: res = cmp == 0; break;
2375                 case NE: res = cmp != 0; break;
2376                 case GT: res = cmp >  0; break;
2377                 case GE: res = cmp >= 0; break;
2378                 /* XXX no default? (res is initialized to 0 though) */
2379                 }
2380         }
2381         v = res ? True : False;
2382         INCREF(v);
2383         return v;
2384 }
2385
2386 static int
2387 import_from(locals, v, name)
2388         object *locals;
2389         object *v;
2390         object *name;
2391 {
2392         object *w, *x;
2393         w = getmoduledict(v);
2394         if (getstringvalue(name)[0] == '*') {
2395                 int pos, err;
2396                 object *name, *value;
2397                 pos = 0;
2398                 while (mappinggetnext(w, &pos, &name, &value)) {
2399                         if (!is_stringobject(name) ||
2400                             getstringvalue(name)[0] == '_')
2401                                 continue;
2402                         if (is_accessobject(value)) {
2403                                 value = getaccessvalue(value, (object *)NULL);
2404                                 if (value == NULL) {
2405                                         err_clear();
2406                                         continue;
2407                                 }
2408                         }
2409                         else
2410                                 INCREF(value);
2411                         err = dict2insert(locals, name, value);
2412                         DECREF(value);
2413                         if (err != 0)
2414                                 return -1;
2415                 }
2416                 return 0;
2417         }
2418         else {
2419                 x = dict2lookup(w, name);
2420                 if (x == NULL) {
2421                         char buf[250];
2422                         sprintf(buf, "cannot import name %.230s",
2423                                 getstringvalue(name));
2424                         err_setstr(ImportError, buf);
2425                         return -1;
2426                 }
2427                 else
2428                         return dict2insert(locals, name, x);
2429         }
2430 }
2431
2432 static object *
2433 build_class(methods, bases, name)
2434         object *methods; /* dictionary */
2435         object *bases;  /* tuple containing classes */
2436         object *name;   /* string */
2437 {
2438         int i;
2439         if (!is_tupleobject(bases)) {
2440                 err_setstr(SystemError, "build_class with non-tuple bases");
2441                 return NULL;
2442         }
2443         if (!is_dictobject(methods)) {
2444                 err_setstr(SystemError, "build_class with non-dictionary");
2445                 return NULL;
2446         }
2447         if (!is_stringobject(name)) {
2448                 err_setstr(SystemError, "build_class witn non-string name");
2449                 return NULL;
2450         }
2451         for (i = gettuplesize(bases); --i >= 0; ) {
2452                 object *base = gettupleitem(bases, i);
2453                 if (!is_classobject(base)) {
2454                         err_setstr(TypeError,
2455                                 "base is not a class object");
2456                         return NULL;
2457                 }
2458         }
2459         return newclassobject(bases, methods, name);
2460 }
2461
2462 static int
2463 access_statement(name, vmode, f)
2464         object *name;
2465         object *vmode;
2466         frameobject *f;
2467 {
2468         int mode = getintvalue(vmode);
2469         object *value, *ac;
2470         typeobject *type;
2471         int fastind, ret;
2472         fastind = -1;
2473         if (f->f_localmap == NULL)
2474                 value = dict2lookup(f->f_locals, name);
2475         else {
2476                 value = dict2lookup(f->f_localmap, name);
2477                 if (value == NULL || !is_intobject(value))
2478                         value = NULL;
2479                 else {
2480                         fastind = getintvalue(value);
2481                         if (0 <= fastind &&
2482                             fastind < getlistsize(f->f_fastlocals))
2483                                 value = getlistitem(f->f_fastlocals, fastind);
2484                         else {
2485                                 value = NULL;
2486                                 fastind = -1;
2487                         }
2488                 }
2489         }
2490         if (value && is_accessobject(value)) {
2491                 err_setstr(AccessError, "can't override access");
2492                 return -1;
2493         }
2494         err_clear();
2495         if (value != NULL && value != None)
2496                 type = value->ob_type;
2497         else
2498                 type = NULL;
2499         ac = newaccessobject(value, f->f_locals, type, mode);
2500         if (ac == NULL)
2501                 return -1;
2502         if (fastind >= 0)
2503                 ret = setlistitem(f->f_fastlocals, fastind, ac);
2504         else {
2505                 ret = dict2insert(f->f_locals, name, ac);
2506                 DECREF(ac);
2507         }
2508         return ret;
2509 }
2510
2511 static int
2512 exec_statement(prog, globals, locals)
2513         object *prog;
2514         object *globals;
2515         object *locals;
2516 {
2517         char *s;
2518         int n;
2519
2520         if (is_tupleobject(prog) && globals == None && locals == None &&
2521             ((n = gettuplesize(prog)) == 2 || n == 3)) {
2522                 /* Backward compatibility hack */
2523                 globals = gettupleitem(prog, 1);
2524                 if (n == 3)
2525                         locals = gettupleitem(prog, 2);
2526                 prog = gettupleitem(prog, 0);
2527         }
2528         if (globals == None) {
2529                 globals = getglobals();
2530                 if (locals == None)
2531                         locals = getlocals();
2532         }
2533         else if (locals == None)
2534                 locals = globals;
2535         if (!is_stringobject(prog) &&
2536             !is_codeobject(prog) &&
2537             !is_fileobject(prog)) {
2538                 err_setstr(TypeError,
2539                            "exec 1st arg must be string, code or file object");
2540                 return -1;
2541         }
2542         if (!is_dictobject(globals) || !is_dictobject(locals)) {
2543                 err_setstr(TypeError,
2544                     "exec 2nd/3rd args must be dict or None");
2545                 return -1;
2546         }
2547         if (is_codeobject(prog)) {
2548                 if (eval_code((codeobject *) prog, globals, locals,
2549                                  (object *)NULL, (object *)NULL) == NULL)
2550                         return -1;
2551                 return 0;
2552         }
2553         if (is_fileobject(prog)) {
2554                 FILE *fp = getfilefile(prog);
2555                 char *name = getstringvalue(getfilename(prog));
2556                 if (run_file(fp, name, file_input, globals, locals) == NULL)
2557                         return -1;
2558                 return 0;
2559         }
2560         s = getstringvalue(prog);
2561         if (strlen(s) != getstringsize(prog)) {
2562                 err_setstr(ValueError, "embedded '\\0' in exec string");
2563                 return -1;
2564         }
2565         if (run_string(s, file_input, globals, locals) == NULL)
2566                 return -1;
2567         return 0;
2568 }