Python 默認(rèn)是沒有 goto 語句的，但是有一個(gè)第三方庫支持在 Python 里面實(shí)現(xiàn)類似于
goto 的功能：https://github.com/snoack/pyt...。

比如在下面這個(gè)例子里，

          
            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() 在執(zhí)行第一遍循環(huán)時(shí)，就會(huì)從最內(nèi)層的 for j in range(2) 跳到函數(shù)的
return 語句前面。

按理說本文到此就該完了，但是這個(gè)庫有一個(gè)限制，如果嵌套的循環(huán)層次太深，就無法工作
。比如下面這幾行代碼：

          
            @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)
          
        

會(huì)讓它拋出 SyntaxError 。

本文接下來的內(nèi)容，就是如何打破這個(gè)限制。

python-goto 是如何工作的

python-goto 這個(gè)庫，通過 decorator 的方式修改了傳進(jìn)來的函數(shù) func 的
__code__ 屬性，把插入的字節(jié)碼暗樁替換成相關(guān)的 JMP 語句。具體的瑣碎實(shí)現(xiàn)細(xì)節(jié)，
可以參考該項(xiàng)目下 goto.py 這個(gè)文件，一共也就不到兩百行。

本文開頭的例子中， func 函數(shù)的字節(jié)碼可以用

          
            import dis
dis.dis(func)
          
        

打印出來。

下面貼出不帶 @with_goto 時(shí)的輸出（# 號(hào)后面的內(nèi)容是我加的）：實(shí)際上

          
            # for i in range(2):
# 7 是源代碼行號(hào)（跟示例不太對(duì)得上，不要太在意細(xì)節(jié)XD）
# 0/2/4 這些是 offset，在這里每條字節(jié)碼長(zhǎng)度都是 2。
# >> 表示會(huì)跳到這里。
  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
# 結(jié)束循環(huán) j
             34 JUMP_ABSOLUTE           24
        >>   36 POP_BLOCK
# 結(jié)束循環(huán) 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 時(shí)的輸出比較，只有這兩點(diǎn)差別：

          
            # 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 時(shí)， goto .end 在 Python 解釋器的眼里，其實(shí)就是
goto.end ，即訪問某個(gè)叫 goto 的全局域里的對(duì)象的 end 屬性。該語句會(huì)被編譯成
三條語句： LOAD_GLOBAL 、 LOAD_ATTR 、 POP_TOP 。這就是插入在字節(jié)碼里的暗樁。

在引入 @with_goto 之后，這三條語句會(huì)被替換成一條 JMP 語句外加若干條輔助的語句
。這樣在執(zhí)行到這些字節(jié)碼時(shí)，就會(huì)跳到指定的地方了，比如在上面例子中跳到 offset 48
，也即原來 label .end 的下一條字節(jié)碼。

（關(guān)于 Python 字節(jié)碼的官方文檔并不顯眼，藏在 dis 這個(gè)模塊下。
注意它不是按字母表順序介紹每個(gè)字節(jié)碼的，所以要想查特定的字節(jié)碼，需要 Ctrl+F 一下。）

JMP 語句只需要一條，如果要向前跳，就用 JUMP_FORWARD ；向后跳，就用
JUMP_ABSOLUTE 。但是輔助的語句可能不止一條，比如要想從一個(gè) for loop 或者 try
block 跳出來，需要加 POP_BLOCK 語句。有多少層循環(huán)就需要加多少條 POP_BLOCK ，比如前面
的示例里是兩層循環(huán)，就是兩條 POP_BLOCK 。

另外，由于 Python 字節(jié)碼的長(zhǎng)度固定為兩個(gè) byte，一個(gè) byte 用于表示字節(jié)碼的類型，
另一個(gè)用于表示參數(shù)。如果要想放下超過字節(jié)碼預(yù)留的空位的參數(shù)，需要用 EXTENDED_ARG
語句。比如

          
            EXTENDED_ARG             7
EXTENDED_ARG          2046
OP                       x
          
        

