git @ Cat's Eye Technologies Turmac / master src / Language / Turmac / Backend / Python.hs
master

Tree @master (Download .tar.gz)

Python.hs @master — raw · history · blame 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
-- SPDX-FileCopyrightText: Chris Pressey, the creator of this work, has dedicated it to the public domain.
-- For more information, please refer to <https://unlicense.org/>
-- SPDX-License-Identifier: Unlicense

module Language.Turmac.Backend.Python where

import Data.List (intercalate)

import Language.Turmac.Model
import Language.Turmac.IR
import Language.Turmac.IRCompiler

compileToPython :: [TMRule] -> String
compileToPython tmRules = let prog = buildProgram tmRules in unlines [
    "class Tape:",
    "    def __init__(self, initial_input=None):",
    "        self.left_cells = []",
    "        self.current_cell = '_'",
    "        self.right_cells = []",
    "        if initial_input is not None:",
    "            initial_input = [str(x) for x in initial_input]",
    "            self.current_cell = initial_input[0] if initial_input else '_'",
    "            self.right_cells = list(initial_input[1:]) if len(initial_input) > 1 else []",
    "",
    "    def move_left(self):",
    "        if self.left_cells:",
    "            self.right_cells.insert(0, self.current_cell)",
    "            self.current_cell = self.left_cells.pop()",
    "        else:",
    "            self.right_cells.insert(0, self.current_cell)",
    "            self.current_cell = '_'",
    "",
    "    def move_right(self):",
    "        if self.right_cells:",
    "            self.left_cells.append(self.current_cell)",
    "            self.current_cell = self.right_cells.pop(0)",
    "        else:",
    "            self.left_cells.append(self.current_cell)",
    "            self.current_cell = '_'",
    "",
    "    def write_symbol(self, symbol):",
    "        self.current_cell = str(symbol)",
    "",
    "    def read_symbol(self):",
    "        return self.current_cell",
    "",
    "    def get_tape_contents(self):",
    "        def strip_zeros(lst):",
    "            while lst and lst[-1] == '_':",
    "                lst.pop()",
    "            return lst",
    "",
    "        left = strip_zeros(self.left_cells[:])",
    "        right = strip_zeros(self.right_cells[:])",
    "        return left + [self.current_cell] + right",
    "",
    "class TuringMachine:",
    "    def __init__(self, initial_input=None):",
    "        self.tape = Tape(initial_input)",
    "        self.state = 'S0'",
    "        self.halted = False",
    "",
    "    def step(self):",
    indentPython 2 (compileStep prog),
    "",
    "    def run(self):",
    "        while not self.halted:",
    "            self.step()",
    "",
    "    def get_configuration(self):",
    "        return (self.state, self.tape.get_tape_contents(), self.halted)",
    "",
    "def main():",
    "    import sys",
    "    initial_input = sys.argv[1].split(',') if len(sys.argv) > 1 else None",
    "    tm = TuringMachine(initial_input)",
    "    tm.run()",
    "    state, tape, halted = tm.get_configuration()",
    "    tape_str = ','.join(tape)",
    "    print(f'State: {state}, Tape: [{tape_str}], Halted: {halted}')",
    "",
    "if __name__ == '__main__':",
    "    main()"
    ]

compileStep :: Prog -> String
compileStep (Program p) = compileStep p
compileStep (Seq ps) = intercalate "\n" (map compileStep ps)
compileStep (CondState branches) = unlines [
    "if self.halted:",
    "    return",
    compileBranches "self.state" branches
    ]
compileStep (CondSymbol branches) = 
    compileBranches "self.tape.read_symbol()" branches
compileStep (WriteMoveGoto sym dir state) = unlines [
    "self.tape.write_symbol(" ++ show sym ++ ")",
    if dir == -1 then "self.tape.move_left()" else "self.tape.move_right()",
    if state == "H" then "self.halted = True" else "self.state = " ++ show state
    ]

compileBranches :: String -> [(StateId, Prog)] -> String
compileBranches cond branches = unlines $
    [     "if " ++ cond ++ " == " ++ show val ++ ":" | (val, _) <- take 1 branches] ++
    [indentPython 1 (compileStep prog) | (_, prog) <- take 1 branches] ++
    concat [[
        "elif " ++ cond ++ " == " ++ show val ++ ":",
        indentPython 1 (compileStep prog)
    ] | (val, prog) <- drop 1 branches] ++
    ["else:",
     "    raise ValueError(f'No rules for " ++ cond ++ " = {" ++ cond ++ "}')"
    ]

indentPython :: Int -> String -> String
indentPython n code = unlines [
    replicate (n * 4) ' ' ++ line | line <- lines code
    ]