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及其调用者的函数的堆栈和指令指针，然后在继续的__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 .f_back对象只是视图（f_back是一个只读属性，有充分理由）C堆栈帧，没有必要更改{ {1}}指针。

如果你真的想操纵堆栈，你必须编写一个C模块，就像greenlet模块一样。

Goog运气好！

Answer 2

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

在Python中调用/ cc - 可能吗？

2 个答案: