Debian Codegraph @

ipl/packs/euler/eulerint.icn

raw
1 # Euler Interpreter
2 global S,k,i,mp,fct
3
4 record Reference(lst,pos)
5 record Progref(mix,adr)
6 record procDescr(bln,mix,adr)
7
8 procedure reference(on,bn)
9 local j
10 j := mp
11 while j>0 do {
12 if S[j][1] = bn then return Reference(S[j][4],on)
13 j := S[j][3] #static link
14 }
15 RTError("dangling reference")
16 fail
17 end
18
19 procedure progref(pa,bn)
20 local j
21 j := mp
22 while j>0 do {
23 if S[j][1] = bn then return Progref(j,pa)
24 j := S[j][3] #static link
25 }
26 RTError("dangling reference")
27 fail
28 end
29
30 procedure deref(x)
31 if type(x) ~== "Reference" then return x
32 return x.lst[x.pos]
33 end
34
35 procedure assignThroughRef(x,v)
36 local j
37 if type(x) ~== "Reference" then {
38 RTError("reference needed on left of '<-'")
39 fail
40 }
41 return x.lst[x.pos] := v
42 end
43
44 procedure interpreter()
45 local l,r,t
46 S := list(500)
47 i := 1
48 S[1] := [0,0,0,[]] #outer, empty activation record
49 mp := 1
50 k := 1
51 repeat {
52 if k>*P then return
53 case P[k][1] of {
54 "+": {
55 if not (l:=numeric(S[i-1])) then
56 return RTError("numeric required")
57 if not (r:=numeric(S[i])) then
58 return RTError("numeric required")
59 i -:= 1
60 S[i] := l + r
61 }
62 "-": {
63 if not (l:=numeric(S[i-1])) then
64 return RTError("numeric required")
65 if not (r:=numeric(S[i])) then
66 return RTError("numeric required")
67 i -:= 1
68 S[i] := l - r
69 }
70 "*": {
71 if not (l:=numeric(S[i-1])) then
72 return RTError("numeric required")
73 if not (r:=numeric(S[i])) then
74 return RTError("numeric required")
75 i -:= 1
76 S[i] := l * r
77 }
78 "/": {
79 if not (l:=real(S[i-1])) then
80 return RTError("numeric required")
81 if not (r:=real(S[i])) then
82 return RTError("numeric required")
83 i -:= 1
84 S[i] := l / r
85 }
86 "div": {
87 if not (l:=integer(S[i-1])) then
88 return RTError("numeric required")
89 if not (r:=integer(S[i])) then
90 return RTError("numeric required")
91 i -:= 1
92 S[i] := l / r
93 }
94 "mod": {
95 if not (l:=integer(S[i-1])) then
96 return RTError("numeric required")
97 if not (r:=integer(S[i])) then
98 return RTError("numeric required")
99 i -:= 1
100 S[i] := l % r
101 }
102 "**": {
103 if not (l:=numeric(S[i-1])) then
104 return RTError("numeric required")
105 if not (r:=numeric(S[i])) then
106 return RTError("numeric required")
107 i -:= 1
108 S[i] := l ^ r
109 }
110 "neg": {
111 if not (r:=numeric(S[i])) then
112 return RTError("numeric required")
113 S[i] := - r
114 }
115 "abs": {
116 if not (r:=numeric(S[i])) then
117 return RTError("numeric required")
118 S[i] := abs(r)
119 }
120 "integer": {
121 if not (r:=numeric(S[i])) then
122 return RTError("numeric required")
123 S[i] := integer(r)
124 }
125 "logical": {
126 if not (r:=numeric(S[i])) then
127 return RTError("numeric required")
128 S[i] := if r ~= 0 then True else False
129 }
130 "real": {
131 if type(r:=S[i])~=="Logical" then
132 return RTError("logical required")
133 S[i] := if r === True then 1 else 0
134 }
135 "min": {
136 if not (l:=numeric(S[i-1])) then
137 return RTError("numeric required")
138 if not (r:=numeric(S[i])) then
139 return RTError("numeric required")
140 i -:= 1
141 S[i] := if l < r then l else r
142 }
143 "max": {
144 if not (l:=numeric(S[i-1])) then
145 return RTError("numeric required")
146 if not (r:=numeric(S[i])) then
147 return RTError("numeric required")
148 i -:= 1
149 S[i] := if l > r then l else r
150 }
151 "isn": {
152 r:=deref(S[i])
153 S[i] := if numeric(r) then True else False
154 }
155 "isb": {
156 r:=deref(S[i])
157 S[i] := if type(r)=="Logical" then True else False
158 }
159 "isr": {
160 r:=deref(S[i])
161 S[i] := if type(r)=="Reference" then True else False
162 }
163 "isl": {
164 r:=deref(S[i])
165 S[i] := if type(r)=="Progref" then True else False
166 }
167 "isli": {
168 r:=deref(S[i])
169 S[i] := if type(r)=="list" then True else False
170 }
171 "isy": {
172 r:=deref(S[i])
173 S[i] := if type(r)=="string" then True else False
174 }
175 "isp": {
176 r:=deref(S[i])
177 S[i] := if type(r)=="procDescr" then True else False
178 }
179 "isu": {
180 r:=deref(S[i])
181 S[i] := if /r then True else False
182 }
183 "in": {
184 i+:=1
185 S[i]:=reads()
186 }
187 "out": {
188 r:=deref(S[i])
189 case type(r) of {
190 "Logical": write(r.s)
191 "null": write("undef")
192 "Reference":write("Reference(",image(r.lst),",",r.pos,")")
193 "Progref":write("Program_Reference(",r.mix,",",r.adr,")")
194 "procDescr":write("Procedure_Descriptor(",
195 r.bln,",",r.mix,",",r.adr,")")
196 default: write(r)
197 }
198 }
199 "<=": {
200 if not (l:=numeric(S[i-1])) then
201 return RTError("numeric required")
202 if not (r:=numeric(S[i])) then
203 return RTError("numeric required")
204 i -:= 1
205 S[i] := if l <= r then True else False
206 }
207 "<": {
208 if not (l:=numeric(S[i-1])) then
209 return RTError("numeric required")
210 if not (r:=numeric(S[i])) then
211 return RTError("numeric required")
212 i -:= 1
213 S[i] := if l < r then True else False
214 }
215 ">=": {
216 if not (l:=numeric(S[i-1])) then
217 return RTError("numeric required")
218 if not (r:=numeric(S[i])) then
219 return RTError("numeric required")
220 i -:= 1
221 S[i] := if l >= r then True else False
222 }
223 ">": {
224 if not (l:=numeric(S[i-1])) then
225 return RTError("numeric required")
226 if not (r:=numeric(S[i])) then
227 return RTError("numeric required")
228 i -:= 1
229 S[i] := if l > r then True else False
230 }
231 "=": {
232 i -:= 1
233 S[i] := if S[i] === S[i+1] then True else False
234 }
235 "~=": {
236 i -:= 1
237 S[i] := if S[i] ~=== S[i+1] then True else False
238 }
239 "and": {
240 if type(r:=S[i])~=="Logical" then
241 return RTError("logical required")
242 if r===True then i-:=1
243 else { k:=P[k][2]; next }
244 }
245 "or": {
246 if type(r:=S[i])~=="Logical" then
247 return RTError("logical required")
248 if r===True then { k:=P[k][2]; next }
249 else i-:=1
250 }
251 "~": {
252 if type(r:=S[i])~=="Logical" then
253 return RTError("logical required")
254 S[i] := if r===True then False else True
255 }
256 "then": {
257 if type(r:=S[i])~=="Logical" then
258 return RTError("logical required")
259 i-:=1
260 if r===False then { k:=P[k][2]; next }
261 }
262 "else": {
263 k:=P[k][2]
264 next
265 }
266 "length": {
267 r:=deref(S[i])
268 if type(r)~=="list" then
269 return RTError("list required")
270 S[i] := *r
271 }
272 "tail": {
273 if type(r:=S[i])~=="list" then
274 return RTError("list required")
275 if *r<1 then
276 return RTError("non-empty list required")
277 S[i] := r[2:0]
278 }
279 "&": {
280 if not (type(l:=S[i-1])==type(r:=S[i])=="list") then
281 return RTError("list required")
282 i -:= 1
283 S[i] := l ||| r
284 }
285 "list": {
286 if not (r:=numeric(S[i])) then
287 return RTError("numeric required")
288 S[i] := list(r)
289 }
290 "number"|"logval"|"symbol" : {
291 i +:= 1
292 S[i] := P[k][2]
293 }
294 "undef": {
295 i +:= 1
296 S[i] := &null
297 }
298 "label": {
299 i +:= 1
300 S[i] := progref(P[k][2],P[k][3])
301 }
302 "@": {
303 i +:= 1
304 S[i] := reference(P[k][2],P[k][3])
305 }
306 "new": {
307 put(S[mp][4],&null)
308 }
309 "formal": {
310 fct +:= 1
311 if fct > *S[mp][4] then put(S[mp][4],&null)
312 }
313 "<-": {
314 i -:= 1
315 S[i] := assignThroughRef(S[i],S[i+1]) | fail
316 }
317 ";": {
318 i -:= 1
319 }
320 "]": {
321 if not (r:=numeric(S[i])) then
322 return RTError("numeric required")
323 if r <= 0 then
324 return RTError("subscript must be positive")
325 i -:= 1
326 l := deref(S[i])
327 if type(l)~=="list" then
328 return RTError("list required")
329 if r > *l then return RTError("subscript too large")
330 S[i] := Reference(l,r)
331 }
332 "begin": {
333 i +:= 1
334 S[i] := [S[mp][1]+1,mp,mp,[]]
335 mp := i
336 }
337 "end": {
338 t := S[mp][2]
339 S[mp] := S[i]
340 i := mp
341 mp := t
342 }
343 "proc": {
344 i +:= 1
345 S[i] := procDescr(S[mp][1]+1,mp,k)
346 k := P[k][2]
347 next
348 }
349 "value": {
350 S[i] := t := deref(S[i])
351 if type(t)=="procDescr" then {
352 fct := 0
353 S[i] := [t.bln,mp,t.mix,[],k]
354 mp := i
355 k := t.adr
356 }
357 }
358 "call": {
359 i -:= 1
360 t := deref(S[i])
361 if type(t)~=="procDescr" then
362 return RTError("procedure required")
363 fct := 0
364 S[i] := [t.bln,mp,t.mix,S[i+1],k]
365 mp := i
366 k := t.adr
367 }
368 "endproc": {
369 k := S[mp][5]
370 t := S[mp][2]
371 S[mp] := S[i]
372 i := mp
373 mp := t
374 }
375 "halt": {
376 break
377 }
378 "goto": {
379 if type(S[i])~=="Progref" then
380 return RTError("label required")
381 mp := S[i].mix
382 k := S[i].adr
383 i := mp
384 next
385 }
386 ")": {
387 i +:= 1
388 r := S[i-P[k][2]:i]
389 i -:= P[k][2]
390 S[i] := r
391 }
392 }
393 k+:=1
394 }
395 return
396 end
397
398 procedure RTError(s)
399 stop(k," ",P[k][1]," --- ",s)
400 end
401