merge 3.3-slp (Stackless python#109)

Author: Anselm Kruis

Python/ceval.c

@@ -1213,8 +1213,8 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
 
 #ifdef STACKLESS
 
-    f->f_execute = PyEval_EvalFrame_noval;
-    return PyEval_EvalFrame_value(f, throwflag, retval);
+    f->f_execute = slp_eval_frame_noval;
+    return slp_eval_frame_value(f, throwflag, retval);
 exit_eval_frame:
     Py_LeaveRecursiveCall();
     f->f_executing = 0;
@@ -1223,30 +1223,38 @@ PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
 }
 
 PyObject *
-PyEval_EvalFrame_noval(PyFrameObject *f, int throwflag, PyObject *retval)
+slp_eval_frame_noval(PyFrameObject *f, int throwflag, PyObject *retval)
 {
+    PyObject *r;
     /*
      * this function is identical to PyEval_EvalFrame_value.
      * it serves as a marker whether we expect a value or
      * not, and it makes debugging a little easier.
      */
-    return PyEval_EvalFrame_value(f, throwflag, retval);
+    Py_XINCREF(f); /* fool the link optimizer */
+    r = slp_eval_frame_value(f, throwflag, retval);
+    Py_XDECREF(f);
+    return r;
 }
 
 PyObject *
-PyEval_EvalFrame_iter(PyFrameObject *f, int throwflag, PyObject *retval)
+slp_eval_frame_iter(PyFrameObject *f, int throwflag, PyObject *retval)
 {
+    PyObject *r;
     /*
      * this function is identical to PyEval_EvalFrame_value.
      * it serves as a marker whether we are inside of a
      * for_iter operation. In this case we need to handle
      * null without error as valid result.
      */
-    return PyEval_EvalFrame_value(f, throwflag, retval);
+    Py_XINCREF(retval); /* fool the link optimizer */
+    r = slp_eval_frame_value(f, throwflag, retval);
+    Py_XDECREF(retval);
+    return r;
 }
 
 PyObject *
-PyEval_EvalFrame_setup_with(PyFrameObject *f, int throwflag, PyObject *retval)
+slp_eval_frame_setup_with(PyFrameObject *f, int throwflag, PyObject *retval)
 {
     PyObject *r;
     /*
@@ -1257,14 +1265,14 @@ PyEval_EvalFrame_setup_with(PyFrameObject *f, int throwflag, PyObject *retval)
      */
     Py_XINCREF(f);	    /* fool the link optimizer */
     Py_XINCREF(retval); /* fool the link optimizer */
-    r = PyEval_EvalFrame_value(f, throwflag, retval);
+    r = slp_eval_frame_value(f, throwflag, retval);
     Py_XDECREF(retval);
     Py_XDECREF(f);
     return r;
 }
 
 PyObject *
-PyEval_EvalFrame_with_cleanup(PyFrameObject *f, int throwflag, PyObject *retval)
+slp_eval_frame_with_cleanup(PyFrameObject *f, int throwflag, PyObject *retval)
 {
     PyObject *r;
     /*
@@ -1275,14 +1283,14 @@ PyEval_EvalFrame_with_cleanup(PyFrameObject *f, int throwflag, PyObject *retval)
      */
     Py_XINCREF(f);      /* fool the link optimizer */
     Py_XINCREF(f);	    /* fool the link optimizer */
-    r = PyEval_EvalFrame_value(f, throwflag, retval);
+    r = slp_eval_frame_value(f, throwflag, retval);
     Py_XDECREF(f);
     Py_XDECREF(f);
     return r;
 }
 
 PyObject *
-PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
+slp_eval_frame_value(PyFrameObject *f, int throwflag, PyObject *retval)
 {
     /* unfortunately we repeat all the variables here... */
 #ifdef DXPAIRS
@@ -1679,7 +1687,7 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
            the generator and on the return from each yield.  In Stackless, we
            reenter frames for other purposes (calls, iteration, ..) and need
            to avoid incorrect reexecution and exc reference leaking. */
-        if (f->f_execute == PyEval_EvalFrame_noval) {
+        if (f->f_execute == slp_eval_frame_noval) {
 #endif
         if (!throwflag && f->f_exc_type != NULL && f->f_exc_type != Py_None) {
             /* We were in an except handler when we left,
@@ -1705,12 +1713,12 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
 
 
 #ifdef STACKLESS
-    if (f->f_execute == PyEval_EvalFrame_value) {
+    if (f->f_execute == slp_eval_frame_value) {
         /* this is a return */
         PUSH(retval); /* we are back from a function call */
     }
     else {
-        if (f->f_execute == PyEval_EvalFrame_iter) {
+        if (f->f_execute == slp_eval_frame_iter) {
             /* finalise the for_iter operation */
             opcode = NEXTOP();
             oparg = NEXTARG();
@@ -1743,7 +1751,7 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
                 JUMPBY(oparg);
             }
         }
-        else if (f->f_execute == PyEval_EvalFrame_setup_with) {
+        else if (f->f_execute == slp_eval_frame_setup_with) {
             /* finalise the SETUP_WITH operation */
             opcode = NEXTOP();
             oparg = NEXTARG();
@@ -1762,7 +1770,7 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
                 PUSH(retval);
             }
         }
-        else if (f->f_execute == PyEval_EvalFrame_with_cleanup) {
+        else if (f->f_execute == slp_eval_frame_with_cleanup) {
             /* finalise the WITH_CLEANUP operation */
 
             if (retval) {
@@ -1801,10 +1809,10 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
         }
         else {
             /* don't push it, frame ignores value */
-            assert (f->f_execute == PyEval_EvalFrame_noval);
+            assert (f->f_execute == slp_eval_frame_noval);
             Py_XDECREF(retval);
         }
-        f->f_execute = PyEval_EvalFrame_value;
+        f->f_execute = slp_eval_frame_value;
 
     }
 
@@ -3912,16 +3920,16 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
     return retval;
 
 stackless_setup_with:
-    f->f_execute = PyEval_EvalFrame_setup_with;
+    f->f_execute = slp_eval_frame_setup_with;
     goto stackless_call_with_opcode;
 
 stackless_with_cleanup:
-    f->f_execute = PyEval_EvalFrame_with_cleanup;
+    f->f_execute = slp_eval_frame_with_cleanup;
     goto stackless_call;
 
 stackless_iter:
     /* restore this opcode and enable frame to handle it */
-    f->f_execute = PyEval_EvalFrame_iter;
+    f->f_execute = slp_eval_frame_iter;
 stackless_call_with_opcode:
     next_instr -= (oparg >> 16) ? 6 : 3;
 
@@ -3939,36 +3947,36 @@ PyEval_EvalFrame_value(PyFrameObject *f, int throwflag, PyObject *retval)
     STACKLESS_UNPACK(retval);
     retval = tstate->frame->f_execute(tstate->frame, 0, retval);
     if (tstate->frame != f) {
-        assert(f->f_execute == PyEval_EvalFrame_value || f->f_execute == PyEval_EvalFrame_noval ||
-            f->f_execute == PyEval_EvalFrame_setup_with || f->f_execute == PyEval_EvalFrame_with_cleanup);
-        if (f->f_execute == PyEval_EvalFrame_noval)
-            f->f_execute = PyEval_EvalFrame_value;
+        assert(f->f_execute == slp_eval_frame_value || f->f_execute == slp_eval_frame_noval ||
+            f->f_execute == slp_eval_frame_setup_with || f->f_execute == slp_eval_frame_with_cleanup);
+        if (f->f_execute == slp_eval_frame_noval)
+            f->f_execute = slp_eval_frame_value;
         return retval;
     }
     if (STACKLESS_UNWINDING(retval))
         STACKLESS_UNPACK(retval);
 
     f->f_stacktop = NULL;
-    if (f->f_execute == PyEval_EvalFrame_iter) {
+    if (f->f_execute == slp_eval_frame_iter) {
         next_instr += (oparg >> 16) ? 6 : 3;
-        f->f_execute = PyEval_EvalFrame_value;
+        f->f_execute = slp_eval_frame_value;
         goto stackless_iter_return;
     }
-    else if (f->f_execute == PyEval_EvalFrame_setup_with) {
+    else if (f->f_execute == slp_eval_frame_setup_with) {
         next_instr += (oparg >> 16) ? 6 : 3;
-        f->f_execute = PyEval_EvalFrame_value;
+        f->f_execute = slp_eval_frame_value;
         goto stackless_setup_with_return;
     }
-    else if (f->f_execute == PyEval_EvalFrame_with_cleanup) {
-        f->f_execute = PyEval_EvalFrame_value;
+    else if (f->f_execute == slp_eval_frame_with_cleanup) {
+        f->f_execute = slp_eval_frame_value;
         goto stackless_with_cleanup_return;
     }
 
     goto stackless_call_return;
 
 stackless_interrupt_call:
 
-    f->f_execute = PyEval_EvalFrame_noval;
+    f->f_execute = slp_eval_frame_noval;
     f->f_stacktop = stack_pointer;
 
     /* the -1 is to adjust for the f_lasti change.

Stackless/changelog.txt

@@ -9,6 +9,11 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://bitbucket.org/stackless-dev/stackless/issues/109
+  The Stackless python*.dll no longer exports private symbols. Symbols
+  required by Stackless-aware 3rd party extension modules should still be
+  available.
+
 - https://bitbucket.org/stackless-dev/stackless/issues/108
   Use PyVarObject_HEAD_INIT to initialise type objects. See PEP 3123.