Lexikální a syntaktická analýza zdrojových kódů jazyka Python (4.část)

Obsah

1. Lexikální a syntaktická analýza zdrojových kódů programovacího jazyka Python (4.část)

2. Překlad modulu do bajtkódu, obsah vygenerovaného binárního souboru

3. Překlad aritmetických výrazů do bajtkódu

4. Zásobníkový efekt (stack effect)

5. Naznačení operací prováděných virtuálním strojem Pythonu zásobníkovým efektem

6. Porovnání s bajtkódem virtuálního stroje jazyka Lua

7. Překlad výrazů s Booleovskými operátory

8. Překlad výrazů s relačními operátory

9. Překlad řídicí struktury typu if-then

10. Překlad řídicí struktury typu if-then-else

11. Jednoduchá programová smyčka typu while

12. Programová smyčka typu while se složitějším tělem

13. Dvě vnořené smyčky typu while – výpis řady prvočísel

14. Jednoduchá programová smyčka typu do-while/repeat-until

15. Příloha A: základní instrukce pro manipulaci se zásobníkem

16. Příloha B: aritmetické a logické operace

17. Příloha C: podmíněné a nepodmíněné skoky, větvení kódu

18. Příloha D: Tabulka všech operačních kódů instrukcí Python VM

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Lexikální a syntaktická analýza zdrojových kódů programovacího jazyka Python (4.část)

Na konci předchozího článku jsme se zmínili o tom, jakým způsobem se překládá kód reprezentovaný v abstraktním syntaktickém stromu (AST) do bajtkódu. Jedná se o poměrně mechanickou operaci, jejímž výsledkem je sekvence instrukcí bajtkódu vytvořená pro každou funkci, resp. metodu. Sekvence těchto instrukcí je buď přímo interpretována (standardní CPython), nebo ji lze přeložit do nativního kódu (AOT, JIT, což bude téma samostatného článku).

Překlad do bajtkódu si můžeme vyzkoušet přímo v REPLu jazyka Python:

import dis
dis.dis("1+2*3")
 
  1           0 LOAD_CONST               0 (7)
              2 RETURN_VALUE

Z předchozího výsledku je patrné, že došlo k optimalizaci výrazu za jeho výsledek – hodnotu 7.

Nyní si vyzkoušejme překlad funkce se dvěma parametry do bajtkódu:

def add(x,y):
...     return x+y
...
dis.dis(add)
 
  2           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_ADD
              6 RETURN_VALUE

V tomto případě nemá Python k dispozici žádné informace o typech, což ostatně platí i pro bajtkód, kde operace BINARY_ADD pouze reprezentuje operátor +, který lze pochopitelně přetížit (a už v samotném Pythonu je několikrát přetížen).

V bajtkódu jsou uloženy i další metainformace o přeložené funkci. Ty lze získat následovně:

>>> print(dis.code_info(add))
 
Name:              add
Filename:          <stdin>
Argument count:    2
Positional-only arguments: 0
Kw-only arguments: 0
Number of locals:  2
Stack size:        2
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: None
Variable names:
   0: x
   1: y

2. Překlad modulu do bajtkódu, obsah vygenerovaného binárního souboru

Díky existenci modulu py_compile je možné zajistit překlad jakéhokoli modulu do bajtkódu. K tomuto účelu slouží následující volání (posledním argumentem je pochopitelně překládaný zdrojový kód):

$ python3 -m py_compile dis_0.py

Po překladu do bajtkódu získáme binární soubor nazvaný dis₀.{python_version}.pyc, jehož obsah si můžeme prohlédnout libovolným hexa prohlížečem. Standardním hexa prohlížečem na Linuxu je nástroj od (nenechte se zmást jeho jménem, které klame – jedná se i o hexa prohlížeč):

$ od -t x1 dis_0.cpython-38.pyc
 
0000000 55 0d 0d 0a 00 00 00 00 ac 9b 00 63 3c 00 00 00
0000020 e3 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0000040 00 02 00 00 00 40 00 00 00 73 0c 00 00 00 64 00
0000060 64 01 84 00 5a 00 64 02 53 00 29 03 63 02 00 00
0000100 00 00 00 00 00 00 00 00 00 03 00 00 00 02 00 00
0000120 00 43 00 00 00 73 0c 00 00 00 7c 00 7c 01 17 00
0000140 7d 02 7c 02 53 00 29 01 4e a9 00 29 03 da 01 78
0000160 da 01 79 da 06 72 65 73 75 6c 74 72 01 00 00 00
0000200 72 01 00 00 00 fa 08 64 69 73 5f 30 2e 70 79 da
0000220 0b 61 64 64 5f 6e 75 6d 62 65 72 73 01 00 00 00
0000240 73 04 00 00 00 00 01 08 01 72 06 00 00 00 4e 29
0000260 01 72 06 00 00 00 72 01 00 00 00 72 01 00 00 00
0000300 72 01 00 00 00 72 05 00 00 00 da 08 3c 6d 6f 64
0000320 75 6c 65 3e 01 00 00 00 f3 00 00 00 00
0000335

Na začátku tohoto binárního souboru se nachází dvojice bajtů, jejichž hodnoty se mění s každou verzí Pythonu. Za těmito dvěma bajty je dvojice 0×0d 0×0a kvůli detekci manipulace se souborem jako s textem (předpokládá se, že se jeden z těchto bajtů buď ztratí nebo naopak zduplikuje). Následuje binárně uložený objekt, který je výsledkem překladu a který kromě tabulky symbolů (viz předchozí článek) obsahuje i sekvenci operačních kódů instrukcí následovaných operačním kódem STOP s hodnotou 0.

3. Překlad aritmetických výrazů do bajtkódu

Nyní se již pojďme věnovat poněkud praktičtějšímu tématu – konkrétně způsobu překladu různých typických programových konstrukcí do bajtkódu virtuálního stroje jazyka Python. V této kapitole si ukážeme, jak se konkrétně překládají základní aritmetické výrazy, a to zejména z toho důvodu, že právě na překladu aritmetických výrazů bude patrný největší rozdíl mezi virtuálními stroji založenými na zásobníku (Python VM) a operacích s operandy uloženými na tomto zásobníku na jedné straně a s virtuálními stroji založenými na sadě registrů na straně druhé (Lua VM).

Budeme analyzovat bajtkód tohoto programu napsaného v Pythonu:

#
# Modul s nekolika jednoduchymi funkcemi
# pro otestovani zakladnich vlastnosti bajtkodu jazyka Python
# prekladu aritmetickych vyrazu.
#
 
def vyraz1(x, y):
    result = x + y
    return result
 
 
def vyraz2(x, y):
    result = x - y
    return result
 
 
