summaryrefslogtreecommitdiff
path: root/system/base/unknown/src/dateieditorpaket
blob: 8aedb2d52f8c96a2b1e52ef071241da9a2b649ea (plain)
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
 
PACKET  d a t e i e d i t o r  paket  DEFINES     (* Autor: P.Heyderhoff *)
        (*******************)                     (* Stand: 19.02.82     *)
                                                  (* Vers.: 1.6.0        *)
        define escape ,
        dateieditor :
 
LET satzmax = 4075, dateianker = 2, left = ""8"", escape = ""27"",
    hop = ""1"", right = ""2"", hoechstes steuerzeichen = ""31"", 
    clear = ""1""4"", hop and mark = ""1""15"", code f = "f",
    clear line mark = ""5""14"", bell = ""7"", freianker = 1, down = ""10"",
    begin mark = ""15"", end mark = ""14"", escape escape = ""27""27"",
    clear eol and mark = ""5""15"";
 
LET DATEI = ROW satzmax STRUCT (INT nachfolger, vorgaenger, index,
                                    fortsetzung, TEXT inhalt);
FOR j FROM 1 UPTO 127 REP escapefkt (j) := "" PER;
INT  VAR j, haltzeile :: satzmax, symboltyp, typ,
         zahlwert, stelle, satz, marke, maxbildlaenge :: 23;
FILE VAR sekundaerfile ;
TEXT VAR zeichen :: "", ersatz   :: "", kommando :: "",
         symbol  :: "", textwert :: "", lernsequenz::"";
BOOL VAR war fehler, boolwert;
LET op1namen = 
";+;-;BEGIN;COL;GET;HALT;LIMIT;MARK;PUT;IF;NOT;REPEAT;WRITE;SIZE"; 
LET b =  5, c = 11, g = 15, h = 19, l = 24, m = 30,
    p = 35, i = 39, n = 42, r = 46, w = 53, s=59;
LET op2namen = "&+&-&*&/&;&CHANGETO;&OR"; 
LET plus = 1, minus = 3, mal = 5, durch = 7, semicolon = 9,
    changecode = 11, or = 21;
LET proznamen = ";col;row;halt;limit;mark;len;eof;";
LET pcol =  1, prow  =  5, phalt =  9, plimit = 14, pmark = 20,
    plen = 25, peof  = 29;
LET void      =  0,    (* keine angabe des typs      *)
    tag       =  1,    (* typ: lower case letter     *)
    bold      =  2,    (* typ: upper case letter     *)
    integer   =  3,    (* typ: digit                 *)
    texttyp   =  4,    (* typ: quote                 *)
    operator  =  5,    (* typ: operator +-*=<> ** := *)
    delimiter =  6,    (* typ: delimiter ( ) , ; .   *)
    eol       =  7,    (* typ: niltext, Zeilenende   *)
    bool      =  8;    (* typ: boolean               *)
LET varimax   = 10;
INT VAR freivar :: 1;
ROW varimax INT  VAR varzahlwert, vartyp;
ROW varimax TEXT VAR vartextwert, varname;
FOR j FROM 1 UPTO varimax
REP vartextwert (j) := ""; varname (j) := "" PER;
 
ROW 127 TEXT VAR escapefkt;
 
 
(*************************  d a t e i e d i t o r  *************************)
 
PROC dateieditor (DATEI VAR datei) :
 
  INTERNAL 295 ;
 
  REP   datei editieren
  UNTIL (feldkommando SUB 1) <> escape
  PER .
 
datei editieren :
  war fehler := FALSE ;
  zeichen := feldkommando SUB 2;
  IF   zeichen = "q" OR zeichen = "w"
  THEN LEAVE dateieditor
  ELIF zeichen = escape
  THEN kommando ermitteln
  ELSE tastenkommando ermitteln ;    (* Li 19.1.82 *)
       abbruchtest;
       feldkommando (subtext (feldkommando, 3))
  FI;
  a u s f u e h r e n .
 
