如何在 Python 中實現 goto 語句

Python 默認是沒有 goto 語句的，可是有一個第三方庫支持在 Python 裏面實現相似於
goto 的功能：https://github.com/snoack/pyt...。

好比在下面這個例子裏，

from goto import with_goto

@with_goto
def func():
    for i in range(2):
        for j in range(2):
            goto .end
    label .end
    return (i, j, k)

func() 在執行第一遍循環時，就會從最內層的 for j in range(2) 跳到函數的
return 語句前面。

按理說本文到此就該完了，可是這個庫有一個限制，若是嵌套的循環層次太深，就沒法工做
。好比下面這幾行代碼：

@with_goto
def func():
    for i in range(2):
        for j in range(2):
            for k in range(2):
                for m in range(2):
                    for n in range(2):
                        goto .end
    label .end
    return (i, j, k, m, n)

會讓它拋出 SyntaxError。

本文接下來的內容，就是如何打破這個限制。

python-goto 是如何工做的

python-goto 這個庫，經過 decorator 的方式修改了傳進來的函數 func 的
__code__ 屬性，把插入的字節碼暗樁替換成相關的 JMP 語句。具體的瑣碎實現細節，
能夠參考該項目下 goto.py 這個文件，一共也就不到兩百行。

本文開頭的例子中，func 函數的字節碼能夠用

import dis
dis.dis(func)

打印出來。

下面貼出不帶 @with_goto 時的輸出（# 號後面的內容是我加的）：實際上

# for i in range(2):
# 7 是源代碼行號（跟示例不太對得上，不要太在乎細節XD）
# 0/2/4 這些是 offset，在這裏每條字節碼長度都是 2。
# >> 表示會跳到這裏。
  7           0 SETUP_LOOP              40 (to 42)
              2 LOAD_GLOBAL              0 (range)
              4 LOAD_CONST               1 (2)
              6 CALL_FUNCTION            1
              8 GET_ITER
        >>   10 FOR_ITER                28 (to 40)
             12 STORE_FAST               0 (i)

# for j in range(2):
  8          14 SETUP_LOOP              22 (to 38)
             16 LOAD_GLOBAL              0 (range)
             18 LOAD_CONST               1 (2)
             20 CALL_FUNCTION            1
             22 GET_ITER
        >>   24 FOR_ITER                10 (to 36)
             26 STORE_FAST               1 (j)

# goto .end
  9          28 LOAD_GLOBAL              1 (goto)
             30 LOAD_ATTR                2 (end)
             32 POP_TOP
# 結束循環 j
             34 JUMP_ABSOLUTE           24
        >>   36 POP_BLOCK
# 結束循環 i
        >>   38 JUMP_ABSOLUTE           10
        >>   40 POP_BLOCK

# label .end
 10     >>   42 LOAD_GLOBAL              3 (label)
             44 LOAD_ATTR                2 (end)
             46 POP_TOP

# return (i, j, k)
 11          48 LOAD_FAST                0 (i)
             50 LOAD_FAST                1 (j)
             52 LOAD_GLOBAL              4 (k)
             54 BUILD_TUPLE              3

跟帶 @with_goto 時的輸出比較，只有這兩點差異：

# goto .end
-  9          28 LOAD_GLOBAL              1 (goto)
-             30 LOAD_ATTR                2 (end)
-             32 POP_TOP
+  9          28 POP_BLOCK
+             30 POP_BLOCK
+             32 JUMP_FORWARD            14 (to 48)

# label .end
- 10     >>   42 LOAD_GLOBAL              3 (label)
-             44 LOAD_ATTR                2 (end)
-             46 POP_TOP
+ 10     >>   42 NOP
+             44 NOP
+             46 NOP

- 11          48 LOAD_FAST                0 (i)
+ 11     >>   48 LOAD_FAST                0 (i)

在沒有引入 @with_goto 時，goto .end 在 Python 解釋器的眼裏，其實就是
goto.end，即訪問某個叫 goto 的全局域裏的對象的 end 屬性。該語句會被編譯成
三條語句：LOAD_GLOBAL、LOAD_ATTR、POP_TOP。這就是插入在字節碼裏的暗樁。