def vyraz3(x, y):
    result = x * y
    return result
 
 
def vyraz4(x, y):
    result = x / y
    return result
 
 
def vyraz5(x, y):
    result = x % y
    return result
 
 
def vyraz6(x, y, z):
    result = x + y * z
    return result
 
 
def vyraz7(x, y, z, w):
    result = x + y * z + w
    return result
 
 
def vyraz8(x, y, z, w):
    result = 2 * (x + y) * (z + w) * ((x + z) / (y + w))
    return result
 
 
#
# Vse je nutne otestovat.
#
def main():
    print(vyraz1(4, 3))
    print(vyraz2(4, 3))
    print(vyraz3(4, 3))
    print(vyraz4(4, 3))
    print(vyraz5(4, 3))
    print(vyraz6(4, 3, 2))
    print(vyraz7(4, 3, 2, 1))
    print(vyraz8(4, 3, 2, 1))
 
def disassemble():
    from dis import dis
 
    print("\nvyraz1:")
    dis(vyraz1)
 
    print("\nvyraz2:")
    dis(vyraz2)
 
    print("\nvyraz3:")
    dis(vyraz3)
 
    print("\nvyraz4:")
    dis(vyraz4)
 
    print("\nvyraz5:")
    dis(vyraz5)
 
    print("\nvyraz6:")
    dis(vyraz6)
 
    print("\nvyraz7:")
    dis(vyraz7)
 
    print("\nvyraz8:")
    dis(vyraz8)
 
main()
 
disassemble()

V Pythonu je použit, jak zajisté po přečtení předchozí části tohoto miniseriálu očekáváte, zásobníkový kód. Pro aritmetické operace se tedy nejdříve načtou oba operandy na zásobník instrukcí LOAD_FAST, provede se příslušná binární operace BINARY_? a následně se hodnota uloží zpět do lokální proměnné instrukcí STORE_FAST:

vyraz1:
  8           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 BINARY_ADD                               ; provedení zvolené binární operace
              6 STORE_FAST               2 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
  9           8 LOAD_FAST                2 (result)      ; načtení hodnoty lokální proměnné
             10 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz2:
 13           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 BINARY_SUBTRACT                          ; provedení zvolené binární operace
              6 STORE_FAST               2 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 14           8 LOAD_FAST                2 (result)      ; načtení hodnoty lokální proměnné
             10 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz3:
 18           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 BINARY_MULTIPLY                          ; provedení zvolené binární operace
              6 STORE_FAST               2 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 19           8 LOAD_FAST                2 (result)      ; načtení hodnoty lokální proměnné
             10 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz4:
 23           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 BINARY_TRUE_DIVIDE                       ; provedení zvolené binární operace
              6 STORE_FAST               2 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 24           8 LOAD_FAST                2 (result)      ; načtení hodnoty lokální proměnné
             10 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz5:
 28           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 BINARY_MODULO                            ; provedení zvolené binární operace
              6 STORE_FAST               2 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 29           8 LOAD_FAST                2 (result)      ; načtení hodnoty lokální proměnné
             10 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz6:
 33           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 LOAD_FAST                2 (z)           ; uložení třetího parametru na zásobník operandů
              6 BINARY_MULTIPLY                          ; provedení zvolené binární operace, výsledek se uloží na zásobník
              8 BINARY_ADD                               ; provedení zvolené binární operace
             10 STORE_FAST               3 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 34          12 LOAD_FAST                3 (result)      ; načtení hodnoty lokální proměnné
             14 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz7:
 38           0 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              2 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              4 LOAD_FAST                2 (z)           ; uložení třetího parametru na zásobník operandů
              6 BINARY_MULTIPLY                          ; provedení zvolené binární operace, výsledek se uloží na zásobník
              8 BINARY_ADD                               ; provedení zvolené binární operace
             10 LOAD_FAST                3 (w)           ; uložení čtvrtého parametru na zásobník operandů
             12 BINARY_ADD                               ; provedení zvolené binární operace
             14 STORE_FAST               4 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 39          16 LOAD_FAST                4 (result)      ; načtení hodnoty lokální proměnné
             18 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce
 
vyraz8:
 43           0 LOAD_CONST               1 (2)           ; uložení konstanty na zásobník operandů
              2 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
              4 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
              6 BINARY_ADD                               ; provedení zvolené binární operace
              8 BINARY_MULTIPLY                          ; provedení zvolené binární operace, výsledek se uloží na zásobník
             10 LOAD_FAST                2 (z)           ; uložení třetího parametru na zásobník operandů
             12 LOAD_FAST                3 (w)           ; uložení čtvrtého parametru na zásobník operandů
             14 BINARY_ADD                               ; provedení zvolené binární operace
             16 BINARY_MULTIPLY                          ; provedení zvolené binární operace, výsledek se uloží na zásobník
             18 LOAD_FAST                0 (x)           ; uložení prvního parametru na zásobník operandů
             20 LOAD_FAST                2 (z)           ; uložení třetího parametru na zásobník operandů
             22 BINARY_ADD                               ; provedení zvolené binární operace
             24 LOAD_FAST                1 (y)           ; uložení druhého parametru na zásobník operandů
             26 LOAD_FAST                3 (w)           ; uložení čtvrtého parametru na zásobník operandů
             28 BINARY_ADD
             30 BINARY_TRUE_DIVIDE
             32 BINARY_MULTIPLY                          ; provedení zvolené binární operace, výsledek se uloží na zásobník
             34 STORE_FAST               4 (result)      ; přečtení vypočteného výsledku s jeho uložením do lokální proměnné
 
 44          36 LOAD_FAST                4 (result)      ; načtení hodnoty lokální proměnné
             38 RETURN_VALUE                             ; která bude současně návratovou hodnotou funkce

4. Zásobníkový efekt (stack effect)

Už před několika desítkami let programátoři píšící aplikace v programovacím jazyku Forth používali pro popis vlivu slov (příkazů) na položky uložené na zásobníku takzvaný zásobníkový efekt (stack effect). Pro další čtení je užitečné si čtení zásobníkového efektu osvojit.

Nejedná se v podstatě o nic složitého: uvnitř kulatých závorek, které ve Forthu ale i Factoru značí začátek a konec poznámky se zásobníkovým efektem, je symbolicky zapsán stav části zásobníku před provedením operace a po dvojici znaků „–“ stav zásobníku po provedení dané operace. Vzhledem k tomu, že na zásobníku může být uloženo teoreticky libovolné množství hodnot a daná operace většinou ovlivňuje pouze hodnoty umístěné blízko jeho vrcholu, je zásobníkový efekt zapsán pouze pro ty pozice na zásobníku, které jsou operací nějakým způsobem dotčeny, tj. operace tyto hodnoty přečte, zruší či modifikuje. Položky umístěné níže nemá cenu zapisovat, jen by zápis zbytečně komplikovaly. Položka umístěná nejvíce vlevo je ve skutečnosti uložena na spodnějších místech zásobníku, než položky napravo od ní.

