python - 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% 确定我是否正确实现了延续逻辑，但这现在并不重要。

我的想法是将调用 callcc 的函数及其调用者的堆栈和指令指针保存在 Continuation 构造函数中，然后保存在 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 堆栈帧的 View (.f_back 是一个只读属性，这是有充分理由的)，没有必要更改 f_back 指针。

如果你真的想操作堆栈，你必须编写一个 C 模块，例如 greenlet模块确实如此。

祝你好运!