Since the fast_yield branch target was introduced, it appears that most

tests of "why" against WHY_YIELD became useless.  This patch removes them,
but assert()s that why != WHY_YIELD everywhere such a test was removed.
The test suite ran fine under a debug build (i.e., the asserts never
triggered).

diff --git a/Python/ceval.c b/Python/ceval.c
index 0595dbeb063148564cdbae305d91cf82771bcade..2adbdaf03cd6f6c0218e50d2250ad9a60c805abe 100644 (file)
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -47,7 +47,7 @@ static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
 static void call_trace_protected(Py_tracefunc, PyObject *,
                                 PyFrameObject *, int);
 static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
-static int maybe_call_line_trace(Py_tracefunc, PyObject *, 
+static int maybe_call_line_trace(Py_tracefunc, PyObject *,
                                  PyFrameObject *, int *, int *, int *);
 
 static PyObject *apply_slice(PyObject *, PyObject *, PyObject *);
@@ -123,7 +123,7 @@ static int pcall[PCALL_NUM];
 PyObject *
 PyEval_GetCallStats(PyObject *self)
 {
-       return Py_BuildValue("iiiiiiiiii", 
+       return Py_BuildValue("iiiiiiiiii",
                             pcall[0], pcall[1], pcall[2], pcall[3],
                             pcall[4], pcall[5], pcall[6], pcall[7],
                             pcall[8], pcall[9]);
@@ -147,7 +147,7 @@ typedef struct {
 
        PyFrameObject *gi_frame;
 
-       /* True if generator is being executed. */ 
+       /* True if generator is being executed. */
        int gi_running;
 
        /* List of weak reference. */
@@ -593,11 +593,11 @@ eval_frame(PyFrameObject *f)
        PyThreadState *tstate = PyThreadState_GET();
        PyCodeObject *co;
 
-       /* when tracing we set things up so that 
+       /* when tracing we set things up so that
 
                not (instr_lb <= current_bytecode_offset < instr_ub)
 
-          is true when the line being executed has changed.  The 
+          is true when the line being executed has changed.  The
            initial values are such as to make this false the first
            time it is tested. */
        int instr_ub = -1, instr_lb = 0, instr_prev = -1;
@@ -644,8 +644,8 @@ eval_frame(PyFrameObject *f)
        A successful prediction saves a trip through the eval-loop including
        its two unpredictable branches, the HASARG test and the switch-case.
 
-        If collecting opcode statistics, turn off prediction so that 
-       statistics are accurately maintained (the predictions bypass 
+        If collecting opcode statistics, turn off prediction so that
+       statistics are accurately maintained (the predictions bypass
        the opcode frequency counter updates).
 */
 
@@ -841,7 +841,7 @@ eval_frame(PyFrameObject *f)
                        /* see maybe_call_line_trace
                           for expository comments */
                        f->f_stacktop = stack_pointer;
-                       
+
                        err = maybe_call_line_trace(tstate->c_tracefunc,
                                                    tstate->c_traceobj,
                                                    f, &instr_lb, &instr_ub,
@@ -1539,7 +1539,7 @@ eval_frame(PyFrameObject *f)
                                    !isspace(Py_CHARMASK(s[len-1])) ||
                                    s[len-1] == ' ')
                                        PyFile_SoftSpace(w, 1);
-                           } 
+                           }
 #ifdef Py_USING_UNICODE
                            else if (PyUnicode_Check(v)) {
                                Py_UNICODE *s = PyUnicode_AS_UNICODE(v);
@@ -1653,8 +1653,8 @@ eval_frame(PyFrameObject *f)
                        v = POP();
                        if (PyInt_Check(v)) {
                                why = (enum why_code) PyInt_AS_LONG(v);
+                               assert(why != WHY_YIELD);
                                if (why == WHY_RETURN ||
-                                   why == WHY_YIELD ||
                                    why == WHY_CONTINUE)
                                        retval = POP();
                        }
@@ -2325,9 +2325,10 @@ eval_frame(PyFrameObject *f)
                /* Unwind stacks if a (pseudo) exception occurred */
 
 fast_block_end:
-               while (why != WHY_NOT && why != WHY_YIELD && f->f_iblock > 0) {
+               while (why != WHY_NOT && f->f_iblock > 0) {
                        PyTryBlock *b = PyFrame_BlockPop(f);
 
+                       assert(why != WHY_YIELD);
                        if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
                                /* For a continue inside a try block,
                                   don't pop the block for the loop. */
@@ -2397,15 +2398,14 @@ fast_block_end:
 
        } /* main loop */
 
-       if (why != WHY_YIELD) {
-               /* Pop remaining stack entries -- but when yielding */
-               while (!EMPTY()) {
-                       v = POP();
-                       Py_XDECREF(v);
-               }
+       assert(why != WHY_YIELD);
+       /* Pop remaining stack entries. */
+       while (!EMPTY()) {
+               v = POP();
+               Py_XDECREF(v);
        }
 
-       if (why != WHY_RETURN && why != WHY_YIELD)
+       if (why != WHY_RETURN)
                retval = NULL;
 
 fast_yield:
@@ -2461,7 +2461,7 @@ PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
        PyObject *x, *u;
 
        if (globals == NULL) {
-               PyErr_SetString(PyExc_SystemError, 
+               PyErr_SetString(PyExc_SystemError,
                                "PyEval_EvalCodeEx: NULL globals");
                return NULL;
        }
@@ -3083,12 +3083,12 @@ _PyEval_CallTracing(PyObject *func, PyObject *args)
 }
 
 static int
-maybe_call_line_trace(Py_tracefunc func, PyObject *obj, 
+maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
                      PyFrameObject *frame, int *instr_lb, int *instr_ub,
                      int *instr_prev)
 {
        /* The theory of SET_LINENO-less tracing.
-          
+
           In a nutshell, we use the co_lnotab field of the code object
           to tell when execution has moved onto a different line.
 
@@ -3117,17 +3117,17 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
 
           2           0 LOAD_FAST                0 (a)
                       3 JUMP_IF_FALSE            9 (to 15)
-                      6 POP_TOP             
+                      6 POP_TOP
 
           3           7 LOAD_CONST               1 (1)
-                     10 PRINT_ITEM          
-                     11 PRINT_NEWLINE       
+                     10 PRINT_ITEM
+                     11 PRINT_NEWLINE
                      12 JUMP_FORWARD             6 (to 21)
-                >>   15 POP_TOP             
+                >>   15 POP_TOP
 
           5          16 LOAD_CONST               2 (2)
-                     19 PRINT_ITEM          
-                     20 PRINT_NEWLINE       
+                     19 PRINT_ITEM
+                     20 PRINT_NEWLINE
                 >>   21 LOAD_CONST               0 (None)
                      24 RETURN_VALUE
 
@@ -3193,7 +3193,7 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
 
                if (addr == frame->f_lasti) {
                        frame->f_lineno = line;
-                       result = call_trace(func, obj, frame, 
+                       result = call_trace(func, obj, frame,
                                            PyTrace_LINE, Py_None);
                }
 
@@ -3211,7 +3211,7 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
        }
        else if (frame->f_lasti <= *instr_prev) {
                /* jumping back in the same line forces a trace event */
-               result = call_trace(func, obj, frame, 
+               result = call_trace(func, obj, frame,
                                    PyTrace_LINE, Py_None);
        }
        *instr_prev = frame->f_lasti;
@@ -3412,14 +3412,14 @@ static void
 err_args(PyObject *func, int flags, int nargs)
 {
        if (flags & METH_NOARGS)
-               PyErr_Format(PyExc_TypeError, 
+               PyErr_Format(PyExc_TypeError,
                             "%.200s() takes no arguments (%d given)",
-                            ((PyCFunctionObject *)func)->m_ml->ml_name, 
+                            ((PyCFunctionObject *)func)->m_ml->ml_name,
                             nargs);
        else
-               PyErr_Format(PyExc_TypeError, 
+               PyErr_Format(PyExc_TypeError,
                             "%.200s() takes exactly one argument (%d given)",
-                            ((PyCFunctionObject *)func)->m_ml->ml_name, 
+                            ((PyCFunctionObject *)func)->m_ml->ml_name,
                             nargs);
 }
 
@@ -3505,8 +3505,8 @@ call_function(PyObject ***pp_stack, int oparg)
                        BEGIN_C_TRACE
                        x = PyCFunction_Call(func, callargs, NULL);
                        END_C_TRACE
-                       Py_XDECREF(callargs); 
-               } 
+                       Py_XDECREF(callargs);
+               }
        } else {
                if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
                        /* optimize access to bound methods */
@@ -3524,11 +3524,11 @@ call_function(PyObject ***pp_stack, int oparg)
                        Py_INCREF(func);
                if (PyFunction_Check(func))
                        x = fast_function(func, pp_stack, n, na, nk);
-               else 
+               else
                        x = do_call(func, pp_stack, na, nk);
                Py_DECREF(func);
        }
-       
+
        /* What does this do? */
        while ((*pp_stack) > pfunc) {
                w = EXT_POP(*pp_stack);
@@ -3822,7 +3822,7 @@ _PyEval_SliceIndex(PyObject *v, int *pi)
 
                                /* It's an overflow error, so we need to
                                   check the sign of the long integer,
-                                  set the value to INT_MAX or -INT_MAX, 
+                                  set the value to INT_MAX or -INT_MAX,
                                   and clear the error. */
 
                                /* Create a long integer with a value of 0 */
@@ -4114,10 +4114,10 @@ exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
                cf.cf_flags = 0;
                if (PyEval_MergeCompilerFlags(&cf))
                        v = PyRun_FileFlags(fp, name, Py_file_input, globals,
-                                           locals, &cf); 
+                                           locals, &cf);
                else
                        v = PyRun_File(fp, name, Py_file_input, globals,
-                                      locals); 
+                                      locals);
        }
        else {
                PyObject *tmp = NULL;
@@ -4136,7 +4136,7 @@ exec_statement(PyFrameObject *f, PyObject *prog, PyObject *globals,
                if (PyString_AsStringAndSize(prog, &str, NULL))
                        return -1;
                if (PyEval_MergeCompilerFlags(&cf))
-                       v = PyRun_StringFlags(str, Py_file_input, globals, 
+                       v = PyRun_StringFlags(str, Py_file_input, globals,
                                              locals, &cf);
                else
                        v = PyRun_String(str, Py_file_input, globals, locals);