tastenkommando ermitteln :
  IF zeichen > ""0"" AND zeichen < ""128""
    THEN kommando := escapefkt (code (zeichen)) (* Li 06.01.82 *)
    ELSE kommando := ""
  FI .

abbruchtest :
  IF   is incharety (escape)
  THEN fehler bearbeiten
  FI .
 
kommando ermitteln :
  IF   (feldkommando SUB 1) = hop
  THEN lernsequenz auf taste legen;
       feldkommando (subtext (feldkommando, 4));
       LEAVE datei editieren
  FI;
  feldkommando (subtext (feldkommando, 3));
  kommando := ""; dialog; analysieren .
 
dialog:
  REP   kommandodialog;
        IF   (feldzeichen SUB 1) <> escape OR kommando <> "?"
        THEN LEAVE dialog
        ELIF (feldzeichen SUB 2) > ""0"" THEN   (* Li 19.02.82 *)
        kommando := escapefkt (code (feldzeichen SUB 2) MOD 128 )
        ELSE kommando := ""
        FI
  PER .
 
lernsequenz auf taste legen :
  lernsequenz := feldaudit;
  lernsequenz := subtext (lernsequenz, 1, LENGTH lernsequenz - 3);
  INT CONST lerncode := code (feldkommando SUB 3) MOD 128 ;
  escapefkt (lerncode) := "W""" ;
  escapefkt (lerncode) CAT lernsequenz ;          (* Li 5.1.81 *)
  escapefkt (lerncode) CAT """" .
 
kommandodialog :
  INT CONST feldlaenge :: max (feldende-feldanfang-21, 6) ;
  cursor (feldrand+1, bildrand+bildzeile+1);
  out (begin mark, "gib editor kommando: "); 
  feldlaenge TIMESOUT "."; out(end mark);
  bildneu (TRUE);
  cursor (feldrand+23, bildrand+bildzeile+1); feldseparator (escape);
  editget (kommando, 255, feldlaenge); feldseparator ("") .
 
analysieren :
  IF   (feldzeichen SUB 1) = escape AND (feldzeichen SUB 2) > ""0"" (*02.82*)
  THEN escapefkt (code (feldzeichen SUB 2) MOD 128) := kommando; (* Li 5.1.*)
       LEAVE datei editieren
  ELIF kommando = ""
  THEN LEAVE datei editieren
  ELIF (kommando SUB 1) = "?"
  THEN kommandos erklaeren;
       LEAVE datei editieren
  ELIF pos ("quit", kommando) = 1
  THEN feldkommando (escape escape);
       LEAVE dateieditor
  ELSE escapefkt (code (code f)) := kommando 
  FI .
 
ausfuehren : 
  haltzeile := satzmax;
  IF   kommando = ""
  THEN zeile unveraendert
  ELSE scan (kommando); nextsymbol;
       IF   a u s d r u c k  (datei)
       THEN IF symboltyp <> eol THEN fehler bearbeiten FI
       FI;
       IF war fehler THEN inchar (zeichen)  (* warten *)  FI
   FI .
 
kommandos erklaeren : 
  out (clear); 
  putline ("kommandos fuer den benutzer :"); line;
  putline ("quit      : beendet das editieren");
  putline ("  n       : positioniert auf zeile n");
  putline ("+ n       : blaettert n zeilen vorwaerts");
  putline ("- n       : blaettert n zeilen rueckwaerts");
  putline (" ""z""      : sucht angegebene zeichenkette ");
  putline ("""muster"" CHANGETO ""ersatz"" :");
  putline ("            muster wird durch ersatz ersetzt"); 
  putline ("HALT   n  : sieht anhalten des suchens in zeile n vor");
  putline ("GET   ""d"" : kopiert datei d und markiert");
  putline ("PUT   ""d"" : schreibt markierten abschnitt in datei d");
  putline ("LIMIT  n  : setzt schreibende auf spalte n");
  putline ("BEGIN  n  : setzt feldanfang auf spalte n");
  putline ("SIZE   n  : setzt bildlaenge auf n"); line;
  putline ("?ESCx     : zeigt kommando auf escapetaste x");
  inchar (zeichen) .
 
