Issue python#109: Don't export internal/private symbols

Previously many internal/private symbols were declared as PyAPI_DATA() or PyAPI_FUNC() and therefore visible in the python*.dll. This commit removes the PyAPI... declarations. Additionally it renames a few symbols to make the naming more consistent.

https://bitbucket.org/stackless-dev/stackless/issues/109
(grafted from 3b6d1f52e108c7377944ee9c452c3d853d8882ab)

Author: Anselm Kruis

Python/ceval.c

@@ -1215,39 +1215,47 @@ 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();
     tstate->frame = f->f_back;
     return NULL;
 }
 
 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;
     /*
@@ -1258,14 +1266,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;
     /*
@@ -1276,14 +1284,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
@@ -1685,7 +1693,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 (f->f_exc_type != NULL && f->f_exc_type != Py_None) {
             /* We were in an except handler when we left,
@@ -1716,12 +1724,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();
@@ -1752,7 +1760,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();
@@ -1771,7 +1779,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) {
@@ -1809,10 +1817,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;
 
     }
 
@@ -3748,16 +3756,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;
 
@@ -3776,37 +3784,37 @@ 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);
 
     x = 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.