Následuje jednoduchý příklad zápisu zásobníkového efektu pro operaci součtu dvou čísel. Nejprve je zapsán název operace, v tomto případě nazvané plus. Poté je zapsána otevírací kulatá závorka značící začátek poznámky, za níž následuje stav nejvyšších položek zásobníku před provedením operace (tedy těch položek, které jsou operací dotčeny – ale můžeme jich zapsat i více). Po oddělovači představovaném dvojicí znaků „–“ je uveden stav nejvyšších položek po provedení operace, za nímž následuje uzavírací kulatá závorka značící konec poznámky (ve skutečnosti jsou i kulaté závorky běžnými slovy jazyka a proto musí být od okolních slov odděleny alespoň jednou mezerou).

Vzhledem k tomu, že operace sčítání načte dvě hodnoty ze zásobníku a zpět vloží jejich součet, jsou použity odlišné symboly x, y a z, přičemž samozřejmě platí, že z=x+y:

# "hlavička" operátoru plus
plus ( x y -- z )

Pokud by nějaká operace například prohazovala hodnoty uložené na zásobníku, ale jinak by je žádným způsobem neměnila, byly by použity stejné symboly, což je případ operátoru swap či rot (což mohou být i instrukce bajtkódu):

# "hlavička" operátorů swap a rot
swap ( x y -- y x )
rot  ( x y z -- y z x )

5. Naznačení operací prováděných virtuálním strojem Pythonu zásobníkovým efektem

Výše popsaný koncept zásobníkového efektu můžeme použít i při popisu operací prováděných instrukcemi bajtkódu. Jednoduchý příklad z předchozích kapitol:

vyraz1:                                                  ; ( -- )
  8           0 LOAD_FAST                0 (x)           ; ( -- x )
              2 LOAD_FAST                1 (y)           ; ( x -- x y )
              4 BINARY_ADD                               ; ( x y -- z )
              6 STORE_FAST               2 (result)      ; ( z -- )
 
  9           8 LOAD_FAST                2 (result)      ; ( -- z )
             10 RETURN_VALUE                             ; ( -- )

A pro nejsložitější funkci z předchozích kapitol:

vyraz8:                                                  ; (  -- )
 43           0 LOAD_CONST               1 (2)           ; (  -- 2 )
              2 LOAD_FAST                0 (x)           ; ( 2 -- 2 x )
              4 LOAD_FAST                1 (y)           ; ( 2 x -- 2 x y )
              6 BINARY_ADD                               ; ( 2 x y -- 2 x+y )
              8 BINARY_MULTIPLY                          ; ( 2 x+y -- 2*(x+y) )
             10 LOAD_FAST                2 (z)           ; ( 2*(x+y) -- 2*(x+y) z )
             12 LOAD_FAST                3 (w)           ; ( 2*(x+y) z -- 2*(x+y) z w )
             14 BINARY_ADD                               ; ( 2*(x+y) z w -- 2*(x+y) z+w )
             16 BINARY_MULTIPLY                          ; ( 2*(x+y) z+w -- 2*(x+y)*(z+w) )
             18 LOAD_FAST                0 (x)           ; ( 2*(x+y)*(z+w) -- 2*(x+y)*(z+w) x )
             20 LOAD_FAST                2 (z)           ; ( 2*(x+y)*(z+w) x -- 2*(x+y)*(z+w) x z )
             22 BINARY_ADD                               ; ( 2*(x+y)*(z+w) x z -- 2*(x+y)*(z+w) x+z )
             24 LOAD_FAST                1 (y)           ; ( 2*(x+y)*(z+w) x+z -- 2*(x+y)*(z+w) x+z y )
             26 LOAD_FAST                3 (w)           ; ( 2*(x+y)*(z+w) x+z y -- 2*(x+y)*(z+w) x+z y w )
             28 BINARY_ADD                               ; ( 2*(x+y)*(z+w) x+z y w -- 2*(x+y)*(z+w) x+z y+w )
             30 BINARY_TRUE_DIVIDE                       ; ( 2*(x+y)*(z+w) x+z y+w -- 2*(x+y)*(z+w) (x+z)/(y+w) )
             32 BINARY_MULTIPLY                          ; ( 2*(x+y)*(z+w) (x+z)/(y+w) -- 2*(x+y)*(z+w)*((x+z)/(y+w)) )
             34 STORE_FAST               4 (result)      ; ( 2*(x+y)*(z+w)*((x+z)/(y+w)) -- )
 
 44          36 LOAD_FAST                4 (result)
             38 RETURN_VALUE

6. Porovnání s bajtkódem virtuálního stroje jazyka Lua

Pro zajímavost se podívejme, jak bude podobný zdrojový kód přeložen v jazyku Lua, jehož bajtkód není založen na zásobníkovém stroji, ale na stroji registrovém:

--
-- Modul s nekolika jednoduchymi funkcemi
-- pro otestovani zakladnich vlastnosti bajtkodu jazyka Lua
-- prekladu aritmetickych vyrazu.
--
 
function vyraz1(x, y)
    local result = x + y
    return result
end
 
function vyraz2(x, y)
    local result = x - y
    return result
end
 
function vyraz3(x, y)
    local result = x * y
    return result
end
 
function vyraz4(x, y)
    local result = x / y
    return result
end
 
function vyraz5(x, y)
    local result = x % y
    return result
end
 
function vyraz6(x, y, z)
    local result = x + y * z
    return result
end
 
function vyraz7(x, y, z, w)
    local result = x + y * z + w
    return result
end
 
function vyraz8(x, y, z, w)
    local result = 2 * (x + y) * (z + w) * ((x + z) / (y + w))
    return result
end
 
--
-- Vse je nutne otestovat.
--
function main()
    print(vyraz1(4, 3))
    print(vyraz2(4, 3))
    print(vyraz3(4, 3))
    print(vyraz4(4, 3))
    print(vyraz5(4, 3))
    print(vyraz6(4, 3, 2))
    print(vyraz7(4, 3, 2, 1))
    print(vyraz8(4, 3, 2, 1))
end
 
main()

Ve virtuálním stroji jazyka Lua je použit kód využívající „registry“ virtuálního stroje a proto je počet instrukcí menší, než u kódu zásobníkového. Za tuto efektivitu platíme omezeným počtem registrů (což v praxi nemusí vadit):

