Python 中的 call/cc — 可能吗？

Question

说，我们在Scheme中有如下代码

(define cc #f)
(define bar 0)

(define (func)
  (print "This should show only once")
  (call/cc (lambda (k) (set! cc k)))
  (print bar)
  (set! bar (+ bar 1)))

(define (g)
  (func)
  (print "This should show multiple times"))

(g)
(cc)

打印类似的东西

This should show only once
0
This should show multiple times
1
This should show multiple times

假设我们想在 Python 中做同样的事情。 http://wiki.c2.com/?ContinuationsInPython 这种方法不起作用，因为它们只保存代码而不保存堆栈。我尝试在 Python 中实现我的call/cc 版本，保存和恢复堆栈上下文。我不能 100% 确定我是否正确实现了延续逻辑，但这现在并不重要。

我的想法是在Continuation构造函数中保存调用callcc的函数及其调用者的堆栈和指令指针，然后在continuation的__call__方法中，重置保存的堆栈帧中的指令指针，指向当前栈帧f_back指向保存的栈帧并返回的指针神奇地出现在调用callcc的函数中。

问题是，即使traceback.print_stack() 的输出显示当前堆栈已被替换，代码仍然执行，就好像我根本没有触及当前堆栈一样。这是我的实现https://ideone.com/kGchEm

import inspect
import types
import ctypes
import sys
import traceback


frameobject_fields = [
    # PyObject_VAR_HEAD
    ("ob_refcnt", ctypes.c_int64),
    ("ob_type", ctypes.py_object),
    ("ob_size", ctypes.c_ssize_t),
    # struct _frame *f_back;      /* previous frame, or NULL */
    ("f_back", ctypes.c_void_p),
    # PyCodeObject *f_code;       /* code segment */
    ("f_code", ctypes.c_void_p),
    # PyObject *f_builtins;       /* builtin symbol table (PyDictObject) */
    ("f_builtins", ctypes.py_object),
    # PyObject *f_globals;        /* global symbol table (PyDictObject) */
    ("f_globals", ctypes.py_object),
    ####
    ("f_locals", ctypes.py_object),
    ("f_valuestack", ctypes.POINTER(ctypes.py_object)),
    ("f_stacktop", ctypes.POINTER(ctypes.py_object)),
    ("f_trace", ctypes.py_object),
    ("f_exc_type", ctypes.py_object),
    ("f_exc_value", ctypes.py_object),
    ("f_exc_traceback", ctypes.py_object),
    ("f_tstate", ctypes.c_void_p),
    ("f_lasti", ctypes.c_int),
]
if hasattr(sys, "getobjects"):
    # This python was compiled with debugging enabled.
    frameobject_fields = [
        ("_ob_next", ctypes.c_void_p),
        ("_ob_prev", ctypes.c_void_p),
    ] + frameobject_fields
class PyFrameObject(ctypes.Structure):
    _fields_ = frameobject_fields


class Continuation:
    def __init__(self, frame):
        self.frame = frame
        self.lasti = frame.f_lasti
        self.lastis = []

        frame = frame.f_back
        while frame is not None:
            self.lastis.append(frame.f_lasti)
            frame = frame.f_back

    def __call__(self):
        print('\nbefore')
        traceback.print_stack()

        cur_frame = PyFrameObject.from_address(id(inspect.currentframe()))
        PyFrameObject.from_address(cur_frame.f_back).ob_refcnt -= 1
        cur_frame.f_back = id(self.frame)
        PyFrameObject.from_address(id(self.frame)).ob_refcnt += 1

        frame = self.frame
        _frame = PyFrameObject.from_address(id(frame))
        _frame.f_lasti = self.lasti + 4

        frame = frame.f_back
        for lasti in self.lastis:
            if len(frame.f_code.co_code) != frame.f_lasti + 2:
                break
            _frame = PyFrameObject.from_address(id(frame))
            _frame.f_lasti = lasti + 4
            frame = frame.f_back

        print('\nafter')
        traceback.print_stack()


def callcc(f):
    f(Continuation(inspect.currentframe().f_back))


cc = None


def func():
    bar = 0
    print("This should show only once")
    def save_cont(k):
        global cc
        cc = k
    callcc(save_cont)
    print(bar)
    bar += 1


def g():
    func()
    print("This should show multiple times")

sys.stderr = sys.stdout
g()
cc()

Answer 1

问题在于标准解释器——CPython——是一个堆栈式解释器，即每次调用 Python 函数都会导致解释器内部的递归调用。因此 Python FrameType 对象只是 C 堆栈帧的 views（.f_back 是只读属性，这是有充分理由的），没有必要更改 f_back 指针。

如果你真的想操作堆栈，你将不得不编写一个 C 模块，就像 greenlet 模块所做的那样。

祝你好运！

Answer 2

This answer 很好地解释了为什么难以捕获 Python 解释器的状态。 This package 为您服务。它没有实现 call/cc，但它实现了 longjmp 和 setjmp，这只是一些语法糖远离 call/cc。