END PROC dateieditor; 
 
PROC define escape (TEXT CONST cmd char, kommando) :
  escapefkt (code (cmd char) MOD 128) := kommando
END PROC define escape ;
 
 
(********************  h i l f s - p r o z e d u r e n  ********************)
 
PROC fehler bearbeiten :
  IF NOT war fehler
  THEN war fehler := TRUE; bildneu (TRUE);
       out (""2""2""2"  kommandofehler bei ",symbol," erkannt.");
       out (clear line mark)
  FI
END PROC fehler bearbeiten;
 
BOOL PROC fehler : fehler bearbeiten; FALSE END PROC fehler;
 
BOOL PROC klammerzu :
  IF   symbol = ")"
  THEN nextsymbol; TRUE
  ELSE fehler
  FI
END PROC klammerzu;
 
PROC nextsymbol :
  nextsymbol (symbol, symboltyp);
  IF symboltyp = eol THEN symbol := "kommandoende" FI
END PROC nextsymbol;
 
PROC eof (DATEI VAR datei) :
  boolwert := (bildstelle = dateianker); typ := void
END PROC eof;
 
PROC nachsatz (DATEI CONST datei) :
  stelle := datei (stelle).nachfolger;
  satz INCR 1; protokoll
END PROC nachsatz;
 
PROC vorsatz  (DATEI CONST datei) :
  stelle := datei (stelle).vorgaenger;
  satz DECR 1; protokoll
END PROC vorsatz;
 
 
PROC protokoll :
  cout (satz) ;
  IF   is incharety (escape)
  THEN fehler bearbeiten
  FI .
END PROC protokoll;
 
 
(*******************  s p r i n g e n  und  s u c h e n  *******************)
 
PROC row (DATEI VAR datei) : 
  IF ziel voraus THEN vorwaerts springen ELSE rueckwaerts springen FI;
  bildsatz (satz); bildstelle (stelle); typ := void; bildneu (TRUE) .
 
ziel voraus :
  satz := bildsatz; stelle := bildstelle;
  IF   zahlwert > satz
  THEN TRUE
  ELIF zahlwert <= satz DIV 2 AND bildmarke = 0
  THEN stelle := datei (dateianker).nachfolger; satz := 1; TRUE
  ELSE FALSE
  FI .
 
vorwaerts springen :
  IF zahlwert <= 0
    THEN fehler bearbeiten
  FI ;
  WHILE stelle <> dateianker AND satz < zahlwert
  REP nachsatz (datei) UNTIL war fehler PER;
  IF   stelle = dateianker AND satz > 1 
  THEN vorsatz (datei);
       feldstelle (LENGTH (datei (stelle).inhalt)+1)
  FI .
 
rueckwaerts springen :
  WHILE stelle <> bildmarke  AND satz > zahlwert
  REP vorsatz (datei) UNTIL war fehler PER .
 
END PROC row;
 
PROC search (DATEI VAR datei) :
  stelle := bildstelle;
  IF textwert <> "" THEN contextadressierung FI;
  typ := void .
 
contextadressierung : 
  j := feldstelle - 1; satz := bildsatz;
  WHILE noch nicht gefunden REP nachsatz (datei) UNTIL war fehler PER;
  IF    stelle = dateianker
  THEN  vorsatz (datei);
        feldstelle (LENGTH (datei (stelle).inhalt)+1)
  ELIF  j > 0
  THEN  feldstelle ((LENGTH textwert)+j)
  FI;
  IF    bildstelle <> stelle
  THEN  bildstelle (stelle); bildsatz (satz); bildneu (TRUE)
  FI .
 
noch nicht gefunden : 
  j := pos (datei (stelle).inhalt, textwert, j+1); 
  j = 0 AND stelle <> dateianker AND satz < haltzeile .
 
END PROC search; 
 
 
(********************  vom file holen, in file bringen  ********************)
 