function <Test2.lua:7,10> (3 instructions at 0x9e07c88)
2 params, 3 slots, 0 upvalues, 3 locals, 0 constants, 0 functions
        1       [8]     ADD             2 0 1  ; provést aritmetickou operaci s parametrem 0 a 1
        2       [9]     RETURN          2 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 2
        3       [10]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:12,15> (3 instructions at 0x9e07f20)
2 params, 3 slots, 0 upvalues, 3 locals, 0 constants, 0 functions
        1       [13]    SUB             2 0 1  ; provést aritmetickou operaci s parametrem 0 a 1
        2       [14]    RETURN          2 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 2
        3       [15]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:17,20> (3 instructions at 0x9e080f0)
2 params, 3 slots, 0 upvalues, 3 locals, 0 constants, 0 functions
        1       [18]    MUL             2 0 1  ; provést aritmetickou operaci s parametrem 0 a 1
        2       [19]    RETURN          2 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 2
        3       [20]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:22,25> (3 instructions at 0x9e07ec8)
2 params, 3 slots, 0 upvalues, 3 locals, 0 constants, 0 functions
        1       [23]    DIV             2 0 1  ; provést aritmetickou operaci s parametrem 0 a 1
        2       [24]    RETURN          2 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 2
        3       [25]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:27,30> (3 instructions at 0x9e084f8)
2 params, 3 slots, 0 upvalues, 3 locals, 0 constants, 0 functions
        1       [28]    MOD             2 0 1  ; provést aritmetickou operaci s parametrem 0 a 1
        2       [29]    RETURN          2 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 2
        3       [30]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:32,35> (4 instructions at 0x9e07e18)
3 params, 4 slots, 0 upvalues, 4 locals, 0 constants, 0 functions
        1       [33]    MUL             3 1 2  ; provést aritmetickou operaci s parametrem 1 a 2
        2       [33]    ADD             3 0 3  ; provést aritmetickou operaci s parametrem 0 a lokální proměnnou 3
        3       [34]    RETURN          3 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 3
        4       [35]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:37,40> (5 instructions at 0x9e08458)
4 params, 5 slots, 0 upvalues, 5 locals, 0 constants, 0 functions
        1       [38]    MUL             4 1 2  ; provést aritmetickou operaci s parametrem 1 a 2
        2       [38]    ADD             4 0 4  ; provést další aritmetickou operaci s parametrem 0 a lokální proměnnou 4
        3       [38]    ADD             4 4 3  ; provést další aritmetickou operaci s parametrem 3 a lokální proměnnou 4
        4       [39]    RETURN          4 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 4
        5       [40]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce
 
function <Test2.lua:42,45> (10 instructions at 0x9e08720)
4 params, 7 slots, 0 upvalues, 5 locals, 1 constant, 0 functions
        1       [43]    ADD             4 0 1  ; provést aritmetickou operaci s parametrem 0 a 1
        2       [43]    MUL             4 -1 4  ; 2 - ; zde se adresuje konstanta -2 !!!
        3       [43]    ADD             5 2 3  ; provést další aritmetickou operaci, výsledek do lok. proměnné 5
        4       [43]    MUL             4 4 5
        5       [43]    ADD             5 0 2
        6       [43]    ADD             6 1 3
        7       [43]    DIV             5 5 6
        8       [43]    MUL             4 4 5
        9       [44]    RETURN          4 2    ; návrat z funkce a vrácení hodnoty lokální proměnné 4
        10      [45]    RETURN          0 1    ; automaticky vkládaná instrukce návratu z funkce

7. Překlad výrazů s Booleovskými operátory

Booleovské (logické) výrazy se v bajtkódu programovacího jazyka Python většinou překládají s využitím podmíněného skoku. Před samotnou instrukcí skoku se vyhodnotí podmínka, v našem případě první část logického výrazu, a na základě této podmínky se zjistí hodnota druhé části logického výrazu (pokud se samozřejmě jedná o operace se dvěma operandy). Podívejme se nyní na způsob překladu výrazů obsahujících negaci, logický součet, logický součin, operaci nonekvivalence a různé kombinace těchto operací:

#
# Modul s nekolika jednoduchymi funkcemi
# pro otestovani zakladnich vlastnosti bajtkodu jazyka Python
# prekladu Booleovskych vyrazu.
#
 
def vyraz1(x):
    result = not x
    return result
 
def vyraz2(x, y):
    result = x and y
    return result
 
def vyraz3(x, y):
    result = x or y
    return result
 
def vyraz4(x, y):
    result = x ^ y
    return result
 
def vyraz5(x, y, z):
    result = x or y and z
    return result
 
def vyraz6(x, y, z, w):
    result = (x or y) and (z or w)
    return result
 
 
#
# Vse je nutne otestovat.
#
def main():
    print(vyraz1(True))
    print(vyraz2(True, False))
    print(vyraz3(True, False))
    print(vyraz4(True, False))
    print(vyraz5(True, False, True))
    print(vyraz6(True, False, True, False))
 
def disassemble():
    from dis import dis
 
    print("\nvyraz1:")
    dis(vyraz1)
 
    print("\nvyraz2:")
    dis(vyraz2)
 
    print("\nvyraz3:")
    dis(vyraz3)
 
    print("\nvyraz4:")
    dis(vyraz4)
 
    print("\nvyraz5:")
    dis(vyraz5)
 
    print("\nvyraz6:")
    dis(vyraz6)
 
main()
 
disassemble()

Povšimněte si, že se kromě první funkce (negace) skutečně používají podmíněné skoky, tj. instrukce JUMP_IF_?, s nimiž se ostatně setkáme i v navazujícím textu:

vyraz1:
  8           0 LOAD_FAST                0 (x)
              2 UNARY_NOT
              4 STORE_FAST               1 (result)
 
  9           6 LOAD_FAST                1 (result)
              8 RETURN_VALUE
 
vyraz2:
 12           0 LOAD_FAST                0 (x)
              2 JUMP_IF_FALSE_OR_POP     6
              4 LOAD_FAST                1 (y)
        >>    6 STORE_FAST               2 (result)
 
 13           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz3:
 16           0 LOAD_FAST                0 (x)
              2 JUMP_IF_TRUE_OR_POP      6
              4 LOAD_FAST                1 (y)
        >>    6 STORE_FAST               2 (result)
 
 17           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz4:
 20           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 BINARY_XOR
              6 STORE_FAST               2 (result)
 
 21           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz5:
 24           0 LOAD_FAST                0 (x)
              2 JUMP_IF_TRUE_OR_POP     10
              4 LOAD_FAST                1 (y)
              6 JUMP_IF_FALSE_OR_POP    10
              8 LOAD_FAST                2 (z)
        >>   10 STORE_FAST               3 (result)

 25          12 LOAD_FAST                3 (result)
             14 RETURN_VALUE
 