在引入 @with_goto 以後，這三條語句會被替換成一條 JMP 語句外加若干條輔助的語句
。這樣在執行到這些字節碼時，就會跳到指定的地方了，好比在上面例子中跳到 offset 48
，也即原來 label .end 的下一條字節碼。

（關於 Python 字節碼的官方文檔並不顯眼，藏在 dis 這個模塊下。
注意它不是按字母表順序介紹每一個字節碼的，因此要想查特定的字節碼，須要 Ctrl+F 一下。）

JMP 語句只須要一條，若是要向前跳，就用 JUMP_FORWARD；向後跳，就用
JUMP_ABSOLUTE。可是輔助的語句可能不止一條，好比要想從一個 for loop 或者 try
block 跳出來，須要加 POP_BLOCK 語句。有多少層循環就須要加多少條 POP_BLOCK，好比前面
的示例裏是兩層循環，就是兩條 POP_BLOCK。

另外，因爲 Python 字節碼的長度固定爲兩個 byte，一個 byte 用於表示字節碼的類型，
另外一個用於表示參數。若是要想放下超過字節碼預留的空位的參數，須要用 EXTENDED_ARG
語句。好比

EXTENDED_ARG             7
EXTENDED_ARG          2046
OP                       x

那麼語句 OP 的參數就是 7 << 16 + 2046 << 8 + x。

對於 JUMP_FORWARD，它的參數是 offset。因此當目標地址離當前位置的 offset 超過
256 時，須要額外生成 EXTENDED_ARG。JUMP_ABSOLUTE 也是一樣的道理，只是該語句
的參數是絕對地址。

因此對於深層嵌套內、須要跳到很遠的 goto 語句，就要加很多輔助語句。而
python-goto 這個庫，在替換暗樁時，並不會額外增長語句。若是所需的語句超過暗樁的
大小，會拋出 SyntaxError。

在 Python 3.6 以前，不帶參數的語句只須要 1 個字節，一樣 6 個字節的地方，能夠
容納 1 條必需的 JMP 語句和 4 條 POP_BLOCK。除非你是在一個五層循環裏用 goto，
不太會碰到這個限制。可是 Python 3.6 以後，POP_BLOCK 也要用 2 個字節了，頓時連
三層循環都 hold 不住了，這個問題就顯得尖銳起來。上面還沒考慮到須要加
EXTENDED_ARG 的狀況。

如何繞過字節碼大小的限制

那麼一個顯而易見的解決方案就浮出水面了：爲什麼不試試在修改字節碼的時候，動態改變字
節碼的大小，讓它有足夠的位置容納新增的輔助語句？這樣一來，就能完全地解決問題了。

這個就是開頭說到的，打破限制的方法。

Python 自己是容許動態增大/縮小 __code__ 屬性裏的字節碼的。可是有個問題，Python
裏許多字節碼依賴特定的位置或者偏移。若是咱們挪動了涉及的字節碼，須要同步修改這些
語句的參數。（包括咱們新生成的 goto 語句裏面的 JUMP_ABSOLUTE 和 JUMP_FORWARD）

這個聽起來簡單，彷佛只要把參數 patch 成實際修改後的值就行了。然而 Python 是
經過在字節碼前面插入 EXTENDED_ARG 來實現定長字節碼裏支持不定長參數的功能。修改
參數的值可能須要動態調整 EXTENDED_ARG 語句的數量；而調整 EXTENDED_ARG 又反過
來影響到各個語句的參數…… 因此這裏須要一個 while True 循環，直到某一次調整不會
觸發 EXTENDED_ARG 語句的變化爲止。

好在若是咱們只單方面增大字節碼，就只須要增長 EXTENDED_ARG 語句。而每在一個地方
增長完 EXTENDED_ARG 語句，就意味着對應的 OP 語句參數能縮小 256。後面不管怎麼
調整，都不太可能須要再增長多一個 EXTENDED_ARG 語句。這麼一來，調整的次數就不會
多。

雖說起來好像就那麼兩三段話的事，可是開發難度會很大。由於須要 patch 的字節碼類型不少，大約十來種吧。並且邏輯上較爲複雜，牽連的地方不少。實際上我沒有實現前述的方案，只是設計了下而已。若是你要實現它，請在編碼時保持心裏的平靜，另外多寫測試用例，否則很容易出問題。