PROC vom file holen (DATEI VAR datei, TEXT VAR textwert) :
  stelle := bildstelle; satz := bildsatz;
  IF   datei eroeffnung korrekt
  THEN IF stelle = dateianker THEN satz erzeugen (datei, stelle) FI;
       zeile auftrennen; file kopieren; kopiertes markieren;
       bildstelle (stelle); bildsatz (satz); bildmarke (marke)
  FI ; textwert := "" .
 
datei eroeffnung korrekt :
  IF   textwert = ""
  THEN sekundaerfile := sequential file (input); NOT eof (sekundaerfile)
  ELIF exists (textwert)
  THEN sekundaerfile := sequential file (input, textwert);
       NOT eof (sekundaerfile) 
  ELSE FALSE
  FI .
 
file kopieren : 
  INT VAR altstelle;
  FOR j FROM 0 UPTO satzmax WHILE NOT eof (sekundaerfile) 
  REP nachsatz (datei); altstelle := stelle;
      satz erzeugen (datei, stelle);
      IF stelle = altstelle THEN LEAVE file kopieren FI; 
      getline (sekundaerfile, inhalt)
  UNTIL war fehler
  PER .
 
zeile auftrennen : 
  marke := stelle; bildmarksatz (satz);
  nachsatz (datei); satz erzeugen (datei, stelle);
  inhalt := subtext (datei (marke).inhalt, feldstelle);
  vorsatz (datei); inhalt := text (inhalt, feldstelle-1) . 
 
kopiertes markieren : 
  nachsatz (datei);
  IF inhalt = "" THEN satz loeschen (datei, stelle) FI;
  vorsatz (datei);
  IF   datei (marke).inhalt = "" 
  THEN satz loeschen (datei, marke); satz DECR 1;
  ELSE marke := datei (marke).nachfolger; bildmarksatz (bildmarksatz+1)
  FI; 
  feldmarke (feldanfang); feldanfangsmarke (feldanfang);
  feldstelle (1+LENGTH inhalt); bildneu (TRUE) .
 
inhalt :
  datei (stelle).inhalt . 
 
END PROC vom file holen; 
 
PROC in file bringen ( DATEI VAR datei, TEXT VAR textwert) :
  neuen sekundaerfile erzeugen;
  marke := bildstelle; stelle := bildmarke; satz := bildmarksatz;
  IF   stelle = marke 
  THEN IF   feldmarke <> feldstelle
       THEN putline (sekundaerfile,
                     subtext (inhalt, feldmarke, feldstelle-1)) 
       FI
  ELSE IF   feldanfangsmarke <= LENGTH inhalt
       THEN putline (sekundaerfile, subtext (inhalt, feldanfangsmarke))
       FI;  schreiben;
       IF   feldstelle > feldanfang 
       THEN putline (sekundaerfile, subtext (inhalt, 1, feldstelle-1)) 
       FI
  FI .
 
schreiben: 
  REP nachsatz (datei);
      IF stelle = marke OR war fehler THEN LEAVE schreiben FI;
      putline (sekundaerfile, inhalt) 
  PER .
 
neuen sekundaerfile erzeugen : 
  IF   textwert = ""
    THEN sekundaerfile := sequential file (output) ;
    ELSE IF   exists (textwert) 
         THEN forget (textwert)
         FI;
         IF   exists (textwert)
         THEN LEAVE in file bringen
         FI;
         sekundaerfile := sequential file (output, textwert)
  FI .
 
inhalt :
  datei (stelle).inhalt . 
 
END PROC in file bringen; 
 
 
(*************************  i n t e r p r e t e r  *************************)
 