vyraz6:
 28           0 LOAD_FAST                0 (x)
              2 POP_JUMP_IF_TRUE         8
              4 LOAD_FAST                1 (y)
              6 JUMP_IF_FALSE_OR_POP    14
        >>    8 LOAD_FAST                2 (z)
             10 JUMP_IF_TRUE_OR_POP     14
             12 LOAD_FAST                3 (w)
        >>   14 STORE_FAST               4 (result)
 
 29          16 LOAD_FAST                4 (result)
             18 RETURN_VALUE

8. Překlad výrazů s relačními operátory

Výrazy s relačními operátory se překládají do značné míry stejným způsobem, jako aritmetické výrazy (jen se používají odlišné binární instrukce), o čemž se ostatně přesvědčíme po pohledu na bajtkód vygenerovaný pro následující skript:

#
# Modul s nekolika jednoduchymi funkcemi
# pro otestovani zakladnich vlastnosti bajtkodu jazyka Python
# prekladu relacnich vyrazu.
#
 
def vyraz1(x, y):
    result = x <= y
    return result
 
def vyraz2(x, y):
    result = x < y
    return result
 
def vyraz3(x, y):
    result = x == y
    return result
 
def vyraz4(x, y):
    result = x != y
    return result
 
def vyraz5(x, y):
    result = x >= y
    return result
 
def vyraz6(x, y):
    result = x > y
    return result
 
 
#
# Vse je nutne otestovat.
#
def main():
    print(vyraz1(1, 2))
    print(vyraz2(1, 2))
    print(vyraz3(1, 2))
    print(vyraz4(1, 2))
    print(vyraz5(1, 2))
    print(vyraz6(1, 2))
 
def disassemble():
    from dis import dis
 
    print("\nvyraz1:")
    dis(vyraz1)
 
    print("\nvyraz2:")
    dis(vyraz2)
 
    print("\nvyraz3:")
    dis(vyraz3)
 
    print("\nvyraz4:")
    dis(vyraz4)
 
    print("\nvyraz5:")
    dis(vyraz5)
 
    print("\nvyraz6:")
    dis(vyraz6)
 
main()
 
disassemble()

Z bajtkódu je patrné, že se používá „univerzální“ instrukce COMPARE_OP, jejímž celočíselným parametrem je číslo (index) prováděné operace:

vyraz1:
  8           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 COMPARE_OP               1 (<=)
              6 STORE_FAST               2 (result)
 
  9           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz2:
 12           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 COMPARE_OP               0 (<)
              6 STORE_FAST               2 (result)
 
 13           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz3:
 16           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 COMPARE_OP               2 (==)
              6 STORE_FAST               2 (result)
 
 17           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz4:
 20           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 COMPARE_OP               3 (!=)
              6 STORE_FAST               2 (result)
 
 21           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz5:
 24           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 COMPARE_OP               5 (>=)
              6 STORE_FAST               2 (result)
 
 25           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE
 
vyraz6:
 28           0 LOAD_FAST                0 (x)
              2 LOAD_FAST                1 (y)
              4 COMPARE_OP               4 (>)
              6 STORE_FAST               2 (result)
 
 29           8 LOAD_FAST                2 (result)
             10 RETURN_VALUE

9. Překlad řídicí struktury typu if-then

Nyní se již konečně dostáváme k mnohem zajímavějšímu tématu – konkrétně k podmíněným skokům, kterými jsou realizovány strukturované příkazy (rozeskoky) typu if-then a samozřejmě i úplné rozhodovací konstrukce typu if-then-else. Jedná se o tak časté programové konstrukce, že pro ně byly v bajtkódu vyhrazeny speciální operace. Nejprve se podívejme na zdrojový kód dvou funkcí, jejichž bajtkód budeme zkoumat:

def prikaz1(x):
    if x:
        return 10
    return 20
 
def prikaz2(x, y):
    if x:
        if y:
            return 10
    return 20
 
#
# Vse je nutne otestovat.
#
def main():
    print(prikaz1(True))
    print(prikaz1(False))
    print(prikaz2(True, True))
    print(prikaz2(True, False))
    print(prikaz2(False, True))
    print(prikaz2(False, False))
 
def disassemble():
    from dis import dis
 
    print("\nprikaz1:")
    dis(prikaz1)
 
    print("\nprikaz2:")
    dis(prikaz2)
 
main()
 
disassemble()

Nejzajímavější částí bajtkódu jsou v tomto případě instrukce POP_JUMP_IF_FALSE (resp. POP_JUMP_IF_TRUE), které načtou hodnotu a pokud je rovna False (tedy vlastně 0), provede se podmíněný skok na konec rozvětvení:

prikaz1:
  8           0 LOAD_FAST                0 (x)
              2 POP_JUMP_IF_FALSE        8
 
  9           4 LOAD_CONST               1 (10)
              6 RETURN_VALUE
 
 10     >>    8 LOAD_CONST               2 (20)
             10 RETURN_VALUE
 
prikaz2:
 13           0 LOAD_FAST                0 (x)
              2 POP_JUMP_IF_FALSE       12
 
 14           4 LOAD_FAST                1 (y)
              6 POP_JUMP_IF_FALSE       12
 
 15           8 LOAD_CONST               1 (10)
             10 RETURN_VALUE
 
 16     >>   12 LOAD_CONST               2 (20)
             14 RETURN_VALUE

10. Překlad řídicí struktury typu if-then-else

Úplná programová konstrukce if-then-else vznikne z neúplné konstrukce typu if-then doplněním programové větve else, což je samozřejmě podporováno i bajtkódem virtuálního stroje Pythonu – musí se jednat o úplné rozvětvení a tedy typicky o kombinaci podmíněného skoku se skokem nepodmíněným:

def prikaz1(x):
    if x:
        return 10
    else:
        return 20
 
def prikaz2(x, y):
    if x:
        if y:
            return 10
        else:
            return 20
    else:
        return 30
 
#
# Vse je nutne otestovat.
#
def main():
    print(prikaz1(True))
    print(prikaz1(False))
    print(prikaz2(True, True))
    print(prikaz2(True, False))
    print(prikaz2(False, True))
    print(prikaz2(False, False))
 
def disassemble():
    from dis import dis
 
    print("\nprikaz1:")
    dis(prikaz1)
 
    print("\nprikaz2:")
    dis(prikaz2)
 
main()
 
disassemble()

V bajtkódu nyní uvidíme dvě možnosti. První variantou je plný rozeskok, přičemž každá větev končí instrukcí RETURN_VALUE:

