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 的字節碼類型很多，
大約十來種吧。而且邏輯上較為復雜，牽連的地方很多。實際上我沒有實現前述的方案，只是設計了
下而已。如果你要實現它，請在編碼時保持內心的平靜，另外多寫測試用例，不然很容易出問題。