BOOL PROC primary (DATEI VAR datei) : 
 
  SELECT symboltyp OF
    CASE integer :
         IF   LENGTH symbol <= 4            (* Li 20.01.82 *)
         THEN zahlwert := int (symbol);
              typ := symboltyp;
              nextsymbol; TRUE
         ELSE fehler
         FI
    CASE texttyp :
         textwert := symbol; typ := symboltyp; nextsymbol; TRUE
    CASE delimiter :
         IF   symbol = "("
         THEN nextsymbol;
              IF ausdruck (datei) THEN klammerzu ELSE fehler FI
         ELSE fehler
         FI
    CASE tag :
         INT CONST pcode :: pos (proznamen, ";" + symbol + ";");
         IF   pcode = 0
         THEN is variable
         ELSE nextsymbol; prozedurieren
         FI
    CASE bold, operator :
         INT CONST op1code :: pos (op1namen, ";" + symbol);
         IF   op1code = 0
         THEN fehler
         ELIF op1code = r                   (* Li 12.01.81 *)
         THEN wiederholung (datei)
         ELSE nextsymbol ;
              IF primary (datei)
              THEN operieren 
              ELSE fehler
              FI
         FI
     OTHERWISE : fehler
   END SELECT .
 
is variable : 
  INT  VAR var :: 1;
  WHILE varname (var) <> symbol AND var <> freivar REP var INCR 1 PER;
  IF   var = freivar
  THEN varname (var) := symbol; nextsymbol;
       IF   symbol = ":="
       THEN deklarieren
       ELSE LEAVE is variable WITH fehler
       FI
  ELSE nextsymbol
  FI;
  IF symbol = ":=" THEN nextsymbol; assignieren ELSE dereferenzieren FI .
 
dereferenzieren :
  typ := vartyp (var); zahlwert := varzahlwert (var);
  textwert := vartextwert (var); TRUE .
 
assignieren :
  IF   primary (datei)
  THEN IF   typ = integer
       THEN varzahlwert (var) := zahlwert
       ELIF typ = texttyp
       THEN vartextwert (var) := textwert
       ELSE fehler bearbeiten
       FI;
       vartyp (var) := typ; typ := void
  ELSE fehler bearbeiten
  FI;
  NOT war fehler .
 
deklarieren :
  IF   freivar = varimax
  THEN fehler bearbeiten
  ELSE freivar INCR 1
  FI .
 
prozedurieren :
  typ := integer;
  SELECT pcode OF 
    CASE pcol   : zahlwert := feldstelle
    CASE plen   : zahlwert := LENGTH (datei (bildstelle).inhalt)
    CASE prow   : zahlwert := bildsatz
    CASE phalt  : zahlwert := haltzeile
    CASE plimit : zahlwert := feldlimit
    CASE pmark  : zahlwert := bildmarke
    CASE peof   : eof (datei) 
    OTHERWISE fehler bearbeiten
  END SELECT;
  NOT war fehler .
 
operieren :
  SELECT op1code OF
    CASE plus  : zahlwert INCR bildsatz; row (datei)
    CASE minus : zahlwert := bildsatz - zahlwert; row (datei)
    CASE b     : begin
    CASE c     : col 
    CASE g     : get 
    CASE h     : halt 
    CASE l     : limit 
    CASE m     : mark
    CASE p     : put
    CASE i     : if 
    CASE w     : write
    CASE s     : size 
    OTHERWISE fehler bearbeiten
  END SELECT;
  typ := void; TRUE .
 
begin : 
  zahlwert := zahlwert MOD 180;
  feldende (feldende+zahlwert-feldanfang); feldanfang (zahlwert) .
 
col :
  zahlwert := zahlwert MOD 256; feldstelle (zahlwert) .
 
get : 
  IF   bildmarke <= 0 AND schreiberlaubnis
  THEN vom file holen (datei, textwert)
  FI .
 
halt :
  haltzeile := zahlwert .
 
limit :
  zahlwert := zahlwert MOD 256; feldlimit (zahlwert) .
 
mark :
  IF   zahlwert = 0
  THEN bildmarke (0); feldmarke (0); bildneu (TRUE) 
  ELSE bildmarke (bildstelle); feldmarke (feldstelle);
       bildmarksatz (bildsatz)
  FI .
 
put : 
  IF bildmarke > 0 THEN in file bringen (datei, textwert) FI .
 