prikaz1:
  8           0 LOAD_FAST                0 (x)
              2 POP_JUMP_IF_FALSE        8
 
  9           4 LOAD_CONST               1 (10)
              6 RETURN_VALUE
 
 11     >>    8 LOAD_CONST               2 (20)
             10 RETURN_VALUE
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

Druhá varianta spočívá ve využití již výše zmíněné kombinace podmíněného a nepodmíněného skoku, tedy zde konkrétně instrukcí POP_JUMP_IF_FALSE a JUMP_FORWARD:

prikaz2:
 14           0 LOAD_FAST                0 (x)
              2 POP_JUMP_IF_FALSE       18
 
 15           4 LOAD_FAST                1 (y)
              6 POP_JUMP_IF_FALSE       12
 
 16           8 LOAD_CONST               1 (10)
             10 RETURN_VALUE
 
 18     >>   12 LOAD_CONST               2 (20)
             14 RETURN_VALUE
             16 JUMP_FORWARD             4 (to 22)
 
 20     >>   18 LOAD_CONST               3 (30)
             20 RETURN_VALUE
        >>   22 LOAD_CONST               0 (None)
             24 RETURN_VALUE

11. Jednoduchá programová smyčka typu while

Základním a ve skutečnosti i univerzálním typem smyčky je ve strukturovaném programování smyčka typu while. U tohoto typu smyčky se podmínka pro ukončení smyčky kontroluje vždy na začátku každé iterace, což mj. znamená, že se tělo smyčky nemusí provést ani jednou, a to v případě, kdy podmínka není splněna již před provedením první iterace, tj. před vstupem do smyčky. Z tohoto důvodu se konstrukce while používá například v situacích, kdy se mají zpracovávat vstupní data (čtená ze souboru, z databázové tabulky atd.), u nichž není zřejmé, kolik údajů se bude načítat a zda se vůbec nějaký údaj na vstupu bude nacházet. Zajímavé je, že ostatní typy smyček lze většinou přepsat právě na programovou smyčku typu while, i když – jak uvidíme na příkladu Pythonu – se nemusí vždy jednat o elegantní řešení. Pojďme si tedy na velmi jednoduchých příkladech ukázat způsob překladu této programové smyčky do bajtkódu virtuálního stroje Pythonu. Nejprve si ukážeme překlad smyčky, v níž se pouze snižuje hodnota počitadla kontrolovaného v podmínce pro další iteraci.

def loop(x):
    while x > 0:
        x = x - 1
    return x
 
 
#
# Vse je nutne otestovat.
#
def main():
    print(loop(10))
 
#
# Vypsani bajtkodu testovane funkce
#
def disassemble():
    from dis import dis
 
    print("\nloop:")
    dis(loop)
 
main()
 
disassemble()

Bajtkód vytvořený pro virtuální stroj Pythonu je kupodivu poměrně dlouhý (což prakticky znamená i pomalejší vyhodnocení v porovnání s Luou). Můžeme zde vidět jak nepodmíněný skok JUMP_ABSOLUTE, tak i podmíněný skok JUMP_IF_FALSE, pro nějž se podmínka vyhodnocuje instrukcí COMPARE_OP (již známe). Povšimněte si taktéž nutnosti použití instrukce POP_TOP sloužící pro „uklizení“ obsahu zásobníku operandů:

loop:
  8     >>    0 LOAD_FAST                0 (x)
              2 LOAD_CONST               1 (0)
              4 COMPARE_OP               4 (>)
              6 POP_JUMP_IF_FALSE       18
 
  9           8 LOAD_FAST                0 (x)
             10 LOAD_CONST               2 (1)
             12 BINARY_SUBTRACT
             14 STORE_FAST               0 (x)
             16 JUMP_ABSOLUTE            0
 
 10     >>   18 LOAD_FAST                0 (x)
             20 RETURN_VALUE

12. Programová smyčka typu while se složitějším tělem

Pro zajímavost se ještě podívejme na poněkud složitější demonstrační příklady, v nichž je opět použita programová smyčka typu while. Tyto příklady slouží k výpočtu exponenciální funkce 2^x, popř. y2^x (což je v Pythonu vlastně zbytečné protože pro tuto operaci máme k dispozici operátor **). Vzhledem k tomu, že hodnoty x a y nejsou dopředu známé, nemůže překladač provádět prakticky žádné optimalizace smyčky (to mohl teoreticky udělat v předchozím příkladu, což se však, jak již víme, ve skutečnosti nestalo, alespoň nikoli na úrovni bajtkódu).

def loop(x, y):
    while x > 0:
        x = x - 1
        y = y * 2
    return y
 
 
#
# Vse je nutne otestovat.
#
def main():
    print(loop(10, 1))
 
def disassemble():
    from dis import dis
 
    print("\nloop:")
    dis(loop)
 
main()
 
disassemble()

Opět můžeme vidět, že se test na ukončení smyčky provádí v úvodní části kódu (porovnání+podmíněný skok), zatímco na konci smyčky je použit nepodmíněný skok na začátek:

loop:
  8     >>    0 LOAD_FAST                0 (x)
              2 LOAD_CONST               1 (0)
              4 COMPARE_OP               4 (>)
              6 POP_JUMP_IF_FALSE       26
 
  9           8 LOAD_FAST                0 (x)
             10 LOAD_CONST               2 (1)
             12 BINARY_SUBTRACT
             14 STORE_FAST               0 (x)
 
 10          16 LOAD_FAST                1 (y)
             18 LOAD_CONST               3 (2)
             20 BINARY_MULTIPLY
             22 STORE_FAST               1 (y)
             24 JUMP_ABSOLUTE            0
 
 11     >>   26 LOAD_FAST                1 (y)
             28 RETURN_VALUE

13. Dvě vnořené smyčky typu while – výpis řady prvočísel

Nastává čas ukázat si způsob překladu algoritmu, v němž se používají dvě vnořené programové smyčky typu while. Zde je již situace zajímavější, protože delší zdrojový kód dává překladači alespoň teoretickou možnost provedení různých optimalizací. Jako příklad jsem vybral výpočet řady prvočísel od 2 do zadané maximální hodnoty, přičemž se pro výpočet používá ta nejjednodušší a současně i nejpomalejší :-) metoda založená na postupném zjišťování, zda je zadaná hodnota n dělitelná nějakým celým číslem v rozsahu 2..n-1 (teoreticky je možné smyčku ukončit dříve, ovšem nechtěl jsem zbytečně do demonstračního algoritmu přidávat volání funkcí).

V Pythonu je možné tento algoritmus zapsat následujícím způsobem:

