|
DataMuseum.dkPresents historical artifacts from the history of: RC4000/8000/9000 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about RC4000/8000/9000 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 26880 (0x6900)
Types: TextFile
Names: »cc «
└─⟦cde9d517b⟧ Bits:30007477 RC8000 Backup tape fra HT's bus-radio system
└─⟦6a563b143⟧
└─⟦this⟧ »cc «
tkermit d.940306.2340
1 begin
2 integer i, mk, state, abort, breakstate, retrycount,
3 incount, inseq, inpackettype, checksum, crc,
4 outcount, outseq, outpackettype, indatacount, outdatacount,
5 packetsize, timeout, numpad, padchar, endchar, startchar,
6 cntrlquote, bit8quote, checktype, repchar,
7 state_ri, state_rf, state_rd, state_si, state_sf, state_sd,
8 state_sz, state_sb, state_c, state_a, state_t, xon, xoff;
9 boolean localecho, series1, xonxoff, waitxon, running, logging,
10 forprinter, activecommandfile, gotsoh, dtrcheck;
11 integer array recvdata, senddata(1:86), tail(1:10), filename(1:4),
12 saveattr(1:8), shd(1:12);
13 long array primary_device(1:2);
14 long array field laf;
15
15 procedure init_kermit;
16 begin
17 integer i;
18
18 i:= 1;
19 state_ri := increase(i);
20 state_rf := increase(i);
21 state_rd := increase(i);
22 state_si := increase(i);
23 state_sf := increase(i);
24 state_sd := increase(i);
25 state_sz := increase(i);
26 state_sb := increase(i);
27 state_c := increase(i);
28 state_a := increase(i);
29 state_t := increase(i);
30 xon:= 'dc1'; xoff:= 'dc3';
31
31 packetsize:= 94;
32 timeout := 60;
33 numpad := 0;
34 padchar := 0;
35 endchar := 'cr';
36 startchar := 'soh';
37 cntrlquote := '#';
38 bit8quote := '&';
39 checktype := '1';
40 repchar := 'nul';
41
41 <* default settings *>
42 gotsoh := false;
43 running := true;
44 end;
45
45 integer procedure tochar(x);
46 value x; integer x;
47 begin
48 tochar:= x+' ';
49 end;
50
50 integer procedure unchar(x);
51 value x; integer x;
52 begin
53 unchar:= x-' ';
54 end;
55
55 integer procedure ctrl(x);
56 value x; integer x;
57 begin
58 ctrl:= (if x>='@' then (x-'@') else (x+'@'));
59 end;
60
60 procedure crc_check(c);
61 value c; integer c;
62 begin
63 integer q;
64
64 c:= c extract 7;
65 q:= exor(crc,c) extract 4;
66 crc:= exor(crc shift (-4),q * 4225);
67 q:= exor(crc,c shift (-4)) extract 4;
68 crc:= exor(crc shift (-4),q * 4225);
69 end;
70
70 procedure timer(z,s,b);
71 zone z; integer s,b;
72 begin
73 if (s extract 1) = 1 then stderror(z,s,b)
74 else
75 begin
76 z(1):= real<:<'em'>:>;
77 b:= 2;
78 end;
79 end;
80
80 zone zin(16,1,timer), zout(16,1,stderror), zf, zh(128,1,stderror);
81
81 boolean procedure readch(c);
82 integer c;
83 begin
84 readchar(zin,c);
85 readch:= c<>'em';
86 end;\f
87 message kermit - packet procedures, page 1;
88
88 <*********************>
89 <* packet procedures *>
90 <*********************>
91
91 procedure send_packet;
92 begin
93 integer i, sum, checkbytes, achar, ochar;
94 boolean soh_echo;
95
95 soh_echo:= -,(localecho or series1);
96 achar:= 0;
97
97 if waitxon then
98 while achar<>xon do if -,readch(achar) then achar:=xon;
99 waitxon:= xonxoff;
100
100 setposition(zin,0,0); <* throw away all previous incomming data *>
101 sum:= crc:= 0;
102 checkbytes:= 1;
103
103 if (outpackettype='S') or (outpackettype='I') or
104 ( inpackettype='S') or ( inpackettype='I') or
105 ( inpackettype='R')
106 then <* leave checkbytes = 1 *>
107 else
108 if checktype='2' then checkbytes:= 2 else
109 if checktype='3' then checkbytes:= 3 ;
110
110 outchar(zout,startchar); setposition(zout,0,0); <* SOH *>
111 if soh_echo then <* wait for soh to be echoed back *>
112 while achar<>startchar do if -,readch(achar) then achar:=startchar;
113
113 outcount:= outdatacount + 2 + checkbytes;
114
114 ochar:= tochar(outcount); <* COUNT *>
115 outchar(zout,ochar);
116 sum:= sum+ochar; crc_check(ochar);
117 ochar:= tochar(outseq); <* SEQ *>
118 outchar(zout,ochar);
119 sum:= sum+ochar; crc_check(ochar);
120 ochar:= tochar(outpackettype); <* TYPE *>
121 outchar(zout,ochar);
122 sum:= sum+ochar; crc_check(ochar);
123 if outdatacount > 0 then
124 for i:= 1 step 1 until outdatacount do
125 begin
126 læstegn(senddata,i+0,ochar); <* DATA *>
127 outchar(zout,ochar);
128 sum:= sum+ochar; crc_check(ochar);
129 end;
130
130 if checkbytes = 1 then
131 begin
132 checksum:= (sum + (sum shift (-6) extract 2)) extract 7;
133 outchar(zout,tochar(checksum));
134 end
135 else
136 if checkbytes = 2 then
137 begin
138 checksum:= sum shift (-6) extract 6;
139 outchar(zout,tochar(checksum));
140 checksum:= sum extract 6;
141 outchar(zout,tochar(checksum));
142 end
143 else
144 if checkbytes = 3 then
145 begin
146 outchar(zout,tochar(crc shift (-12) extract 4));
147 outchar(zout,tochar(crc shift (-6) extract 6));
148 outchar(zout,tochar(crc extract 6));
149 end;
150
150 outchar(zout,endchar);
151
151 if numpad > 0 then
152 for i:= 1 step 1 until numpad do outchar(zout,padchar);
153
153 setposition(zout,0,0);
154 end; <* procedure send_packet *>
155
155 boolean procedure recv_packet;
156 begin
157 integer i, sum, resends, inchar, checkbytes;
158 boolean dummy;
159
159 recvpacket:= false;
160
160 if got_soh then
161 begin
162 inchar:= startchar; got_soh:= false;
163 end
164 else
165 inchar:= ' ';
166
166 while inchar<>startchar do <* SOH *>
167 if -, readch(inchar) then goto exit;
168
168 sum:= crc:= 0;
169
169 if -, readch(inchar) then goto exit; <* COUNT *>
170 sum:= sum+inchar;
171 crc_check(inchar);
172 incount:= unchar(inchar);
173
173 if -, readch(inchar) then goto exit; <* SEQ *>
174 sum:= sum+inchar;
175 crc_check(inchar);
176 inseq:= unchar(inchar);
177
177 if -, readch(inchar) then goto exit; <* TYPE *>
178 sum:= sum+inchar;
179 crc_check(inchar);
180 inpackettype:= inchar;
181 checkbytes:= 1;
182 if (outpackettype='S') or
183 ( inpackettype='S') or
184 ( inpackettype='I') or
185 ( inpackettype='R')
186 then
187 else
188 if checktype='2' then checkbytes:= 2 else
189 if checktype='3' then checkbytes:= 3 ;
190
190 indatacount:= incount - 2 - checkbytes;
191 if indatacount > 0 then
192 for i:= 1 step 1 until indatacount do
193 begin
194 if -, readch(inchar) then goto exit; <* DATA *>
195 sum:= sum+inchar;
196 crc_check(inchar);
197 skrivtegn(recvdata,i+0,inchar);
198 end;
199
199 recv_packet:= true;
200
200 if checkbytes = 1 then
201 begin
202 checksum:= (sum + (sum shift (-6) extract 2)) extract 7;
203 if -,readch(inchar) then
204 else if inchar<>tochar(checksum) then recv_packet:= false;
205 end
206 else
207 if checkbytes = 2 then
208 begin
209 checksum:= sum shift (-6) extract 6;
210 if -,readch(inchar) then
211 else if inchar<>tochar(checksum) then recv_packet:= false;
212 checksum:= sum extract 6;
213 if -,readch(inchar) then
214 else if inchar<>tochar(checksum) then recv_packet:= false;
215 end
216 else
217 if checkbytes = 3 then
218 begin
219 checksum:= crc shift (-12) extract 4;
220 if -,readch(inchar) then
221 else if inchar<>tochar(checksum) then recv_packet:= false;
222 checksum:= crc shift (-6) extract 6;
223 if -,readch(inchar) then
224 else if inchar<>tochar(checksum) then recv_packet:= false;
225 checksum:= crc extract 6;
226 if -,readch(inchar) then
227 else if inchar<>tochar(checksum) then recv_packet:= false;
228 end;
229 exit:
230 end; <* procedure recv_packet *>
231
231 procedure decode_file(z);
232 zone z;
233 begin
234 integer pos, ch, repcount, bit8;
235
235 pos:= 1;
236 while pos <= indatacount do
237 begin
238 læstegn(recvdata,pos,ch);
239
239 if ch=repchar then
240 begin
241 læstegn(recvdata,pos,ch);
242 repcount:= unchar(ch);
243 læstegn(recvdata,pos,ch);
244 end
245 else
246 repcount:= 1;
247
247 if ch=bit8quote then
248 begin
249 bit8:= 128;
250 læstegn(recvdata,pos,ch);
251 end
252 else
253 bit8:= 0;
254
254 if ch=cntrlquote then
255 begin
256 læstegn(recvdata,pos,ch);
257 ch:= cntrl(ch);
258 end;
259
259 ch:= (ch mod 128) + bit8;
260
260 for i:= 1 step 1 until repcount do
261 outchar(z,ch);
262 end;
263 end; <* procedure decode_file *>
264
264 integer procedure decode_data(buf);
265 integer array buf;
266 begin
267 integer pos, p, ch, repcount, bit8;
268
268 pos:= 1;
269 p:=1;
270 while pos <= indatacount do
271 begin
272 læstegn(recvdata,pos,ch);
273
273 if ch=repchar then
274 begin
275 læstegn(recvdata,pos,ch);
276 repcount:= unchar(ch);
277 læstegn(recvdata,pos,ch);
278 end
279 else
280 repcount:= 1;
281
281 if ch=bit8quote then
282 begin
283 bit8:= 128;
284 læstegn(recvdata,pos,ch);
285 end
286 else
287 bit8:= 0;
288
288 if ch=cntrlquote then
289 begin
290 læstegn(recvdata,pos,ch);
291 ch:= cntrl(ch);
292 end;
293
293 ch:= (ch mod 128) + bit8;
294
294 for i:= 1 step 1 until repcount do
295 skrivtegn(buf,p,ch);
296 end;
297
297 decode_data:= p-1;
298 repeat skrivtegn(buf,p,0) until (p mod 6)=1;
299 end; <* procedure decode_data *>
300
300 procedure encode_data(buf);
301 integer array buf;
302 begin
303 integer i, pos, p, ch;
304
304 pos:= 1; p:=1;
305 while ((p-1)<packetsize-3-4) and (læstegn(buf,pos,ch) extract 12 <> 0) do
306 begin
307 if ch >= 128 then
308 skrivtegn(senddata,p,bit8quote);
309 ch:= ch mod 128;
310 if ch<' ' or ch='del' then
311 begin
312 skrivtegn(senddata,p,cntrlquote);
313 skrivtegn(senddata,p,cntrl(ch));
314 else
315 if ch=bit8quote or ch=cntrlquote then
316 begin
317 skrivtegn(senddata,p,cntrlquote);
318 skrivtegn(senddata,p,ch);
319 end
320 else
321 skrivtegn(senddata,p,ch);
322 end;
323 outdatacount:= p-1;
324 end; <* procedure encode_data *>
325
325 procedure resendit(retries);
326 value retries; integer retries;
327 begin
328 retry_count:= retrycount+1;
329 if retries > 0 then
330 begin
331 send_packet;
332 if recv_packet then
333 begin
334 if inpackettype='Y' then else
335 if inpackettype='N' then resendit(retries-1)
336 else state:= state_a; <* Abort *>
337 end
338 else
339 state:= state_a; <* Abort *>
340 end
341 else
342 state:= state_a; <* Abort *>
343 end; <* procedure resendit *>
344
344 procedure send_packettype(packettype,seq);
345 value packettype; integer packettype, seq;
346 begin
347 integer saveseq;
348
348 <* send Ack or Nak or B or Z *>
349 saveseq:= outseq;
350 outseq:= seq;
351 outdatacount:= 0;
352 outpackettype:= packettype;
353 sendpacket;
354 outseq:= saveseq;
355 end; <* procedure send_packettype *>
356
356 procedure send_msg_packet(packettype,msg,seq);
357 value packettype, seq; integer packettype, seq;
358 string msg;
359 begin
360 integer array buf;
361
361 puttext(buf,1,msg);
362 outpackettype:= packettype;
363 outseq:= seq;
364 encode_data(buf);
365 sendpacket;
366 end; <* procedure send_msg_packet *>
367
367 procedure putinitpacket;
368 begin
369 <* put parameters into initpacket *>
370 outdatacount:= 9;
371 outseq:= 0;
372 skrivtegn(senddata,1,tochar(packetsize));
373 skrivtegn(senddata,2,tochar(timeout));
374 skrivtegn(senddata,3,tochar(numpad));
375 skrivtegn(senddata,4,tochar(padchar));
376 skrivtegn(senddata,5,tochar(endchar));
377 skrivtegn(senddata,6,cntrlquote);
378 skrivtegn(senddata,7,bit8quote);
379 skrivtegn(senddata,8,checktype);
380 skrivtegn(senddata,9,repchar);
381 if bit8quote=0 then outdatacount:= 6 else
382 if checktype=0 then outdatacount:= 7 else
383 if repchar=0 then outdatacount:= 8 ;
384 end; <* procedure putinitpacket *>
385
385 procedure getinitpacket;
386 begin <* get init parameters *>
387 integer ch;
388
388 if indatacount >=1 then læstegn(recvdata,1,ch); packetsize:= unchar(ch);
389 if indatacount >=2 then læstegn(recvdata,2,ch); timeout:= unchar(ch);
390 if indatacount >=3 then læstegn(recvdata,3,ch); numpad:= unchar(ch);
391 if indatacount >=4 then læstegn(recvdata,4,ch); padchar:= unchar(ch);
392 if indatacount >=5 then læstegn(recvdata,5,ch); endchar:= unchar(ch);
393 if indatacount >=6 then læstegn(recvdata,6,cntrlquote);
394 if indatacount >=7 then
395 begin
396 læstegn(recvdata,7,bit8quote);
397 if bit8quote='Y' then bit8quote:= '&';
398 if (bit8quote < '!') or ('ü' < bit8quote) or
399 ('?' < bit8quote and bit8quote < '`') then bit8quote:= 0;
400 end
401 else bit8quote:= 0;
402 if indatacount >=8 then
403 begin
404 læstegn(recvdata,8,checktype);
405 if -,('1' <= checktype and checktype <= '3') then checktype:= '1';
406 end
407 else checktype:= '1';
408 if indatacount >=9 then
409 begin
410 læstegn(recvdata,9,repchar);
411 if (repchar < '!') or ('ü' < repchar) or
412 ('?' < repchar and repchar < '`') then repchar:= 0;
413 end
414 else repchar:= 0;
415 end; <* procedure getinitpacket *>
416
416 <*--------------- end of packet procedures ---------------*>\f
417
417 message kermit - main body, page 1;
418
418 <**************** start of main program body ****************>
419 trap(exit);
420
420 laf:= 0;
421 system(7,mk,primary_device);
422 open(zin,mk,primary_device,1 shift 21);
423 open(zout,mk,primaty_device,0);
424
424 <* lookup termial attributes *>
425 open(zh,0,primary_device,0);
426 getshare6(zh,shd,1);
427 shd(1):= 1;
428 shd(4):= 134 shift 12;
429 for i:= 5 step 1 until 11 do shd(i):= 0;
430 setshare6(zh,shd,1);
431 monitor(16)send_message:(zh,1,shd);
432 monitor(18)wait_answer:(zh,1,saveattr);
433
433 <* set tiomeoutvalue and echo off *>
434 getshare6(zh,shd,1);
435 shd(1):= 1;
436 shd(4):= 132 shift 12;
437 for i:= 5 step 1 until 11 do shd(i):= saveattr(i-3);
438 shd(5):= shd(5) shift 1 shift (-1);
439 setshare6(zh,shd,1);
440 monitor(16)send_message:(zh,1,shd);
441 monitor(18)wait_answer:(zh,1,shd);
442 close(zh,false);
443
443 init_kermit;
444
444 state:= state_ri;
445 retry_count:= 0;
446 outseq:= 0;
447 <* main loop *>
448 while running do
449 case state of
450 begin
451 <* 1 : Recv_Init *>
452 begin
453 if -, recv_packet then
454 begin
455 increase(retry_count);
456 if retry_count > retry_limit then
457 begin
458 send_msg_packet('E',<:Retrylimit exeeded:>,0);
459 goto exit;
460 end
461 else
462 send_packettype('N',0);
463 end
464 else
465 if (inpackettype='I' or inpackettype='S') and inseq=0 then
466 begin
467 getinitparam;
468 outpackettype:= 'Y';
469 putinitpacket;
470 sendpacket;
471 if inpackettype='S' then
472 begin
473 outseq:= (outseq+1) mod 64; retry_count:= 0;
474 state:= state_rf;
475 end;
476 end
477 else
478 if inpackettype='R' then
479 begin
480 decode_data(filename);
481 state:= state_si;
482 end
483 else
484 begin
485 send_msg_packet('E',<:Packet Type Error:>,0);
486 end;
487 end; <* state_ri *>
488
488 <* 2 : Recv_File *>
489 begin
490 if -, recv_packet then
491 begin
492 increase(retry_count);
493 if retry_count > retry_limit then
494 begin
495 send_msg_packet('E',<:Retrylimit exeeded:>,0);
496 goto exit;
497 end
498 else
499 send_packettype('Y',(out_seq+63) mod 64);
500 end
501 else
502 if inpackettype='F' and inseq=outseq then
503 begin
504 decode_data(filename);
505 open(zf,4,<::>,0);
506 for i:= 1 step 1 until 10 do tail(i):= 0;
507 tail(1):= 1;
508 if monitor(40,zf,0,tail)=0 and monitor(52,zf,0,tail)=0 then
509 begin
510 send_packettype('Y',outseq);
511 outseq:= (outseq+1) mod 64; retry_count:= 0;
512 state:= state_rd;
513 end
514 else
515 begin
516 close(zf,true);
517 send_msg_packet('E',<:Cannot create file:>,outseq);
518 state:= state_a;
519 end;
520 end
521 else
522 if inpackettype='B' and inseq=outseq then
523 begin
524 send_packettype('Y',outseq);
525 state:= state_c;
526 end
527 else
528 if inpackettype='S' and ((inseq+1) mod 64)=outseq then
529 begin
530 increase(retry_count);
531 if retry_count > retry_limit then
532 begin
533 send_msg_packet('E',<:Retrylimit exeeded:>,0);
534 goto exit;
535 end
536 else
537 begin
538 putinitpacket;
539 outpackettype:='Y';
540 outseq:= inseq;
541 sendpacket;
542 outseq:= (outseq+1) mod 64;
543 end;
544 end
545 else
546 if inpackettype='Z' and ((inseq+1) mod 64)=outseq then
547 begin
548 increase(retry_count);
549 if retry_count > retry_limit then
550 begin
551 send_msg_packet('E',<:Retrylimit exeeded:>,0);
552 goto exit;
553 end
554 else
555 send_packettype('Y',inseq);
556 end
557 else
558 begin
559 send_msg_packet('E',<:Protocol Error:>,outseq);
560 state:= state_a;
561 end;
562 end; <* state_RF *>
563
563 <* 3 : Recv_Data *>
564 begin
565 if -, recv_packet then
566 begin
567 increase(retry_count);
568 if retry_count > retry_limit then
569 begin
570 close(zf,true);
571 monitor(48)remove_entry:(zf,0,tail);
572 send_msg_packet('E',<:Retrylimit exeeded:>,outseq);
573 state:= state_a;
574 end
575 else
576 send_packettype('Y',(out_seq+63) mod 64);
577 end
578 else
579 if inpackettype='D' and inseq=outseq then
580 begin
581 decode_file(zf);
582 send_packettype('Y',outseq);
583 outseq:= (outseq+1) mod 64; retry_count:= 0;
584 end
585 else
586 if inpackettype='D' and ((inseq+1) mod 64)=outseq then
587 begin
588 increase(retry_count);
589 if retry_count > retry_limit then
590 begin
591 close(zf,true);
592 monitor(48)remove_entry:(zf,0,tail);
593 send_msg_packet('E',<:Retrylimit exeeded:>,0);
594 state:= state_a;
595 end
596 else
597 send_packettype('Y',inseq);
598 end
599 else
600 if inpackettype='Z' and inseq=outseq and indatacount=0 then
601 begin
602 close(zf,true);
603 i:= monitor(46)rename_entry:(zf,0,filename);
604 if i=3 then
605 begin
606 open(zh,4,filename,0); close(zh,true);
607 i:= monitor(48)remove_entry:(zh,0,tail);
608 if i=0 then i:=monitor(46)rename_entry:(zf,0,filename);
609 end;
610 if i=0 then
611 begin
612 send_packettype('Y',outseq);
613 outseq:= (outseq+1) mod 64; retry_count:= 0;
614 state:= state_rf;
615 end
616 else
617 begin
618 close(zf,true);
619 monitor(48)remove_entry:(zf,0,tail);
620 send_msg_packet('E',<:File Receive Error:>,outseq);
621 state:= state_a;
622 end;
623 end
624 if inpackettype='Z' and inseq=outseq and
625 indatacount > 0 and læstegn(recvdata,1,i) extract 12 = 'D'
626 then
627 begin
628 close(zf,true);
629 monitor(48)remove_entry:(zf,0,tail);
630 send_packettype('Y',outseq);
631 outseq:= (outseq+1) mod 64; retry_count:= 0;
632 state:= state_rf;
633 end
634 else
635 if inpackettype='F' and ((inseq+1) mod 64)=outseq then
636 begin
637 increase(retry_count);
638 if retry_count > retry_limit then
639 begin
640 close(zf,true);
641 monitor(48)remove_entry:(zf,0,tail);
642 send_msg_packet('E',<:Retrylimit exeeded:>,0);
643 goto exit;
644 end
645 else
646 send_packettype('Y',inseq);
647 end
648 else
649 begin
650 close(zf,true);
651 monitor(48)remove_entry:(zf,0,tail);
652 send_msg_packet('E',<:Protocol Error:>,outseq);
653 state:= state_a;
654 end;
655 end; <* state_RD *>
656
656 <* 4 : state Send_Init *>
657 begin
658 end; <* state_SI *>
659
659 <* 5 : state Send_File *>
660 begin
661 end; <* state_SF *>
662
662 <* 6 : state Send_Data *>
663 begin
664 end; <* state_SD *>
665
665 <* 7 : state Send_EOF *>
666 begin
667 end; <* state_SZ *>
668
668 <* 8 : state Send_Break *>
669 begin
670 end; <* state_SB *>
671
671 <* 9 : state Complete *>
672 begin
673 init_kermit;
674 retry_count:= outseq:= 0;
675 state:= state_ri;
676 end; <* state_C *>
677
677 <* 10 : state Abort *>
678 begin
679 init_kermit;
680 retry_count:= outseq:= 0;
681 state:= state_ri;
682 end; <* state_A *>
683
683 <* 11 : state Terminate *>
684 begin
685 running:= false;
686 end;
687 end; <* case state - main loop *>
688
688 exit:
689 <* reset terminal attributes *>
690 getshare6(zin,shd,1);
691 for i:= 1 step 1 until 8 do
692 shd(3+i):= saveattr(i);
693 shd(4):= 132 shift 12;
694 setshare6(zin,shd,1);
695 monitor(16)send_message:(zin,1,shd);
696 monitor(18)wait_answer:(zin,1,shd);
697
697 close(zin,true);
698 close(zout,true);
699 end
\f
6. line 257 . 2 undeclared
line 291 . 2 undeclared
line 313 . 4 undeclared
line 314 . 0 termination
line 325 . 0 delimiter
line 326 . 0 delimiter
line 326 . 1 delimiter
line 329 . 1 undeclared
line 335 . 3 undeclared
line 344 . 0 delimiter
line 345 . 0 delimiter
line 345 . 1 delimiter
line 350 . 2 undeclared
line 352 . 2 undeclared
line 356 . 0 delimiter
line 357 . 0 delimiter
line 357 . 2 delimiter
line 358 . 0 delimiter
line 360 . 1 delimiter
line 361 . 1 undeclared
line 361 . 4 undeclared
line 362 . 2 undeclared
line 363 . 2 undeclared
line 367 . 0 delimiter
line 385 . 0 delimiter
line 423 . 4 undeclared
line 456 . 2 undeclared
line 458 . 1 undeclared
line 462 . 1 undeclared
line 467 . 1 undeclared
line 469 . 1 undeclared
line 634 . 0 termination
algol end 63
▶EOF◀