if : 
  IF   bedingung (datei) 
  THEN IF   boolwert 
       THEN IF   pos ("THEN", symbol) = 1 
            THEN nextsymbol;
                 IF   ausdruck (datei)
                 THEN skip elseteil
                 ELSE fehler bearbeiten
                 FI 
            ELSE fehler bearbeiten
            FI
       ELSE skip thenteil; 
            IF   j = 1
            THEN elseteil
            ELIF j <> 5
            THEN fehler bearbeiten
            FI
       FI
  ELSE fehler bearbeiten
  FI .
 
elseteil :
  IF   ausdruck (datei)
  THEN IF symbol = "FI" THEN nextsymbol ELSE fehler bearbeiten FI
  FI .
 
skip elseteil : 
  WHILE symboltyp <> eol AND pos ("FI", symbol) <> 1 REP nextsymbol PER; 
  nextsymbol .
 
skip thenteil : 
  WHILE (symboltyp <> eol) AND nicht elsefi REP nextsymbol PER; 
  nextsymbol .
 
nicht elsefi : 
  j := pos ("ELSEFI", symbol); j = 0 . 
 
write :
  feldkommando (textwert); zeile unveraendert .
 
size :
  IF   bildlaenge > maxbildlaenge
  THEN maxbildlaenge := bildlaenge
  FI;
  bildlaenge (max (1, min (zahlwert, maxbildlaenge)));
  bildzeile  (min (bildzeile, bildlaenge)); 
  bildrand (0); bildneu (TRUE); page .
 
END PROC primary; 
 
 
(***********  w i e d e r h o l u n g ,   b e d i n g u n g  ***************)
 
BOOL PROC wiederholung (DATEI VAR datei) : 
 
  fix scanner ;              (* Li 12.01.81 *)
  wiederholt interpretieren;
  skip endrep; typ := void;
  NOT war fehler .
 
wiederholt interpretieren :
  REP reset scanner; nextsymbol;           (* 12.01.81 *)
      WHILE ausdruck (datei) REP UNTIL until PER; abbruchtest
  UNTIL ende der wiederholung
  PER .
 
until : 
  IF   pos ("UNTIL", symbol) = 1
  THEN nextsymbol;
       IF   primary (datei) THEN FI;
       IF   bedingung (datei) 
       THEN IF   boolwert
            THEN LEAVE wiederholt interpretieren;TRUE
            ELSE TRUE
            FI
       ELSE fehler
       FI
  ELSE TRUE
  FI .
 
ende der wiederholung :
  IF war fehler
    THEN TRUE
  ELIF datei (stelle).nachfolger = dateianker
    THEN feldstelle > LENGTH (datei (stelle).inhalt)
  ELSE FALSE
  FI .
 
skip endrep :
  WHILE pos ("ENDREPEAT", symbol) <> 1 AND symboltyp <> eol 
  REP nextsymbol PER;
  nextsymbol .
 
abbruchtest :
  IF   is incharety (escape)
  THEN fehler bearbeiten
  FI .
 
END PROC wiederholung; 
 
BOOL PROC bedingung (DATEI VAR datei) : 
  INT VAR relator; 
  relator := pos ("=><<=>=<>", symbol); 
  IF   relator = 0
  THEN fehler
  ELSE IF typ = texttyp THEN relator INCR 8 FI;
       nextsymbol; 
       INT VAR operandtyp :: typ, operandzahlwert :: zahlwert; 
       TEXT VAR operandtextwert :: textwert; 
       IF   primary (datei) THEN FI; 
       IF   operandtyp <> typ
       THEN fehler
       ELSE boolwert := vergleich; typ := bool; TRUE 
       FI
  FI .
 
