Initial import

1 files changed, 119 insertions, 0 deletions

diff --git a/app/gs.mp-bap/1.1/src/ls-MP BAP 1 b/app/gs.mp-bap/1.1/src/ls-MP BAP 1
new file mode 100644
index 0000000..be7e3d2
--- /dev/null
+++ b/app/gs.mp-bap/1.1/src/ls-MP BAP 1
@@ -0,0 +1,119 @@
+PACKET ls mp bap 1  DEFINES                (*******************************) 
+                                           (*                             *) 
+       stdvoreinstellung der parameter,    (*         ls-MP BAP 1         *) 
+       werkstueckdefinition,               (*         Version 1.1         *) 
+       tastendefinition,                   (*                             *) 
+       phasendefinition,                   (*   (c) 1987, 1988            *) 
+       bewertungsschluessel,               (*       by Eva Latta-Weber    *) 
+       werkstueckaufhaenger,               (*          Bielefeld          *) 
+       tastenbezeichnung,                  (*                             *) 
+       piepse,                             (*******************************) 
+                                            
+       mp bap einstellung anzeigen,         
+       mp bap standardwerte,                
+       mp bap breite des werkstuecks, 
+       mp bap hoehe  des werkstuecks, 
+       mp bap invers normal, 
+       mp bap zeichensatz, 
+       mp bap fehlerzeichen, 
+       mp bap tastenbelegung, 
+       mp bap anzahl arbeitsphasen, 
+       mp bap dauer einer arbeitsphase, 
+       mp bap pausendauer, 
+       mp bap wertungsschluessel: 
+ 
+LET maxspalten         =            70,{}    maxzeilen          =            14,{}    kleinster wert     =             1,{}    oben unten return  = ""3""10""13"",{}    punkt              =           "+",{}    punkt und zurueck  =        "+"8"",{}    piep               =         ""7"",{}    blank              =           " ";{}INT  VAR aktuelle werkstueckbreite,{}         aktuelle werkstueckhoehe,{}         kleinster aktueller zeichencode,{}         groesster aktueller zeichencode,{}         aktuelle anzahl der arbeitsphasen,{}
+         aktuelle arbeitsphasendauer in minuten,{}         aktuelle pausendauer in minuten;{}TEXT VAR aktuelles fehlerzeichen,{}         nach rechts,{}         nach links,{}         nach oben,{}         nach unten,{}         ausbesserung,{}         naechstes;{}BOOL VAR inversdarstellung;{}ROW 11 REAL VAR bewertung;{}WINDOW VAR w1, w2, w3, w4;{}PROC stdvoreinstellung der parameter:{}  aktuelle werkstueckbreite               :=     15;{}  aktuelle werkstueckhoehe                :=     12;{}  kleinster aktueller zeichencode         :=     65;{}
+  groesster aktueller zeichencode         :=     90;{}  aktuelle anzahl der arbeitsphasen       :=      3;{}  aktuelle arbeitsphasendauer in minuten  :=     10;{}  aktuelle pausendauer in minuten         :=      2;{}  aktuelles fehlerzeichen                 :=    "F";{}  nach rechts                             :=  ""2"";{}  nach links                              :=  ""8"";{}  nach oben                               :=  ""3"";{}  nach unten                              := ""10"";{}  ausbesserung                            :=  ""1"";{}
+  naechstes                               := ""27"";{}  inversdarstellung                       :=  FALSE;{}  bewertung := ROW 11 REAL : (0.0, 0.1, 0.2, 0.3, 0.4, 0.5,{}                                   0.6, 0.7, 0.8, 0.9, 1.0){}END PROC stdvoreinstellung der parameter;{}PROC werkstueckdefinition (INT VAR breite, hoehe, kleinster, groesster,{}                           TEXT VAR fzeichen, BOOL VAR invers):{}  breite        := aktuelle werkstueckbreite;{}  hoehe         := aktuelle werkstueckhoehe;{}
+  kleinster     := kleinster aktueller zeichencode;{}  groesster     := groesster aktueller zeichencode;{}  fzeichen      := aktuelles fehlerzeichen;{}  invers        := inversdarstellung{}END PROC werkstueckdefinition;{}PROC tastendefinition (TEXT VAR rechts, links, hoch, runter, aus, nach):{}  rechts        := nach rechts;{}  links         := nach links;{}  hoch          := nach oben;{}  runter        := nach unten;{}  aus           := ausbesserung;{}  nach          := naechstes{}END PROC tastendefinition;{}
+PROC phasendefinition (INT VAR aphasenzahl, aphasendauer, pausendauer):{}  aphasenzahl   := aktuelle anzahl der arbeitsphasen;{}  aphasendauer  := aktuelle arbeitsphasendauer in minuten;{}  pausendauer   := aktuelle pausendauer in minuten{}END PROC phasendefinition;{}PROC bewertungsschluessel (ROW 11 REAL VAR schluessel):{}  INT VAR zeiger;{}  FOR zeiger FROM 1 UPTO 11 REP{}    schluessel [zeiger] := bewertung [zeiger]{}  PER{}END PROC bewertungsschluessel;{}PROC mp bap einstellung anzeigen:{}  aktuellen parameterzustand anzeigen;{}
+  regenerate menuscreen{}END PROC mp bap einstellung anzeigen;{}PROC mp bap standardwerte:{}  standardwerte einstellen;{}  regenerate menuscreen{}END PROC mp bap standardwerte;{}PROC mp bap breite des werkstuecks:{}  breite des werkstuecks einstellen;{}  regenerate menuscreen{}END PROC mp bap breite des werkstuecks;{}PROC mp bap hoehe des werkstuecks:{}  hoehe des werkstuecks einstellen;{}  regenerate menuscreen{}END PROC mp bap hoehe des werkstuecks;{}PROC mp bap invers normal:{}  werkstueckdarstellung einstellen;{}
+  regenerate menuscreen{}END PROC mp bap invers normal;{}PROC mp bap zeichensatz:{}  zeichensatz einstellen;{}  regenerate menuscreen{}END PROC mp bap zeichensatz;{}PROC mp bap fehlerzeichen:{}  fehlerzeichen veraendern;{}  regenerate menuscreen{}END PROC mp bap fehlerzeichen;{}PROC mp bap tastenbelegung:{}  tastaturbelegung einstellen;{}  regenerate menuscreen{}END PROC mp bap tastenbelegung;{}PROC mp bap anzahl arbeitsphasen:{}  anzahl der arbeitsphasen festlegen;{}  regenerate menuscreen{}END PROC mp bap anzahl arbeitsphasen;{}
+PROC mp bap dauer einer arbeitsphase:{}  dauer einer arbeitsphase festlegen;{}  regenerate menuscreen{}END PROC mp bap dauer einer arbeitsphase;{}PROC mp bap pausendauer:{}  pausendauer festlegen;{}  regenerate menuscreen{}END PROC mp bap pausendauer;{}PROC mp bap wertungsschluessel:{}  wertungsschluessel veraendern;{}  regenerate menuscreen{}END PROC mp bap wertungsschluessel;{}PROC aktuellen parameterzustand anzeigen:{}  zeige die fenster;{}  fuelle die fenster mit inhalt;{}  gib hinweis aus.{}
+  zeige die fenster:{}    w1 := window ( 2,  2, 37, 20);{}    w2 := window (41,  2, 38, 20);{}    w3 := window ( 1,  1, 79, 24);{}    page; show (w1); show (w2).{}  fuelle die fenster mit inhalt:{}    zeige inhalt fenster 1;{}    zeige inhalt fenster 2.{}  zeige inhalt fenster 1:{}    zeige eingestellte parameter an (w1).{}  zeige inhalt fenster 2:{}    gib bewertungsschluessel aus (w2).{}  gib hinweis aus:{}    out footnote (w3, anwendungstext (2)); pause.{}END PROC aktuellen parameterzustand anzeigen;{}
+PROC zeige eingestellte parameter an (WINDOW VAR w):{}  zeige ueberschrift;{}  zeige werkstueckdefinition;{}  zeige tastenbelegung;{}  zeige simulationszeiten.{}  zeige ueberschrift:{}    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 1)))).{}  zeige werkstueckdefinition:{}    cursor (w, 2,  3); out (w, anwendungstext ( 6));{}                       out (w, text (aktuelle werkstueckbreite, 3));{}                       out (w, anwendungstext (28));{}    cursor (w, 2,  4); out (w, anwendungstext ( 7));{}
+                       out (w, text (aktuelle werkstueckhoehe,  3));{}                       out (w, anwendungstext (28));{}    cursor (w, 2,  5); out (w, anwendungstext ( 8));{}                        IF inversdarstellung{}                           THEN out (w, anwendungstext (29)){}                           ELSE out (w, anwendungstext (30)){}                        FI;{}    cursor (w, 2,  6); out (w, anwendungstext ( 9));{}                       out (w, zeichensatz);{}    cursor (w, 2,  7); out (w, anwendungstext (10));{}
+                       out (blank + aktuelles fehlerzeichen).{}  zeige tastenbelegung:{}    cursor (w, 2,  9); out (w, anwendungstext (11));{}                       out (w, tastenbezeichnung (nach rechts));{}    cursor (w, 2, 10); out (w, anwendungstext (12));{}                       out (w, tastenbezeichnung (nach links));{}    cursor (w, 2, 11); out (w, anwendungstext (13));{}                       out (w, tastenbezeichnung (nach oben));{}    cursor (w, 2, 12); out (w, anwendungstext (14));{}                       out (w, tastenbezeichnung (nach unten));{}
+    cursor (w, 2, 13); out (w, anwendungstext (15));{}                       out (w, tastenbezeichnung (ausbesserung));{}    cursor (w, 2, 14); out (w, anwendungstext (16));{}                       out (w, tastenbezeichnung (naechstes)).{}  zeige simulationszeiten:{}    cursor (w, 2, 16); out (w, anwendungstext (17));{}                       out (w, text (aktuelle anzahl der arbeitsphasen, 4));{}    cursor (w, 2, 17); out (w, anwendungstext (18));{}                       out (w, text (aktuelle arbeitsphasendauer in minuten, 4));{}
+                       out (w, anwendungstext (51));{}    cursor (w, 2, 18); out (w, anwendungstext (19));{}                       out (w, text (aktuelle pausendauer in minuten, 4));{}                       out (w, anwendungstext (51));{}    cursor (w, 2, 20); out (w, anwendungstext ( 5));{}                       out (w, gesamtdauerangabe).{}  zeichensatz:{}    blank + code (kleinster aktueller zeichencode) + "..." +{}            code (groesster aktueller zeichencode) + " ("  +{}            text (groesster aktueller zeichencode{}
+                   - kleinster aktueller zeichencode + 1, 2) +{}            anwendungstext (28) + ")".{}  gesamtdauerangabe:{}    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).{}  arbeitsdauer:{}      aktuelle anzahl der arbeitsphasen{}    * aktuelle arbeitsphasendauer in minuten.{}  pausendauer:{}      (aktuelle anzahl der arbeitsphasen - 1){}    * aktuelle pausendauer in minuten.{}END PROC zeige eingestellte parameter an;{}PROC gib bewertungsschluessel aus (WINDOW VAR w):{}  zeichne koordinatenkreuz;{}
+  trage messwerte ein.{}  zeichne koordinatenkreuz:{}    cursor (w, 1,  1); out (w, center (w, invers (anwendungstext ( 4))));{}    cursor (w, 2,  3); out (w, anwendungstext (20));{}    cursor (w, 2,  4); out (w, anwendungstext (21));{}    cursor (w, 2,  6); out (w, anwendungstext (23));{}    cursor (w, 2,  7); out (w, anwendungstext (22));{}    cursor (w, 2,  8); out (w, anwendungstext (22));{}    cursor (w, 2,  9); out (w, anwendungstext (22));{}    cursor (w, 2, 10); out (w, anwendungstext (22));{}
+    cursor (w, 2, 11); out (w, anwendungstext (24));{}    cursor (w, 2, 12); out (w, anwendungstext (22));{}    cursor (w, 2, 13); out (w, anwendungstext (22));{}    cursor (w, 2, 14); out (w, anwendungstext (22));{}    cursor (w, 2, 15); out (w, anwendungstext (22));{}    cursor (w, 2, 16); out (w, anwendungstext (25));{}    cursor (w, 2, 17); out (w, anwendungstext (26));{}    cursor (w, 2, 19); out (w, anwendungstext (27)).{}  trage messwerte ein:{}    INT CONST abszisse :: 16, ordinate :: 2;{}
+    INT VAR nr;{}    FOR nr FROM 1 UPTO 11 REP{}      zeichne einen punkt{}    PER.{}  zeichne einen punkt:{}    cursor (w, ordinate + 3 * nr, abszisse - nachkommastelle); out (punkt).{}  nachkommastelle:{}    int(bewertung [nr] * 10.0).{}END PROC gib bewertungsschluessel aus;{}PROC standardwerte einstellen:{}  zeige fenster;{}  zeige eingestellte parameter an (w1);{}  gib information aus;{}  hole bestaetigung ein.{}  zeige fenster:{}    w1 := window ( 2,  2, 37, 20);{}    w2 := window (41, 10, 37, 12);{}
+    w3 := window (41,  2, 37,  6);{}    page; show (w1); show (w2); show (w3).{}  gib information aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (67));{}    cursor (w2, 2, 4); out (w2, anwendungstext (68));{}    cursor (w2, 2, 7); out (w2, anwendungstext (69));{}    cursor (w2, 2, 9); out (w2, anwendungstext (70));{}    cursor (w2, 2,10); out (w2, anwendungstext (71));{}    cursor (w2, 2,11); out (w2, anwendungstext (72));{}
+    cursor (w2, 2,12); out (w2, anwendungstext (73)).{}  hole bestaetigung ein:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (66))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (66)){}       THEN stdvoreinstellung der parameter;{}            gib positive rueckmeldung{}    FI.{}  gib positive rueckmeldung:{}    page (w1);{}    zeige eingestellte parameter an (w1);{}    cleop  (w3, 2, 3); out (anwendungstext (221));{}    cursor (w3, 2, 5); out (anwendungstext (  3));{}
+    pause.{}END PROC standardwerte einstellen;{}PROC breite des werkstuecks einstellen:{}  zeige die fenster;{}  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige die fenster:{}    w1 := window ( 2, 2, 26, 6);{}    w2 := window (30, 2, 48, 6);{}    w3 := window (2, 9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (kleinster wert, 3));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxspalten,     3));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle werkstueckbreite, 3)).{}  erfrage veraenderung:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (57))));{}    cursor (w2, 2, 3);{}    IF no (anwendungstext (216)){}
+       THEN LEAVE breite des werkstuecks einstellen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w2, 2, 3); out (w2, anwendungstext (58));{}    cursor (w2, 2, 4); out (w2, anwendungstext (59));{}    cursor (w2, 2, 6); out (w2, anwendungstext (60));{}    aktuelle werkstueckbreite := ermittelter wert (1, maxspalten,{}                                                aktuelle werkstueckbreite).{}  benutzer ist einverstanden :{}    gib aktuelle infos aus;{}    hole bestaetigung.{}  gib aktuelle infos aus:{}
+    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3);{}    cleop (w2, 1, 3).{}  hole bestaetigung:{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (62)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC breite des werkstuecks einstellen;{}PROC hoehe des werkstuecks einstellen:{}  fenster zeigen;{}  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}
+  fenster zeigen:{}    w1 := window ( 2, 2, 26, 6);{}    w2 := window (30, 2, 48, 6);{}    w3 := window (2, 9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (kleinster wert, 3));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxzeilen,      3));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}
+                       out (w1, text (aktuelle werkstueckhoehe, 3)).{}  erfrage veraenderung:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (63))));{}    cursor (w2, 2, 3);{}    IF no (anwendungstext (217)){}       THEN LEAVE hoehe des werkstuecks einstellen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w2, 2, 3); out (w2, anwendungstext (58));{}    cursor (w2, 2, 4); out (w2, anwendungstext (59));{}    cursor (w2, 2, 6); out (w2, anwendungstext (64));{}    aktuelle werkstueckhoehe := ermittelter wert (1, maxzeilen,{}
+                                                  aktuelle werkstueckhoehe).{}  benutzer ist einverstanden :{}    gib aktuelle infos aus;{}    hole bestaetigung.{}  gib aktuelle infos aus:{}    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3);{}    cleop (w2, 1, 3).{}  hole bestaetigung:{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (65)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC hoehe des werkstuecks einstellen;{}PROC werkstueckdarstellung einstellen:{}  fenster zeigen;{}
+  hinweise an den benutzer ausgeben;{}  werkstueck zeigen (w3);{}  REP{}    bestaetigung einholen;{}    hinweise an den benutzer ausgeben;{}    werkstueck zeigen (w3){}  UNTIL benutzer ist einverstanden PER.{}  fenster zeigen:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (32,  2, 46,  6);{}    w3 := window ( 2,  9, 77, 16);{}    page; show (w1); show (w2).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (74));{}
+                       out (w1, anwendungstext (76));{}    cursor (w1, 2, 4); out (w1, anwendungstext (74));{}                       out (w1, anwendungstext (77));{}    cursor (w1, 2, 6); out (w1, anwendungstext (75));{}                       IF inversdarstellung{}                          THEN out (w1, anwendungstext (77)){}                          ELSE out (w1, anwendungstext (76)){}                       FI.{}  bestaetigung einholen:{}    page (w2);{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (89))));{}
+    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (78)){}       THEN veraendere darstellungsart{}       ELSE LEAVE werkstueckdarstellung einstellen{}    FI.{}  veraendere darstellungsart:{}    IF inversdarstellung{}       THEN inversdarstellung := FALSE{}       ELSE inversdarstellung := TRUE{}    FI.{}  benutzer ist einverstanden:{}    cleop (w2, 1, 3);{}    cursor (w2, 2, 3);{}    IF yes (w2, anwendungstext (99)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC werkstueckdarstellung einstellen;{}
+PROC zeichensatz einstellen:{}  zeige fenster;{}  gib eingestellten zeichensatz an;{}  gib bedienhinweise aus;{}  erfrage neueinstellung;{}  REP{}    erfrage das neue fehlerzeichen;{}    ermittle das kleinste zeichen;{}    ermittle das groesste zeichen;{}    page (w1);{}    gib eingestellten zeichensatz an{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28, 22);{}    w2 := window (32, 10, 46, 14);{}    w3 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3).{}
+  gib eingestellten zeichensatz an:{}    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (79))));{}    gib zeichenkette aus (w1, kleinster aktueller zeichencode,{}                              groesster aktueller zeichencode,{}                              code (aktuelles fehlerzeichen)).{}  gib bedienhinweise aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (80));{}    cursor (w2, 2, 4); out (w2, anwendungstext (81));{}
+    cursor (w2, 2, 5); out (w2, anwendungstext (82));{}    cursor (w2, 2, 6); out (w2, anwendungstext (83));{}    cursor (w2, 2, 8); out (w2, anwendungstext (84));{}    cursor (w2, 2, 9); out (w2, anwendungstext (85));{}    cursor (w2, 2,10); out (w2, anwendungstext (86));{}    cursor (w2, 2,12); out (w2, anwendungstext (87));{}    cursor (w2, 2,13); out (w2, anwendungstext (88)).{}  erfrage neueinstellung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (90))));{}    cursor (w3, 2, 3);{}
+    IF no (w3, anwendungstext (91)){}       THEN LEAVE zeichensatz einstellen{}    FI.{}  erfrage das neue fehlerzeichen:{}    gib vollstaendigen zeichensatz aus;{}    gib fehlerzeicheninformationen aus;{}    REP{}      lasse fehlerzeichen eingeben{}    UNTIL fehlerzeichen ist ok PER.{}  gib vollstaendigen zeichensatz aus:{}    page (w1); page (w2); page (w3);{}    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (92))));{}    gib zeichenkette aus (w1, 33, 126, 0).{}  gib fehlerzeicheninformationen aus:{}
+    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3);  out (w2, anwendungstext (95));{}    cursor (w2, 2, 4);  out (w2, anwendungstext (96));{}    cursor (w2, 2, 6);  out (w2, anwendungstext (97)).{}  lasse fehlerzeichen eingeben:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (100))));{}    cursor (w3, 2, 3);{}    out (w3, anwendungstext (101));{}    cursor on; inchar (aktuelles fehlerzeichen); cursor off;{}    IF fehlerzeichen ist ok{}
+       THEN out (w3, aktuelles fehlerzeichen);{}            markiere das fehlerzeichen im ersten fenster;{}       ELSE lege beschwerde ein{}    FI.{}  fehlerzeichen ist ok:{}        code (aktuelles fehlerzeichen) >=  33{}    AND code (aktuelles fehlerzeichen) <= 126.{}  markiere das fehlerzeichen im ersten fenster:{}    positioniere cursor in zeichenkette (w1, 33, code (aktuelles fehlerzeichen));{}    out (w1, invers (aktuelles fehlerzeichen)).{}  lege beschwerde ein:{}    piepse;{}    cursor (w2, 2, 8); out (w2, anwendungstext (102));{}
+    cursor (w2, 2,10); out (w2, anwendungstext (103));{}    cursor (w2, 2,11); out (w2, anwendungstext (104));{}    cursor (w2, 2,12); out (w2, anwendungstext (105));{}    cursor (w2, 2,13); out (w2, anwendungstext (106));{}    cursor (w2, 2,14); out (w2, anwendungstext (107)).{}  ermittle das kleinste zeichen:{}    page (w2); page (w3);{}    gib kleinste zeichencode informationen aus;{}    lasse den vorbereich festlegen.{}  ermittle das groesste zeichen:{}    lasse den nachbereich festlegen.{}  gib kleinste zeichencode informationen aus:{}
+    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (111));{}    cursor (w2, 2, 4); out (w2, anwendungstext (112));{}    cursor (w2, 2, 5); out (w2, anwendungstext (113));{}    cursor (w2, 2, 6); out (w2, anwendungstext (114));{}    cursor (w2, 2, 8); out (w2, anwendungstext (115));{}    cursor (w2, 2, 9); out (w2, anwendungstext (116));{}    cursor (w2, 2,10); out (w2, anwendungstext (117));{}    cursor (w2, 2,11); out (w2, anwendungstext (118));{}
+    cursor (w2, 2,13); out (w2, anwendungstext (119));{}    cursor (w2, 2,14); out (w2, anwendungstext (120)).{}  lasse den vorbereich festlegen:{}    INT VAR s, z; page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (121))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (122));{}    cursor (w3, 2, 4); out (w3, anwendungstext (123));{}    cursor (w3, 2, 5); out (w3, anwendungstext (125));{}    get cursor (s, z); cursor on;{}    kleinster aktueller zeichencode := code (aktuelles fehlerzeichen);{}
+    groesster aktueller zeichencode := code (aktuelles fehlerzeichen);{}    kleinster aktueller zeichencode := eingabe mit intervallanzeige ( w1, 33,{}                                       code (aktuelles fehlerzeichen),{}                                       kleinster aktueller zeichencode, s, z);{}    cursor off.{}  lasse den nachbereich festlegen:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (121))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (122));{}    cursor (w3, 2, 4); out (w3, anwendungstext (124));{}
+    cursor (w3, 2, 5); out (w3, anwendungstext (125));{}    get cursor (s, z); cursor on;{}    groesster aktueller zeichencode := eingabe mit intervallanzeige ( w1,{}                                       code (aktuelles fehlerzeichen), 126,{}                                       groesster aktueller zeichencode, s, z);{}    cursor off.{}  benutzer ist einverstanden:{}    page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (90))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (126)){}
+       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC zeichensatz einstellen;{}PROC fehlerzeichen veraendern:{}  fenster zeigen;{}  gib eingestellten zeichensatz an;{}  gib bedienhinweise aus;{}  erfrage neueinstellung;{}  REP{}    lasse fehlerzeichen einstellen{}  UNTIL benutzer ist einverstanden PER.{}  fenster zeigen:{}    w1 := window ( 2,  2, 28, 22);{}    w2 := window (32, 10, 46, 14);{}    w3 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3).{}  gib eingestellten zeichensatz an:{}
+    cursor (w1, 1, 1);{}    out (w1, center (w1, invers (anwendungstext (79))));{}    gib zeichenkette aus (w1, kleinster aktueller zeichencode,{}                              groesster aktueller zeichencode,{}                              code (aktuelles fehlerzeichen)).{}  gib bedienhinweise aus:{}    cursor (w2, 1, 1);{}    out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (131));{}    cursor (w2, 2, 4); out (w2, anwendungstext (132));{}    cursor (w2, 2, 5); out (w2, anwendungstext (133));{}
+    cursor (w2, 2, 7); out (w2, anwendungstext (134));{}    cursor (w2, 2, 8); out (w2, anwendungstext (135));{}    cursor (w2, 2, 9); out (w2, anwendungstext (136)).{}  erfrage neueinstellung:{}    cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (130))));{}    cursor (w3, 2, 3);{}    IF no (w3, anwendungstext (137)){}       THEN LEAVE fehlerzeichen veraendern{}    FI.{}  lasse fehlerzeichen einstellen:{}    INT VAR s, z, fehlercode :: code (aktuelles fehlerzeichen);{}    page (w3); cursor (w3, 1, 1);{}
+    out (w3, center (w3, invers (anwendungstext (138))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (139));{}    cursor (w3, 2, 4); out (w3, anwendungstext (140));{}    cursor (w3, 2, 5); out (w3, anwendungstext (141));{}    get cursor (s, z); cursor on;{}    fehlercode := eingabe mit elementanzeige (w1,{}                                              kleinster aktueller zeichencode,{}                                              groesster aktueller zeichencode,{}                                              fehlercode, s, z);{}
+    cursor off;{}    aktuelles fehlerzeichen := code (fehlercode).{}  benutzer ist einverstanden:{}    page (w3); cursor (w3, 1, 1);{}    out (w3, center (w3, invers (anwendungstext (130))));{}    cursor (w3, 2, 3);{}    IF yes (w3, anwendungstext (142)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC fehlerzeichen veraendern;{}PROC tastaturbelegung einstellen:{}  ROW 6 TEXT VAR tastenname, taste;{}  fenster zeigen;{}  REP{}    tastaturneubelegung vornehmen{}  UNTIL benutzer ist einverstanden PER.{}
+  fenster zeigen:{}    w1 := window ( 2,  2, 28, 10);{}    w2 := window ( 2, 14, 28, 10);{}    w3 := window (32, 10, 46, 14);{}    w4 := window (32,  2, 46,  6);{}    page; show (w1); show (w2); show (w3); show (w4).{}  tastaturneubelegung vornehmen:{}    alte tastenbelegung einlesen;{}    tastenbelegung anzeigen;{}    bedienhinweise ausgeben;{}    veraenderung erfragen;{}    neue tastenbelegung erfragen;{}    hinweis zur bewertung und stand ausgeben.{}  alte tastenbelegung einlesen:{}    INT VAR z1;{}
+    FOR z1 FROM 1 UPTO 6 REP{}      tastenname [z1] := anwendungstext (z1 + 10){}    PER;{}    taste [1] := nach rechts;{}    taste [2] := nach links;{}    taste [3] := nach oben;{}    taste [4] := nach unten;{}    taste [5] := ausbesserung;{}    taste [6] := naechstes;{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (151)))).{}  tastenbelegung anzeigen:{}    INT VAR cspa, czei;{}    cursor (w1, 2, 3); out (w1, tastenname [1]);{}                       out (w1, tastenbezeichnung (taste [1]));{}
+                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 4); out (w1, tastenname [2]);{}                       out (w1, tastenbezeichnung (taste [2]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 5); out (w1, tastenname [3]);{}                       out (w1, tastenbezeichnung (taste [3]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 6); out (w1, tastenname [4]);{}
+                       out (w1, tastenbezeichnung (taste [4]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2, 8); out (w1, tastenname [5]);{}                       out (w1, tastenbezeichnung (taste [5]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei);{}    cursor (w1, 2,10); out (w1, tastenname [6]);{}                       out (w1, tastenbezeichnung (taste [6]));{}                       get cursor (w1, cspa, czei); cleol (w1, cspa, czei).{}
+  bedienhinweise ausgeben:{}    cursor (w2, 1, 1); out (center (w2, invers (anwendungstext (152))));{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (52))));{}    cursor (w3, 2, 3); out (w3, anwendungstext (153));{}    cursor (w3, 2, 4); out (w3, anwendungstext (154));{}    cursor (w3, 2, 6); out (w3, anwendungstext (155));{}    cursor (w3, 2, 7); out (w3, anwendungstext (156));{}    cursor (w3, 2, 8); out (w3, anwendungstext (157));{}    cursor (w3, 2, 9); out (w3, anwendungstext (158));{}
+    cursor (w3, 2,11); out (w3, anwendungstext (159));{}    cursor (w3, 2,12); out (w3, anwendungstext (160));{}    cursor (w3, 2,13); out (w3, anwendungstext (161));{}    cursor (w3, 2,14); out (w3, anwendungstext (162)).{}  veraenderung erfragen:{}    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}    cursor (w4, 2, 3);{}    IF no (w4, anwendungstext (164)){}       THEN LEAVE tastaturbelegung einstellen{}    FI.{}  neue tastenbelegung erfragen:{}    INT VAR z2; page (w4);{}
+    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}    cursor (w4, 2, 3); out (w4, anwendungstext (165));{}    FOR z2 FROM 1 UPTO 6 REP{}      gib tastenhinweis;{}      hole tastatureingabe;{}      tastenbelegung anzeigen{}    PER.{}  gib tastenhinweis:{}    cleol (w4, 2, 5); out (w4, tastenname [z2]).{}  hole tastatureingabe:{}    INT VAR s, z; get cursor (w4, s, z);{}    cursor on; inchar (taste [z2]); cursor off;{}    cursor (w4, s, z); out (w4, tastenbezeichnung (taste [z2])).{}
+  hinweis zur bewertung und stand ausgeben:{}    IF neue tastenbelegung ist ok{}       THEN akzeptiere{}       ELSE akzeptiere nicht{}    FI.{}  neue tastenbelegung ist ok:{}    INT VAR zeiger; TEXT VAR tastenkette :: "";{}    FOR zeiger FROM 1 UPTO 6 REP{}      IF pos (tastenkette, taste [zeiger]) > 0{}         THEN LEAVE neue tastenbelegung ist ok WITH FALSE{}         ELSE tastenkette CAT taste [zeiger]{}      FI{}    PER;{}    TRUE.{}  akzeptiere:{}    cursor (w2, 3, 4);{}    out (w2, anwendungstext (166));{}
+    cursor (w2, 7, 6);{}    out (w2, anwendungstext (167)).{}  akzeptiere nicht:{}    cursor (w2, 3, 3); out (w2, anwendungstext (168));{}    cursor (w2, 3, 4); out (w2, anwendungstext (169));{}    cursor (w2, 3, 6); out (w2, anwendungstext (170));{}    cursor (w2, 3, 7); out (w2, anwendungstext (171));{}    cursor (w2, 3, 9); out (w2, anwendungstext (172));{}    cursor (w2, 5,10); out (w2, anwendungstext (173)).{}  benutzer ist einverstanden:{}    page (w4);{}    cursor (w4, 1, 1); out (w4, center (w4, invers (anwendungstext (163))));{}
+    IF neue tastenbelegung ist ok{}       THEN gib hinweis auf abspeicherung{}       ELSE frage nach neueingabe{}    FI.{}  gib hinweis auf abspeicherung:{}    cursor (w4, 3, 3); out (w4, anwendungstext (174));{}    neue tastenbelegung festschreiben;{}    cursor (w4, 3, 5); out (w4, anwendungstext (  2));{}    cursor on; pause; cursor off;{}    TRUE.{}  neue tastenbelegung festschreiben:{}    nach rechts   := taste [1];{}    nach links    := taste [2];{}    nach oben     := taste [3];{}    nach unten    := taste [4];{}
+    ausbesserung  := taste [5];{}    naechstes     := taste [6].{}  frage nach neueingabe:{}    cursor (w4, 2, 3);{}    IF yes (w4, anwendungstext (175)){}       THEN cleop (w2, 1, 3); FALSE{}       ELSE alte tastenbelegung einlesen;{}            tastenbelegung anzeigen;{}            cleop  (w4, 2, 3); out (w4, anwendungstext (176));{}            cursor (w4, 3, 5); out (w4, anwendungstext (  2));{}            cursor on; pause; cursor off;{}            TRUE{}    FI.{}END PROC tastaturbelegung einstellen;{}
+PROC simulationszeiten anzeigen (WINDOW VAR w):{}  cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (181))));{}  cursor (w, 2, 3); out (w, anwendungstext (17));{}                    out (w, text (aktuelle anzahl der arbeitsphasen, 4));{}  cursor (w, 2, 4); out (w, anwendungstext (18));{}                    out (w, text (aktuelle arbeitsphasendauer in minuten, 4));{}                    out (w, anwendungstext (51));{}  cursor (w, 2, 5); out (w, anwendungstext (19));{}                    out (w, text (aktuelle pausendauer in minuten, 4));{}
+                    out (w, anwendungstext (51));{}  cursor (w, 2, 7); out (w, anwendungstext ( 5));{}                       out (w, gesamtdauerangabe).{}  gesamtdauerangabe:{}    text ( arbeitsdauer + pausendauer, 4) + anwendungstext (51).{}  arbeitsdauer:{}      aktuelle anzahl der arbeitsphasen{}    * aktuelle arbeitsphasendauer in minuten.{}  pausendauer:{}      (aktuelle anzahl der arbeitsphasen - 1){}    * aktuelle pausendauer in minuten.{}END PROC simulationszeiten anzeigen;{}PROC anzahl der arbeitsphasen festlegen:{}
+  INT CONST minwert :: 2, maxwert :: 20;{}  zeige fenster;{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}
+    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxwert, 2));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle anzahl der arbeitsphasen, 2)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (182))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (218)){}
+       THEN LEAVE anzahl der arbeitsphasen festlegen{}    FI.{}  neuen wert vom bildschirm holen:{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (183));{}    aktuelle anzahl der arbeitsphasen := ermittelter wert (minwert, maxwert,{}                                         aktuelle anzahl der arbeitsphasen).{}  benutzer ist einverstanden:{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}
+    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (184)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC anzahl der arbeitsphasen festlegen;{}PROC dauer einer arbeitsphase festlegen:{}  INT CONST minwert :: 1, maxwert :: 60;{}  zeige fenster;{}  hinweise an den benutzer ausgeben;{}  simulationszeiten anzeigen (w2);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}
+    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}                       out (w1, text (maxwert, 2));{}                       out (w1, anwendungstext (51));{}
+    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle arbeitsphasendauer in minuten, 2));{}                       out (w1, anwendungstext (51)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (187))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (219)){}       THEN LEAVE dauer einer arbeitsphase festlegen{}    FI.{}  neuen wert vom bildschirm holen:{}    INT VAR spa, zei;{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}
+    cursor (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (188));{}    get cursor (w3, spa, zei);{}    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));{}    cursor (w3, spa, zei);{}    aktuelle arbeitsphasendauer in minuten{}                               := ermittelter wert (minwert, maxwert,{}                                  aktuelle arbeitsphasendauer in minuten).{}  benutzer ist einverstanden:{}
+    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (189)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC dauer einer arbeitsphase festlegen;{}PROC pausendauer festlegen:{}  INT CONST minwert :: 1, maxwert :: 30;{}  zeige fenster;{}  hinweise an den benutzer ausgeben;{}  simulationszeiten anzeigen (w2);{}  erfrage veraenderung;{}  REP{}    neuen wert vom bildschirm holen{}  UNTIL benutzer ist einverstanden PER.{}
+  zeige fenster:{}    w1 := window ( 2,  2, 28,  6);{}    w2 := window (22, 12, 37,  7);{}    w3 := window (32,  2, 47,  6);{}    page; show (w1); show (w2); show (w3).{}  hinweise an den benutzer ausgeben:{}    cursor (w1, 1, 1); out (w1, center (w1, invers (anwendungstext (52))));{}    cursor (w1, 2, 3); out (w1, anwendungstext (53));{}                       out (w1, text (minwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 4); out (w1, anwendungstext (54));{}
+                       out (w1, text (maxwert, 2));{}                       out (w1, anwendungstext (51));{}    cursor (w1, 2, 6); out (w1, anwendungstext (55));{}                       out (w1, text (aktuelle pausendauer in minuten, 2));{}                       out (w1, anwendungstext (51)).{}  erfrage veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (191))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (220)){}       THEN LEAVE pausendauer festlegen{}    FI.{}
+  neuen wert vom bildschirm holen:{}    INT VAR spa, zei;{}    cleop  (w3, 2, 3); out (w3, anwendungstext ( 58));{}    cursor (w3, 2, 4); out (w3, anwendungstext ( 59));{}    cursor (w3, 2, 6); out (w3, anwendungstext (192));{}    get cursor (w3, spa, zei);{}    cursor (w3, spa + 3, zei); out (w3, anwendungstext (51));{}    cursor (w3, spa, zei);{}    aktuelle pausendauer in minuten{}                               := ermittelter wert (minwert, maxwert,{}                                          aktuelle pausendauer in minuten).{}
+  benutzer ist einverstanden:{}    hinweise an den benutzer ausgeben;{}    simulationszeiten anzeigen (w2);{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (193)){}       THEN TRUE{}       ELSE FALSE{}    FI.{}END PROC pausendauer festlegen;{}PROC wertungsschluessel veraendern:{}  INT CONST abszisse :: 16, ordinate :: 2;{}  zeige fenster;{}  gib bewertungsschluessel aus (w1);{}  gib informationen aus;{}  stelle frage nach veraenderung;{}  REP{}    neueinstellung{}  UNTIL benutzer ist einverstanden PER.{}
+  zeige fenster:{}    w1 := window ( 2,  2, 38, 22);{}    w2 := window (42, 10, 37, 14);{}    w3 := window (42,  2, 37,  6);{}    page; show (w1); show (w2); show (w3).{}  gib informationen aus:{}    cursor (w2, 1, 1); out (w2, center (w2, invers (anwendungstext (52))));{}    cursor (w2, 2, 3); out (w2, anwendungstext (195));{}    cursor (w2, 2, 4); out (w2, anwendungstext (196));{}    cursor (w2, 2, 6); out (w2, anwendungstext (197));{}    cursor (w2, 2, 7); out (w2, anwendungstext (198));{}    cursor (w2, 2, 8); out (w2, anwendungstext (199));{}
+    cursor (w2, 2,11); out (w2, anwendungstext (200));{}    cursor (w2, 2,12); out (w2, anwendungstext (201));{}    cursor (w2, 2,13); out (w2, anwendungstext (202)).{}  stelle frage nach veraenderung:{}    cursor (w3, 1, 1); out (w3, center (w3, invers (anwendungstext (205))));{}    cursor (w3, 2, 3);{}    IF no (anwendungstext (206)){}       THEN LEAVE wertungsschluessel veraendern{}       ELSE gib hinweis auf linkes fenster{}    FI.{}  gib hinweis auf linkes fenster:{}    cleop  (w3, 2, 3); out (w3, anwendungstext (211));{}
+    cursor (w3, 2, 4); out (w3, anwendungstext (212));{}    cursor (w3, 2, 5); out (w3, anwendungstext (213)).{}  neueinstellung:{}    INT VAR zeiger;{}    cursor an;{}    FOR zeiger FROM 1 UPTO 11 REP{}      gehe auf aktuelle punktposition;{}      lasse verschieben{}    PER;{}    cursor aus.{}  gehe auf aktuelle punktposition:{}    cursor (w1, ordinate + 3 * zeiger, abszisse - nachkommastelle).{}  nachkommastelle:{}    int (bewertung [zeiger] * 10.0).{}  lasse verschieben:{}    TEXT VAR eingabezeichen; INT VAR position;{}
+    REP{}      inchar (eingabezeichen);{}      position := pos (oben unten return, eingabezeichen);{}      fuehre angemessene reaktion aus{}    UNTIL position = 3 PER.{}  fuehre angemessene reaktion aus:{}    SELECT position OF{}      CASE 1: steige auf{}      CASE 2: steige ab{}      CASE 3: (* tue nichts *){}      OTHERWISE piepse{}    END SELECT.{}  steige auf:{}    IF bewertung [zeiger] < 1.0{}       THEN loesche alten punkt;{}            bewertung [zeiger] INCR 0.1;{}            schreibe neuen punkt{}
+       ELSE piepse{}    FI.{}  steige ab:{}    IF bewertung [zeiger] > 0.0{}       THEN loesche alten punkt;{}            bewertung [zeiger] DECR 0.1;{}            schreibe neuen punkt{}       ELSE piepse{}    FI.{}  loesche alten punkt:{}    INT VAR tabspalte, tabzeile;{}    gehe auf aktuelle punktposition;{}    get cursor (w1, tabspalte, tabzeile);{}    IF tabspalte = ordinate + 3 OR tabzeile = abszisse{}       THEN out (w1, "|"){}       ELSE out (w1, blank){}    FI.{}  schreibe neuen punkt:{}    gehe auf aktuelle punktposition;{}
+    out (w1, punkt und zurueck).{}  benutzer ist einverstanden:{}    cleop (w3, 2, 3);{}    IF yes (w3, anwendungstext (207)){}       THEN TRUE{}       ELSE gib hinweis auf linkes fenster;{}            FALSE{}    FI.{}END PROC wertungsschluessel veraendern;{}PROC cleol (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):{}  cursor (w, cursorspalte, cursorzeile);{}  IF remaining lines (w) > 1{}     THEN out (w, (areaxsize (w) - cursorspalte + 1) * blank){}     ELSE out (w, (areaxsize (w) - cursorspalte) * blank){}
+  FI;{}  cursor (w, cursorspalte, cursorzeile){}END PROC cleol;{}PROC cleop (WINDOW VAR w, INT CONST cursorspalte, cursorzeile):{}  cleol (w, cursorspalte, cursorzeile);{}  INT VAR i;{}  FOR i FROM 1 UPTO remaining lines (w) REP{}    cleol (w, 1, cursorzeile + i){}  PER;{}  cursor  (w, cursorspalte, cursorzeile){}END PROC cleop;{}PROC cursor an:{}  INT VAR spalte, zeile;{}  get cursor (spalte, zeile); cursor on; cursor (spalte, zeile){}END PROC cursor an;{}PROC cursor aus:{}  INT VAR spalte, zeile;{}
+  get cursor (spalte, zeile); cursor off; cursor (spalte, zeile){}END PROC cursor aus;{}INT PROC eingabe mit intervallanzeige (WINDOW VAR w, INT CONST minwert,{}                                       maxwert, anfangswert, cursorspalte,{}                                       cursorzeile):{}  BOOL VAR ist aufsteigend :: minwert = anfangswert;{}  INT  VAR aktueller wert  :: anfangswert, alter wert, eingelesener wert;{}  REP{}    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}
+      CASE 1: erniedrige aktuellen wert wenn moeglich{}      CASE 2: erhoehe aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  aktueller wert.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minwert{}       THEN alter wert := aktueller wert;{}            aktueller wert DECR 1;{}            IF ist aufsteigend{}               THEN loesche alte markierung{}               ELSE markiere neues zeichen{}            FI{}       ELSE piepse{}    FI.{}  erhoehe aktuellen wert wenn moeglich:{}
+    IF aktueller wert < maxwert{}       THEN alter wert := aktueller wert;{}            aktueller wert INCR 1;{}            IF ist aufsteigend{}               THEN markiere neues zeichen{}               ELSE loesche alte markierung{}            FI{}       ELSE piepse{}    FI.{}  loesche alte markierung:{}    positioniere cursor in zeichenkette (w, 33, alter wert);{}    out (w, code (alter wert) + "  ");{}    cursor (cursorspalte, cursorzeile).{}  markiere neues zeichen:{}    positioniere cursor in zeichenkette (w, 33, aktueller wert);{}
+    out (w, invers (code (aktueller wert)));{}    cursor (cursorspalte, cursorzeile).{}END PROC eingabe mit intervallanzeige;{}INT PROC eingabe mit elementanzeige (WINDOW VAR w, INT CONST minwert,{}                                     maxwert, anfangswert,{}                                     cursorspalte, cursorzeile):{}  INT VAR aktueller wert :: anfangswert, alter wert, eingelesener wert;{}  REP{}    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}
+      CASE 1: erniedrige aktuellen wert wenn moeglich{}      CASE 2: erhoehe aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  aktueller wert.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minwert{}       THEN alter wert := aktueller wert;{}            aktueller wert DECR 1;{}            loesche alte markierung;{}            markiere neues zeichen{}       ELSE piepse{}    FI.{}  erhoehe aktuellen wert wenn moeglich:{}    IF aktueller wert < maxwert{}
+       THEN alter wert := aktueller wert;{}            aktueller wert INCR 1;{}            loesche alte markierung;{}            markiere neues zeichen{}       ELSE piepse{}    FI.{}  loesche alte markierung:{}    positioniere cursor in zeichenkette (w, minwert, alter wert);{}    out (w, code (alter wert) + "  ");{}    cursor (cursorspalte, cursorzeile).{}  markiere neues zeichen:{}    positioniere cursor in zeichenkette (w, minwert, aktueller wert);{}    out (w, invers (code (aktueller wert)));{}
+    cursor (cursorspalte, cursorzeile).{}END PROC eingabe mit elementanzeige;{}PROC werkstueck zeigen (WINDOW VAR w):{}  INT VAR zaehler, spalte, zeile;{}  page (w);{}  werkstueckaufhaenger (spalte, zeile);{}  schreibe werkstueck zeilenweise.{}  schreibe werkstueck zeilenweise:{}    FOR zaehler FROM 1 UPTO aktuelle werkstueckhoehe REP{}      positioniere den cursor;{}      bastle eine zeile;{}      gib eine zeile aus{}    PER.{}  positioniere den cursor:{}    cursor (w, spalte,  zeile + zaehler - 1).{}
+  bastle eine zeile:{}    TEXT VAR zeileninhalt := "";{}    INT VAR z;{}    FOR z FROM 1 UPTO aktuelle werkstueckbreite REP{}      zeileninhalt CAT code (random (kleinster aktueller zeichencode,{}                                     groesster aktueller zeichencode)){}    PER.{}  gib eine zeile aus:{}    IF inversdarstellung{}       THEN out (w, invers (zeileninhalt)){}       ELSE out (w, zeileninhalt){}    FI.{}END PROC werkstueck zeigen;{}PROC werkstueckaufhaenger (INT VAR spalte, zeile):{}  spalte := ((maxspalten - aktuelle werkstueckbreite) DIV 2) + 3;{}
+  zeile  := ((maxzeilen  - aktuelle werkstueckhoehe ) DIV 2) + 2;{}  IF inversdarstellung THEN spalte DECR 1 FI{}END PROC werkstueckaufhaenger;{}PROC gib zeichenkette aus (WINDOW VAR w,{}                           INT CONST kleinster, groesster, markiertes):{}  INT VAR zaehler;{}  FOR zaehler FROM kleinster UPTO groesster REP{}    positioniere cursor in zeichenkette (w, kleinster, zaehler);{}    IF zaehler = markiertes{}       THEN out (w, invers (code (zaehler))){}       ELSE out (w, code (zaehler)){}
+    FI{}  PER{}END PROC gib zeichenkette aus;{}PROC positioniere cursor in zeichenkette (WINDOW VAR w,{}                                          INT CONST mincode, position):{}  cursor (w, 4 + ((position - mincode) DIV 19) * 5,{}             3 + ((position - mincode) MOD 19)){}END PROC positioniere cursor in zeichenkette;{}TEXT PROC tastenbezeichnung (TEXT CONST zeichen):{}  IF code (zeichen) >= 33 AND code (zeichen) <= 126{}     THEN "<" + zeichen + ">"{}     ELSE umgesetzter code{}  FI.{}  umgesetzter code:{}
+    SELECT code (zeichen) OF{}      CASE   1: anwendungstext (31){}      CASE   2: anwendungstext (32){}      CASE   3: anwendungstext (33){}      CASE   8: anwendungstext (34){}      CASE   9: anwendungstext (35){}      CASE  10: anwendungstext (36){}      CASE  11: anwendungstext (37){}      CASE  12: anwendungstext (38){}      CASE  13: anwendungstext (39){}      CASE  16: anwendungstext (40){}      CASE  27: anwendungstext (41){}      CASE  32: anwendungstext (42){}      CASE 214: anwendungstext (43){}
+      CASE 215: anwendungstext (44){}      CASE 216: anwendungstext (45){}      CASE 217: anwendungstext (46){}      CASE 218: anwendungstext (47){}      CASE 219: anwendungstext (48){}      CASE 251: anwendungstext (49){}      OTHERWISE anwendungstext (50){}  END SELECT{}END PROC tastenbezeichnung;{}INT PROC ermittelter wert (INT CONST minimum, maximum, startwert):{}  INT VAR aktueller wert, eingelesener wert;{}  cursor an;{}  aktueller wert := startwert;{}  REP{}    gib dreistellig aus und positioniere zurueck (aktueller wert, FALSE);{}
+    hole position aus vorgabe (oben unten return, eingelesener wert);{}    SELECT eingelesener wert OF{}      CASE 1: erhoehe aktuellen wert wenn moeglich{}      CASE 2: erniedrige aktuellen wert wenn moeglich{}    END SELECT{}  UNTIL eingelesener wert = 3 PER;{}  cursor aus;{}  aktueller wert.{}  erhoehe aktuellen wert wenn moeglich:{}    IF aktueller wert < maximum{}       THEN aktueller wert INCR 1{}       ELSE piepse{}    FI.{}  erniedrige aktuellen wert wenn moeglich:{}    IF aktueller wert > minimum{}
+       THEN aktueller wert DECR 1{}       ELSE piepse{}    FI.{}END PROC ermittelter wert;{}PROC gib dreistellig aus und positioniere zurueck (INT CONST wert,{}                                                   BOOL CONST mit wertwandel):{}  INT VAR spalte, zeile; get cursor (spalte, zeile);{}  IF mit wertwandel{}     THEN out ("'" + code (wert) + "'"){}     ELSE out (text (wert, 3)){}  FI;{}  cursor (spalte, zeile);{}END PROC gib dreistellig aus und positioniere zurueck;{}PROC hole position aus vorgabe (TEXT CONST vorgabe, INT VAR position):{}
+  TEXT VAR eingabezeichen; INT VAR spa, zei;{}  REP{}    get cursor (spa, zei); inchar (eingabezeichen); cursor (spa, zei);{}    position := pos (vorgabe, eingabezeichen);{}    IF position = 0 THEN piepse; cursor (spa, zei) FI{}  UNTIL position > 0 PER{}END PROC hole position aus vorgabe;{}PROC piepse:{}  INT VAR spa, zei; get cursor (spa, zei); out (piep); cursor (spa, zei){}END PROC piepse;{}END PACKET ls mp bap 1;{}stdvoreinstellung der parameter{}
+