def primeNumbers(min, max):
    i = min
    while i <= max:        # projit vsechny hodnoty od min do max
        j = 2
        while j < i:       # (lze optimalizovat a zkratit smycku!)
            if i % j == 0: # je mozne celociselne delit?
                break      # - pak ovsem nejde o prvocislo
            j = j + 1      # vyzkouset dalsiho kandidata na celociselne deleni
        if j == i:         # pokud jsme dosli az k cislu i
            print(i)       # nedoslo nikdy k celociselnemu deleni
        i = i + 1          # dalsi hodnota v posloupnosti
 
#
# Vse je nutne otestovat.
#
def main():
    primeNumbers(2, 1000)
 
def disassemble():
    from dis import dis
 
    print("\nprimeNumbers:")
    dis(primeNumbers)
 
main()
 
disassemble()

Překlad do bajtkódu je v tomto případě dosti těžkopádný a jedná se o jeden z důvodů, proč je interpret Pythonu tak pomalý v porovnání s nejbližší (technologickou) konkurencí:

primeNumbers:
  9           0 LOAD_FAST                0 (min)      # i = min
              2 STORE_FAST               2 (i)
 
 10     >>    4 LOAD_FAST                2 (i)
              6 LOAD_FAST                1 (max)
              8 COMPARE_OP               1 (<=)
             10 POP_JUMP_IF_FALSE       74            # while(i <= max):
 
 11          12 LOAD_CONST               1 (2)
             14 STORE_FAST               3 (j)
 
 12     >>   16 LOAD_FAST                3 (j)        # j = 2
             18 LOAD_FAST                2 (i)
             20 COMPARE_OP               0 (<)
             22 POP_JUMP_IF_FALSE       48
 
 13          24 LOAD_FAST                2 (i)        # if i % j == 0:
             26 LOAD_FAST                3 (j)
             28 BINARY_MODULO
             30 LOAD_CONST               2 (0)
             32 COMPARE_OP               2 (==)
             34 POP_JUMP_IF_FALSE       38    # break
 
 14          36 JUMP_ABSOLUTE           48
 
 15     >>   38 LOAD_FAST                3 (j)        # j = j + 1
             40 LOAD_CONST               3 (1)
             42 BINARY_ADD
             44 STORE_FAST               3 (j)
             46 JUMP_ABSOLUTE           16            # konec vnitřní smyčky
 
 16     >>   48 LOAD_FAST                3 (j)        # if (j == i):
             50 LOAD_FAST                2 (i)
             52 COMPARE_OP               2 (==)
             54 POP_JUMP_IF_FALSE       64
 
 17          56 LOAD_GLOBAL              0 (print)
             58 LOAD_FAST                2 (i)        # print i
             60 CALL_FUNCTION            1
             62 POP_TOP
 
 18     >>   64 LOAD_FAST                2 (i)        # i = i + 1
             66 LOAD_CONST               3 (1)
             68 BINARY_ADD
             70 STORE_FAST               2 (i)
             72 JUMP_ABSOLUTE            4            # konec vnější smyčky
        >>   74 LOAD_CONST               0 (None)
             76 RETURN_VALUE

14. Jednoduchá programová smyčka typu do-while/repeat-until

Kromě programové smyčky typu while se ve strukturovaném programování velmi často setkáme i se smyčkou typu do-while, popř. s ekvivalentní smyčkou repeat-until. Zatímco se ve smyčce while provádí test na ukončení smyčky před každou iterací, je v případě do-while i repeat-until test prováděn na konci těla smyčky a tedy již po dokončení jedné iterace, což mimochodem znamená, že tělo smyčky bude vždy provedeno alespoň jedenkrát. Rozdíl mezi smyčkami do-while (céčková větev programovacích jazyků) a repeat-until (Pascal, Modula-2, Lua) spočívá pouze v tom, zda je splnění zapsané podmínky považováno za vstup do další iterace či naopak za důvod pro ukončení celé programové smyčky. Zatímco programovací jazyk Java podporuje smyčku do-while, najdeme v jazyku Lua smyčku repeat-until a v Pythonu je nutné tuto smyčku emulovat s využitím smyčky typu while doplněnou o podmínku na konci, popř. doplněnou o další lokální proměnnou:

def loop(x):
    while True:
        x = x - 1
        if x <= 0: break
    return x
 
#
# Vse je nutne otestovat.
#
def main():
    print(loop(10))
  
#
# Vypsani bajtkodu testovane funkce
#
def disassemble():
    from dis import dis
  
    print("\nloop:")
    dis(loop)
  
main()
  
disassemble()

V případě Pythonu je smyčka do-while ve skutečnosti pouze emulována, čemuž odpovídá i (relativně přímočarý) překlad do bajtkódu:

loop:
 10     >>    0 LOAD_FAST                0 (x)
              2 LOAD_CONST               1 (1)
              4 BINARY_SUBTRACT                   # x=x-1
              6 STORE_FAST               0 (x)
 
 11           8 LOAD_FAST                0 (x)
             10 LOAD_CONST               2 (0)
             12 COMPARE_OP               1 (<=)   # vyhodnocení podmínky
             14 POP_JUMP_IF_FALSE        0        # podmíněný skok na začátek smyčky
             16 JUMP_ABSOLUTE           20        # výskok ze smyčky
             18 JUMP_ABSOLUTE            0        # nepodmíněný skok na začátek smyčky
 
 12     >>   20 LOAD_FAST                0 (x)    # návratová hodnota
             22 RETURN_VALUE

15. Příloha A: základní instrukce pro manipulaci se zásobníkem

Před provedením aritmetických, logických i bitových instrukcí jakož i před zavoláním jiné funkce, popř. metody je mnohdy nutné data vložit do vhodných registrů a/nebo na správné místo v zásobníku operandů. K tomu slouží instrukce popsané v této příloze.

Python VM je zásobníkový virtuální stroj, proto jeho instrukční sada obsahuje několik instrukcí, které se nápadně podobají slovům používaným v programovacím jazyku Forth (ono se ostatně není čemu divit, protože se jedná skutečně o základní „zásobníkové“ instrukce). Důležité je, že tyto instrukce již nepotřebují být rozděleny podle toho s jakými daty pracují, protože každému prvku uloženém na zásobníku operandů je stejně přiřazen datový tag, který je těmito instrukcemi využíván:

16. Příloha B: aritmetické a logické operace

Začněme popisem aritmetických instrukcí, které jsou velmi jednoduché a snadno pochopitelné.

Aritmetické instrukce pracují s hodnotami umístěnými na zásobníku operandů, podobně jako je tomu například i v JVM. Všechny instrukce navíc mohou pracovat i pro různé typy objektů (to odpovídá přetížení příslušných operandů):

Druhou skupinou instrukcí jsou instrukce, pomocí nichž se implementují téměř všechny základní bitové a logické operace.

