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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
# Wrappers around file system primitives that take a 'filesystem' object and
# are thus easier to test.
container filesystem [
data:address:array:file-mapping
]
container file-mapping [
name:address:array:character
contents:address:array:character
]
def start-reading fs:address:filesystem, filename:address:array:character -> contents:address:source:character [
local-scope
load-ingredients
{
break-if fs
# real file system
file:number <- $open-file-for-reading filename
assert file, [file not found]
contents:address:source:character, sink:address:sink:character <- new-channel 30
start-running transmit-from-file file, sink
return
}
# fake file system
i:number <- copy 0
data:address:array:file-mapping <- get *fs, data:offset
len:number <- length *data
{
done?:boolean <- greater-or-equal i, len
break-if done?
tmp:file-mapping <- index *data, i
i <- add i, 1
curr-filename:text <- get tmp, name:offset
found?:boolean <- equal filename, curr-filename
loop-unless found?
contents:address:source:character, sink:address:sink:character <- new-channel 30
curr-contents:text <- get tmp, contents:offset
start-running transmit-from-text curr-contents, sink
return
}
return 0/not-found
]
def transmit-from-file file:number, sink:address:sink:character -> sink:address:sink:character [
local-scope
load-ingredients
{
c:character, eof?:boolean <- $read-from-file file
break-if eof?
sink <- write sink, c
loop
}
sink <- close sink
file <- $close-file file
]
def transmit-from-text contents:address:array:character, sink:address:sink:character -> sink:address:sink:character [
local-scope
load-ingredients
i:number <- copy 0
len:number <- length *contents
{
done?:boolean <- greater-or-equal i, len
break-if done?
c:character <- index *contents, i
sink <- write sink, c
i <- add i, 1
loop
}
sink <- close sink
]
def start-writing fs:address:filesystem, filename:address:array:character -> sink:address:sink:character, routine-id:number [
local-scope
load-ingredients
source:address:source:character, sink:address:sink:character <- new-channel 30
{
break-if fs
# real file system
file:number <- $open-file-for-writing filename
assert file, [no such file]
routine-id <- start-running transmit-to-file file, source
reply
}
# fake file system
# beware: doesn't support multiple concurrent writes yet
routine-id <- start-running transmit-to-fake-file fs, filename, source
]
def transmit-to-file file:number, source:address:source:character -> source:address:source:character [
local-scope
load-ingredients
{
c:character, done?:boolean, source <- read source
break-if done?
$write-to-file file, c
loop
}
file <- $close-file file
]
def transmit-to-fake-file fs:address:filesystem, filename:address:array:character, source:address:source:character -> fs:address:filesystem, source:address:source:character [
local-scope
load-ingredients
# compute new file contents
buf:address:buffer <- new-buffer 30
{
c:character, done?:boolean, source <- read source
break-if done?
buf <- append buf, c
loop
}
contents:text <- buffer-to-array buf
new-file-mapping:file-mapping <- merge filename, contents
# write to filesystem
curr-filename:text <- copy 0
data:address:array:file-mapping <- get *fs, data:offset
# replace file contents if it already exists
i:number <- copy 0
len:number <- length *data
{
done?:boolean <- greater-or-equal i, len
break-if done?
tmp:file-mapping <- index *data, i
curr-filename <- get tmp, name:offset
found?:boolean <- equal filename, curr-filename
loop-unless found?
put-index *data, i, new-file-mapping
reply
}
# if file didn't already exist, make room for it
new-len:number <- add len, 1
new-data:address:array:file-mapping <- new file-mapping:type, new-len
put *fs, data:offset, new-data
# copy over old files
i:number <- copy 0
{
done?:boolean <- greater-or-equal i, len
break-if done?
tmp:file-mapping <- index *data, i
put-index *new-data, i, tmp
}
# write new file
put-index *new-data, len, new-file-mapping
]
|