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
118
|
from .. import TypeEnum, Environment, Arg, Builtin, evaluate, InterpretPanic
from ..structs import *
from pathlib import Path
from glob import glob
from io import UnsupportedOperation
import sys
FS = Environment()
FS.register("_stdin_", Handle(sys.stdin))
FS.register("_stdout_", Handle(sys.stdout))
FS.register("_stderr_", Handle(sys.stderr))
def interpretExists(symbol, args, env, ns):
return Bool(Path(args[0].value).resolve().exists())
FS.register("exists?", Builtin("exists?", interpretExists, [Arg("filename", TypeEnum.STRING)], return_type=Type(":bool")))
def interpretGlob(symbol, args, env, ns):
items = glob(args[0].value)
return List([String(item) for item in items])
FS.register("glob", Builtin("glob", interpretGlob, [Arg("regex", TypeEnum.STRING)], return_type=Type(":string")))
def interpretUnlink(symbol, args, env, ns):
target_path = Path(args[0].value).resolve()
if not target_path.exists():
raise InterpretPanic(symbol, "target file does not exist", target_path)
target_path.unlink()
return List([])
FS.register("unlink", Builtin("unlink", interpretUnlink, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list")))
def interpretWrite(symbol, args, env, ns):
string = args[0]
handle = args[1]
try:
handle.file.write(string.value)
except UnsupportedOperation:
raise InterpretPanic(symbol, f"{handle} is not writable!")
except ValueError:
raise InterpretPanic(symbol, f"{handle} is closed")
return List([])
FS.register("write", Builtin("write", interpretWrite, [Arg("string", TypeEnum.STRING), Arg("handle", TypeEnum.HANDLE)], return_type=TypeEnum.LIST))
def interpretOpenRead(symbol, args, env, ns):
name = args[0].value
fil = Path(name)
if not fil.exists():
raise InterpretPanic(symbol, "file does not exist", fil)
try:
f = open(str(fil), "r")
except:
raise InterpretPanic(symbol, "cannot open {fil} for reading")
return Handle(f)
FS.register("open-read", Builtin("open-read", interpretOpenRead, [Arg("filename", TypeEnum.STRING)], return_type=TypeEnum.HANDLE))
def interpretOpenWrite(symbol, args, env, ns):
name = args[0].value
fil = Path(name)
try:
f = open(str(fil), "w")
except:
raise InterpretPanic(symbol, "cannot open {fil} for writing")
return Handle(f)
FS.register("open-write", Builtin("open-write", interpretOpenWrite, [Arg("filename", TypeEnum.STRING)], return_type=TypeEnum.HANDLE))
def interpretOpenAppend(symbol, args, env, ns):
name = args[0].value
fil = Path(name)
try:
f = open(str(fil), "a")
except:
raise InterpretPanic(symbol, "cannot open {fil} for appending")
return Handle(f)
FS.register("open-append", Builtin("open-append", interpretOpenAppend, [Arg("filename", TypeEnum.STRING)], return_type=TypeEnum.HANDLE))
def interpretClose(symbol, args, env, ns):
try:
args[0].file.close()
# TODO ideally we'd be able to remove it from the env
# but by this point, we don't know its symbol
# though it may not be in the env, e.g.
# (close (print (read (open-read "fil.txt"))))
except:
raise InterpretPanic(symbol, "cannot close {args[0]}")
return List([])
FS.register("close", Builtin("close", interpretClose, [Arg("handle", TypeEnum.HANDLE)], return_type=TypeEnum.LIST))
def interpretRead(symbol, args, env, ns):
handle = args[0]
try:
inp = args[0].file.read()
except UnsupportedOperation:
raise InterpretPanic(symbol, f"{handle} is not writable!")
except ValueError:
raise InterpretPanic(symbol, f"{handle} is closed")
return String(inp)
FS.register("read", Builtin("read", interpretRead, [Arg("handle", TypeEnum.HANDLE)], return_type=TypeEnum.STRING))
def interpretReadLines(symbol, args, env, ns):
target_file_name = args[0].value
target_file = Path(target_file_name).resolve()
if not target_file.exists():
raise InterpretPanic(symbol, "no such file", target_file)
with open(target_file, "r") as fil:
data = fil.readlines()
out = List([String(d) for d in data]) # all lines are strings
return out
FS.register("read-lines", Builtin("read-lines", interpretReadLines, [Arg("filename", TypeEnum.STRING)], return_type=Type(":list")))
|