V Python VM nalezneme i následující instrukce pro posuny (pro celočíselné operandy se jedná o aritmetický posun doleva a doprava):

17. Příloha C: podmíněné a nepodmíněné skoky, větvení kódu

Ve virtuálním stroji programovacího jazyka Python nalezneme celkem šest základních instrukcí skoku – konkrétně dvě instrukce určené pro provedení nepodmíněných skoků a tři instrukce pro provedení skoků podmíněných:

18. Příloha D: Tabulka všech operačních kódů instrukcí Python VM

Virtuální stroj programovacího jazyka Python využívá v bajtkódu instrukce, jejichž operační kód má šířku osmi bitů (jeden bajt). To znamená, že je teoreticky možné využít 256 různých instrukcí. Ve skutečnosti jsou však některé operační kódy neobsazeny, což je ostatně patrné i při pohledu na tabulku se seznamem všech (v současnosti používaných) instrukcí Python VM.

19. Repositář s demonstračními příklady

Zdrojové kódy všech prozatím popsaných demonstračních příkladů určených pro programovací jazyk Python 3 (některé přímo pro Python 3.10) byly uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/most-popular-python-libs. V případě, že nebudete chtít klonovat celý repositář (ten je ovšem stále velmi malý, dnes má velikost zhruba několik desítek kilobajtů), můžete namísto toho použít odkazy na jednotlivé příklady, které naleznete v následující tabulce:

20. Odkazy na Internetu

1. Inside The Python Virtual Machine
   https://leanpub.com/insidet­hepythonvirtualmachine
2. module-py_compile
   https://docs.python.org/3­.8/library/py_compile.html
3. Given a python .pyc file, is there a tool that let me view the bytecode?
   https://stackoverflow.com/qu­estions/11141387/given-a-python-pyc-file-is-there-a-tool-that-let-me-view-the-bytecode
4. The structure of .pyc files
   https://nedbatchelder.com/blog/200804/the_str­ucture_of_pyc_files.html
5. Python Bytecode: Fun With Dis
   http://akaptur.github.io/blog/2013/08/14/pyt­hon-bytecode-fun-with-dis/
6. Python's Innards: Hello, ceval.c!
   http://tech.blog.aknin.na­me/category/my-projects/pythons-innards/
7. Byterun
   https://github.com/nedbat/byterun
8. Python Byte Code Instructions
   http://document.ihg.uni-duisburg.de/Documentation/Pyt­hon/lib/node56.html
9. Python Byte Code Instructions
   https://docs.python.org/3­.2/library/dis.html#python-bytecode-instructions
10. dis – Python module
    https://docs.python.org/2/li­brary/dis.html
11. Comparison of Python virtual machines
    http://polishlinux.org/ap­ps/cli/comparison-of-python-virtual-machines/
12. O-code
    http://en.wikipedia.org/wiki/O-code_machine
13. Abstract syntax tree
    https://en.wikipedia.org/wi­ki/Abstract_syntax_tree
14. Lexical analysis
    https://en.wikipedia.org/wi­ki/Lexical_analysis
15. Parser
    https://en.wikipedia.org/wi­ki/Parsing#Parser
16. Parse tree
    https://en.wikipedia.org/wi­ki/Parse_tree
17. Derivační strom
    https://cs.wikipedia.org/wi­ki/Deriva%C4%8Dn%C3%AD_strom
18. Python doc: ast — Abstract Syntax Trees
    https://docs.python.org/3/li­brary/ast.html
19. Python doc: tokenize — Tokenizer for Python source
    https://docs.python.org/3/li­brary/tokenize.html
20. SymbolTable
    https://docs.python.org/3­.8/library/symtable.html
21. 5 Amazing Python AST Module Examples
    https://www.pythonpool.com/python-ast/
22. Intro to Python ast Module
    https://medium.com/@wshanshan/intro-to-python-ast-module-bbd22cd505f7
23. Golang AST Package
    https://golangdocs.com/golang-ast-package
24. AP8, IN8 Regulární jazyky
    http://statnice.dqd.cz/home:inf:ap8
25. AP9, IN9 Konečné automaty
    http://statnice.dqd.cz/home:inf:ap9
26. AP10, IN10 Bezkontextové jazyky
    http://statnice.dqd.cz/home:inf:ap10
27. AP11, IN11 Zásobníkové automaty, Syntaktická analýza
    http://statnice.dqd.cz/home:inf:ap11
28. Introduction to YACC
    https://www.geeksforgeeks­.org/introduction-to-yacc/
29. Introduction of Lexical Analysis
    https://www.geeksforgeeks­.org/introduction-of-lexical-analysis/?ref=lbp
30. Využití knihovny Pygments (nejenom) pro obarvení zdrojových kódů
    https://www.root.cz/clanky/vyuziti-knihovny-pygments-nejenom-pro-obarveni-zdrojovych-kodu/
31. Pygments – Python syntax highlighter
    http://pygments.org/
32. Pygments (dokumentace)
    http://pygments.org/docs/
33. Write your own filter
    http://pygments.org/docs/fil­terdevelopment/
34. Write your own lexer
    http://pygments.org/docs/le­xerdevelopment/
35. Write your own formatter
    http://pygments.org/docs/for­matterdevelopment/
36. Jazyky podporované knihovnou Pygments
    http://pygments.org/languages/
37. Pygments FAQ
    http://pygments.org/faq/
38. Compiler Construction/Lexical analysis
    https://en.wikibooks.org/wi­ki/Compiler_Construction/Le­xical_analysis
39. Compiler Design – Lexical Analysis
    https://www.tutorialspoin­t.com/compiler_design/com­piler_design_lexical_analy­sis.htm
40. Lexical Analysis – An Intro
    https://www.scribd.com/do­cument/383765692/Lexical-Analysis
41. Python AST Visualizer
    https://github.com/pombredanne/python-ast-visualizer
42. What is an Abstract Syntax Tree
    https://blog.bitsrc.io/what-is-an-abstract-syntax-tree-7502b71bde27
43. Why is AST so important
    https://medium.com/@obernar­dovieira/why-is-ast-so-important-b1e7d6c29260
44. Emily Morehouse-Valcarcel – The AST and Me – PyCon 2018
    https://www.youtube.com/wat­ch?v=XhWvz4dK4ng
45. Python AST Parsing and Custom Linting
    https://www.youtube.com/wat­ch?v=OjPT15y2EpE
46. Chase Stevens – Exploring the Python AST Ecosystem
    https://www.youtube.com/wat­ch?v=Yq3wTWkoaYY
47. Full Grammar specification
    https://docs.python.org/3/re­ference/grammar.html