那么語句 OP 的參數(shù)就是 7 << 16 + 2046 << 8 + x。

對(duì)于 JUMP_FORWARD ，它的參數(shù)是 offset。所以當(dāng)目標(biāo)地址離當(dāng)前位置的 offset 超過
256 時(shí)，需要額外生成 EXTENDED_ARG 。 JUMP_ABSOLUTE 也是同樣的道理，只是該語句
的參數(shù)是絕對(duì)地址。

所以對(duì)于深層嵌套內(nèi)、需要跳到很遠(yuǎn)的 goto 語句，就要加不少輔助語句。而
python-goto 這個(gè)庫，在替換暗樁時(shí)，并不會(huì)額外增加語句。如果所需的語句超過暗樁的
大小，會(huì)拋出 SyntaxError。

在 Python 3.6 之前，不帶參數(shù)的語句只需要 1 個(gè)字節(jié)，同樣 6 個(gè)字節(jié)的地方，可以
容納 1 條必需的 JMP 語句和 4 條 POP_BLOCK 。除非你是在一個(gè)五層循環(huán)里用 goto ，
不太會(huì)碰到這個(gè)限制。但是 Python 3.6 之后， POP_BLOCK 也要用 2 個(gè)字節(jié)了，頓時(shí)連
三層循環(huán)都 hold 不住了，這個(gè)問題就顯得尖銳起來。上面還沒考慮到需要加
EXTENDED_ARG 的情況。

如何繞過字節(jié)碼大小的限制

那么一個(gè)顯而易見的解決方案就浮出水面了：為何不試試在修改字節(jié)碼的時(shí)候，動(dòng)態(tài)改變字
節(jié)碼的大小，讓它有足夠的位置容納新增的輔助語句？這樣一來，就能徹底地解決問題了。

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

Python 本身是允許動(dòng)態(tài)增大/縮小 __code__ 屬性里的字節(jié)碼的。但是有個(gè)問題，Python
里許多字節(jié)碼依賴特定的位置或者偏移。如果我們挪動(dòng)了涉及的字節(jié)碼，需要同步修改這些
語句的參數(shù)。（包括我們新生成的 goto 語句里面的 JUMP_ABSOLUTE 和 JUMP_FORWARD ）

這個(gè)聽起來簡(jiǎn)單，似乎只要把參數(shù) patch 成實(shí)際修改后的值就好了。然而 Python 是
通過在字節(jié)碼前面插入 EXTENDED_ARG 來實(shí)現(xiàn)定長(zhǎng)字節(jié)碼里支持不定長(zhǎng)參數(shù)的功能。修改
參數(shù)的值可能需要?jiǎng)討B(tài)調(diào)整 EXTENDED_ARG 語句的數(shù)量；而調(diào)整 EXTENDED_ARG 又反過
來影響到各個(gè)語句的參數(shù)…… 所以這里需要一個(gè) while True 循環(huán)，直到某一次調(diào)整不會(huì)
觸發(fā) EXTENDED_ARG 語句的變化為止。

好在如果我們只單方面增大字節(jié)碼，就只需要增加 EXTENDED_ARG 語句。而每在一個(gè)地方
增加完 EXTENDED_ARG 語句，就意味著對(duì)應(yīng)的 OP 語句參數(shù)能縮小 256。后面無論怎么
調(diào)整，都不太可能需要再增加多一個(gè) EXTENDED_ARG 語句。這么一來，調(diào)整的次數(shù)就不會(huì)
多。

雖然說起來好像就那么兩三段話的事，但是開發(fā)難度會(huì)很大。因?yàn)樾枰?patch 的字節(jié)碼類型很多，
大約十來種吧。而且邏輯上較為復(fù)雜，牽連的地方很多。實(shí)際上我沒有實(shí)現(xiàn)前述的方案，只是設(shè)計(jì)了
下而已。如果你要實(shí)現(xiàn)它，請(qǐng)?jiān)诰幋a時(shí)保持內(nèi)心的平靜，另外多寫測(cè)試用例，不然很容易出問題。