vergleich : 
  SELECT relator OF 
    CASE  1 : operandzahlwert =  zahlwert 
    CASE  2 : operandzahlwert >  zahlwert 
    CASE  3 : operandzahlwert <  zahlwert 
    CASE  4 : operandzahlwert <= zahlwert 
    CASE  6 : operandzahlwert >= zahlwert 
    CASE  8 : operandzahlwert <> zahlwert 
    CASE  9 : operandtextwert =  textwert 
    CASE 10 : operandtextwert >  textwert 
    CASE 11 : operandtextwert <  textwert 
    CASE 12 : operandtextwert <= textwert 
    CASE 14 : operandtextwert >= textwert 
    CASE 16 : operandtextwert <> textwert 
    OTHERWISE fehler
  END SELECT .
 
END PROC bedingung; 
 
(****************************  a u s d r u c k  ****************************)
 
BOOL PROC ausdruck (DATEI VAR datei) : 
  INT VAR opcode, operandtyp, operandzahlwert;
  TEXT VAR operandtextwert;
  IF   primary (datei)
  THEN BOOL VAR war operation :: TRUE;
       WHILE operator AND war operation
       REP IF   primary (datei)
           THEN war operation := operator verarbeiten
           ELSE war operation := FALSE
           FI
       PER;
       war operation
  ELSE fehler
  FI .
 
operator :
  IF   kommandoende
  THEN IF   typ = integer
       THEN row (datei)
       ELIF typ = texttyp
       THEN search (datei)
       FI
  FI;
  opcode := pos (op2namen, "&" + symbol);
  IF   opcode = 0
  THEN FALSE
  ELSE nextsymbol; operandtyp := typ;
       operandzahlwert := zahlwert;
       operandtextwert := textwert;
       NOT war fehler
  FI .
 
operator verarbeiten :
  SELECT opcode OF
    CASE plus :
         IF   typ = integer
         THEN zahlwert := operandzahlwert + zahlwert
         ELSE textwert := operandtextwert + textwert
         FI
    CASE minus : 
         zahlwert := operandzahlwert - zahlwert
    CASE mal :
         IF   typ = integer
         THEN zahlwert := operandzahlwert * zahlwert
         ELSE textwert := operandzahlwert * textwert
         FI
    CASE durch :
         zahlwert := operandzahlwert DIV zahlwert
    CASE changecode : 
         change
    CASE semicolon : 
    OTHERWISE fehler bearbeiten
  END SELECT;
  NOT war fehler .
 
change : 
  IF   bildmarke <= 0 AND schreiberlaubnis AND bildstelle <> dateianker
  THEN ersatz := textwert; textwert := operandtextwert; search (datei);
       INT VAR fstelle :: feldstelle;
       IF   textwert = "" AND ersatz <> "" AND fstelle > LENGTH inhalt 
       THEN inhalt := text (inhalt, fstelle-1)
       FI;
       IF   subtext (inhalt, fstelle-LENGTH textwert, fstelle-1) = textwert 
       THEN fstelle := fstelle - LENGTH textwert; 
            FOR j FROM 1 UPTO LENGTH ersatz 
            REP IF   j <=  LENGTH textwert 
                THEN replace     (inhalt, fstelle, ersatz SUB j) 
                ELSE insert char (inhalt, ersatz SUB j, fstelle)
                FI;
                fstelle INCR 1
            PER;
            FOR j FROM 1+LENGTH ersatz UPTO LENGTH textwert 
            REP delete char (inhalt, fstelle) PER;
       FI;
       feldstelle (fstelle); typ := void
  ELSE fehler bearbeiten
  FI .
 
inhalt :
  datei (stelle).inhalt . 
 
kommandoende :
  SELECT pos (";FIELSEENDREPEATUNTIL", symbol) OF
    CASE 1,2,4,8,17 : TRUE
    OTHERWISE symboltyp = eol
  END SELECT .
 
END PROC ausdruck;
 
(************************** schrott ****************************************)
 
PROC satz erzeugen (DATEI VAR datei, INT VAR satz): 
  EXTERNAL 291 ;
END  PROC satz erzeugen; 
 
PROC satz loeschen (DATEI VAR datei, INT VAR satz): 
  EXTERNAL 292 ;
END  PROC satz loeschen; 
 
END PACKET dateieditorpaket;