From afd4c3c448381f6eb706090911a15c162fdaf8af Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Sun, 9 Oct 2016 11:28:19 +0200 Subject: Decompress source files MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit EUMEL’s TEXT dataspaces wastes a lot of storage space. Some files were therefore “compressed” by storing them as a single line, reducing overhead significantly. --- mp-bap/ls-MP BAP 1 | 1415 ++++++++++++++++++++++++++++++++++++++++++++---- mp-bap/ls-MP BAP 2 | 1472 ++++++++++++++++++++++++++++++++++++++++++++++---- mp-bap/ls-MP BAP-gen | 80 ++- 3 files changed, 2767 insertions(+), 200 deletions(-) (limited to 'mp-bap') diff --git a/mp-bap/ls-MP BAP 1 b/mp-bap/ls-MP BAP 1 index be7e3d2..9fa1a4b 100644 --- a/mp-bap/ls-MP BAP 1 +++ b/mp-bap/ls-MP BAP 1 @@ -22,98 +22,1325 @@ PACKET ls mp bap 1 DEFINES (*******************************) 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{} +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 + diff --git a/mp-bap/ls-MP BAP 2 b/mp-bap/ls-MP BAP 2 index 0cd66ff..4ae047c 100644 --- a/mp-bap/ls-MP BAP 2 +++ b/mp-bap/ls-MP BAP 2 @@ -22,105 +22,1375 @@ LET maxeintraege = 800, auswertdateipostfix = " - Auswertung", protokolldateityp = 1955, maxspalten = 70, - maxzeilen = 14,{} blank = " ",{} trenn = "|",{} werkstueckendekennung = 1,{} pausenendekennung = 2,{} simulationsendekennung = 3,{} markierung ein = ""15"",{} markierung aus = " "14"",{} stdschrifttyp = "",{} - stdxstart = 0.0,{} stdystart = 0.0,{} stdfeldbreite = 21.0,{} stdfeldlaenge = 29.5;{}LET KONTROLLTABELLE = STRUCT (INT letzter eintrag,{} breite, hoehe,{} kleinster code, groesster code,{} anzahl aphasen, aphasendauer,{} pausendauer,{} - TEXT datum, uhrzeit, fehlerzeichen,{} nach rechts, nach links,{} nach oben, nach unten,{} ausbesserung, naechstes,{} BOOL inversdarstellung,{} ROW 11 REAL bewertung,{} ROW maxeintraege KONTROLLE tabelle),{} KONTROLLE = STRUCT (INT eintragskennung,{} produktionsfehler,{} - anzahl korrekturen,{} anzahl bedienfehler,{} REAL anfang, ende, differenz),{} WERKSTUECK = ROW maxspalten ROW maxzeilen INT;{}INT VAR breite, hoehe, kleinster code, groesster code,{} anzahl aphasen, aphasendauer, pausendauer,{} eckspalte, eckzeile, x, y, xsize, ysize;{}TEXT VAR fehlerzeichen, nach rechts, nach links, nach oben, nach unten,{} ausbesserung, naechstes, datum, uhrzeit;{} -TEXT VAR protokollschrifttyp :: stdschrifttyp;{}REAL VAR xstart :: stdxstart,{} ystart :: stdystart,{} schreibfeldbreite :: stdfeldbreite,{} schreibfeldlaenge :: stdfeldlaenge;{}ROW 11 REAL VAR bewertung;{}BOOL VAR inversdarstellung,{} kontrolldatei zur vatertask :: TRUE,{} mit kurzprotokoll :: TRUE,{} mit anmerkungen :: TRUE,{} auswertung geht zum drucker :: FALSE;{}WERKSTUECK VAR werkstueck;{} -PROC bildschirmarbeitsplatz:{} kontrolldatei zur vatertask := FALSE;{} install menu (menukarte);{} handle menu (menubezeichnung);{}END PROC bildschirmarbeitsplatz;{}PROC bap:{} bildschirmarbeitsplatz{}END PROC bap;{}PROC materialpruefung:{} TEXT VAR benutzerkennung :: "", protokollname, alter dateiname :: std;{} install menu (menukarte, FALSE);{} kontrolldatei zur vatertask := TRUE;{} ermittle eingestellte parameter;{} bereite den bildschirm vor;{} ermittle die benutzerkennung;{} gib benutzerhinweise aus;{} - arbeitsplatzsimulation ausfuehren (benutzerkennung, protokollname);{} forget (protokollname, quiet);{} last param (alter dateiname).{} bereite den bildschirm vor:{} WINDOW VAR w :: window ( 2, 10, 77, 14);{} page;{} show (w);{} out (w, center (w, anwendungstext (400))).{} ermittle die benutzerkennung:{} benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));{} IF benutzerkennung = ""{} THEN cursor on; page;{} LEAVE materialpruefung{} FI.{} - gib benutzerhinweise aus:{} boxinfo (w, anwendungstext (402));{} boxinfo (w, anwendungstext (403));{} boxinfo (w, anwendungstext (404));{} gib bedieninformationen aus (2);{} boxinfo (w, anwendungstext (405));{} boxinfo (w, anwendungstext (406));{} boxinfo (w, anwendungstext (407));{} boxinfo (w, anwendungstext (408)).{}END PROC materialpruefung;{}PROC mp:{} materialpruefung{}END PROC mp;{}PROC mp bap simulation ausfuehren:{} TEXT VAR benutzerkennung :: "", dateiname;{} - kontrolldatei zur vatertask := FALSE;{} ermittle eingestellte parameter;{} bereite den bildschirm vor;{} ermittle die benutzerkennung;{} arbeitsplatzsimulation ausfuehren (benutzerkennung, dateiname);{} regenerate menuscreen.{} bereite den bildschirm vor:{} WINDOW VAR w :: window (2,2,77,22);{} page;{} out (w, center (w, anwendungstext (399))).{} ermittle die benutzerkennung:{} benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5));{} IF benutzerkennung = ""{} - THEN regenerate menuscreen;{} LEAVE mp bap simulation ausfuehren{} FI.{}END PROC mp bap simulation ausfuehren;{}PROC mp bap auswertung auf bildschirm:{} auswertung geht zum drucker := FALSE;{} lasse protokolldateien auswaehlen;{} werte protokolldateien aus;{} regenerate menuscreen.{} lasse protokolldateien auswaehlen:{} THESAURUS VAR verfuegbare;{} verfuegbare := infix namen (ALL myself, protokolldateipraefix,{} protokolldateityp);{} - IF NOT not empty (verfuegbare){} THEN noch kein protokoll{} ELSE biete auswahl an{} FI.{} noch kein protokoll:{} regenerate menuscreen;{} menuinfo (anwendungstext (424));{} LEAVE mp bap auswertung auf bildschirm.{} biete auswahl an:{} verfuegbare := menusome (verfuegbare, anwendungstext (421),{} anwendungstext (422), FALSE).{} werte protokolldateien aus:{} INT VAR k;{} steige ggf bei leerem thesaurus aus;{} FOR k FROM 1 UPTO highest entry (verfuegbare) REP{} - IF name (verfuegbare, k) <> ""{} THEN disable stop;{} gib hinweis auf auswertung;{} simulationsauswertung (name (verfuegbare, k), TRUE);{} forget (name (verfuegbare, k) + auswertdateipostfix, quiet);{} fehlerbehandlung{} FI{} PER.{} steige ggf bei leerem thesaurus aus:{} IF NOT not empty (verfuegbare){} THEN regenerate menuscreen;{} menuinfo (anwendungstext (423));{} LEAVE mp bap auswertung auf bildschirm{} - FI.{} gib hinweis auf auswertung:{} page;{} WINDOW VAR fenster :: window ( 2, 2, 77, 22);{} show (fenster);{} cursor (fenster, 1, 9); out (fenster, center (fenster, name (verfuegbare, k)));{} cursor (fenster, 1, 12); out (fenster, center (anwendungstext (274))).{} fehlerbehandlung:{} IF is error{} THEN regenerate menuscreen;{} menuinfo (invers (errormessage));{} clear error; enable stop;{} LEAVE mp bap auswertung auf bildschirm{} FI.{} -END PROC mp bap auswertung auf bildschirm;{}PROC mp bap drucken von auswertungen:{} auswertung geht zum drucker := TRUE;{} lasse protokolldateien auswaehlen;{} werte protokolldateien aus;{} regenerate menuscreen.{} lasse protokolldateien auswaehlen:{} THESAURUS VAR verfuegbare;{} verfuegbare := infix namen (ALL myself, protokolldateipraefix,{} protokolldateityp);{} IF NOT not empty (verfuegbare){} THEN noch kein protokoll{} ELSE biete auswahl an{} - FI.{} noch kein protokoll:{} regenerate menuscreen;{} menuinfo (anwendungstext (424));{} LEAVE mp bap drucken von auswertungen.{} biete auswahl an:{} verfuegbare := menusome (verfuegbare, anwendungstext (425),{} anwendungstext (422), FALSE).{} werte protokolldateien aus:{} INT VAR k;{} steige ggf bei leerem thesaurus aus;{} FOR k FROM 1 UPTO highest entry (verfuegbare) REP{} IF name (verfuegbare, k) <> ""{} THEN disable stop;{} gib hinweis auf auswertung;{} - simulationsauswertung (name (verfuegbare, k), FALSE);{} print (name (verfuegbare, k) + auswertdateipostfix);{} forget (name (verfuegbare, k) + auswertdateipostfix, quiet);{} fehlerbehandlung{} FI{} PER.{} steige ggf bei leerem thesaurus aus:{} IF NOT not empty (verfuegbare){} THEN regenerate menuscreen;{} menuinfo (anwendungstext (423));{} LEAVE mp bap drucken von auswertungen{} FI.{} gib hinweis auf auswertung:{} - page;{} WINDOW VAR fenster :: window ( 2, 2, 77, 22);{} show (fenster);{} cursor (fenster, 1, 9); out (fenster, center (fenster, name (verfuegbare, k)));{} cursor (fenster, 1, 12); out (fenster, center (anwendungstext (270))).{} fehlerbehandlung:{} IF is error{} THEN regenerate menuscreen;{} menuinfo (invers (errormessage));{} clear error; enable stop;{} LEAVE mp bap drucken von auswertungen{} FI.{}END PROC mp bap drucken von auswertungen;{} -PROC mp bap protokollumfang festlegen:{} page;{} zeige aktuellen protokollumfang an;{} gib erlaeuterungen zum protokollumfang;{} frage nach umfangsaenderung;{} regenerate menuscreen{}END PROC mp bap protokollumfang festlegen;{}PROC mp bap kurzauswertung:{} page;{} zeige aktuelle kurzauswertungseinstellung an;{} gib erlaeuterungen zur kurzauswertung;{} frage nach kurzauswertungsaenderung;{} regenerate menuscreen{}END PROC mp bap kurzauswertung;{}PROC druckereinstellung fuer protokolldatei (TEXT CONST schrifttyp,{} - REAL CONST linker rand,{} oberer rand,{} feldbreite,{} feldlaenge):{} protokollschrifttyp := schrifttyp;{} xstart := linker rand;{} ystart := oberer rand;{} schreibfeldbreite := feldbreite;{} schreibfeldlaenge := feldlaenge;{}END PROC druckereinstellung fuer protokolldatei;{} -PROC stddruckereinstellung fuer protokolldatei:{} protokollschrifttyp := stdschrifttyp;{} xstart := stdxstart;{} ystart := stdystart;{} schreibfeldbreite := stdfeldbreite;{} schreibfeldlaenge := stdfeldlaenge{}END PROC stddruckereinstellung fuer protokolldatei;{} (********************************){}PROC arbeitsplatzsimulation ausfuehren (TEXT CONST kennung,{} TEXT VAR dateiname):{} ermittle eingestellte parameter;{} - lege datei mit kennung an (kennung, dateiname);{} cursor on;{} fuehre simulation durch (dateiname);{} schicke ggf protokolldatei zur vatertask;{} gib ggf kurzprotokoll aus.{} schicke ggf protokolldatei zur vatertask:{} IF kontrolldatei zur vatertask{} THEN command dialogue (FALSE);{} save (dateiname);{} command dialogue (TRUE){} FI.{} gib ggf kurzprotokoll aus:{} IF mit kurzprotokoll{} THEN kurzauswertung auf bildschirm (dateiname){} ELSE page; put (anwendungstext (271)){} - FI.{}END PROC arbeitsplatzsimulation ausfuehren;{}PROC ermittle eingestellte parameter:{} werkstueckdefinition (breite, hoehe, kleinster code, groesster code,{} fehlerzeichen, inversdarstellung);{} tastendefinition (nach rechts, nach links, nach oben, nach unten,{} ausbesserung, naechstes);{} phasendefinition (anzahl aphasen, aphasendauer, pausendauer);{} bewertungsschluessel (bewertung);{}END PROC ermittle eingestellte parameter;{}PROC lege datei mit kennung an (TEXT CONST kennung, TEXT VAR datname):{} - BOUND KONTROLLTABELLE VAR tab;{} TEXT VAR interner name :: protokolldateipraefix;{} interner name CAT kennung;{} lege neue datei an;{} type (old (datname), protokolldateityp).{} lege neue datei an:{} INT VAR i :: 0; TEXT VAR bezeichnung;{} REP{} i INCR 1;{} bezeichnung := interner name + " /" + text (i){} UNTIL NOT exists (bezeichnung) PER;{} tab := new (bezeichnung);{} initialisiere tabelle;{} datname := bezeichnung.{} initialisiere tabelle:{} tab.letzter eintrag := 0.{} -END PROC lege datei mit kennung an;{}PROC fuehre simulation durch (TEXT CONST dateiname):{} BOUND KONTROLLTABELLE VAR tab :: old (dateiname);{} TEXT CONST moegliche eingabezeichen :: nach rechts + nach links +{} nach oben + nach unten +{} ausbesserung + naechstes;{} treffe vorbereitungen;{} trage grunddaten in tabelle;{} simuliere.{} treffe vorbereitungen:{} initialisierungen;{} WINDOW VAR fenster :: window ( 1, 9, 79, 16);{} - page;{} gib bedieninformationen aus (2);{} werkstueckaufhaenger (eckspalte, eckzeile);{} weise auf arbeitsbeginn hin;{} beginn der arbeitsphase := clock (1);{} beginn der bearbeitung := beginn der arbeitsphase;{} arbeitsphasenlaenge := real (aphasendauer * 60).{} initialisierungen:{} INT VAR eintragzaehler :: 0,{} arbeitsphasenzaehler :: 1,{} werkstueckzaehler :: 0,{} bedienfehlerzaehler :: 0,{} - korrekturzaehler :: 0,{} produktionsfehler,{} cursorspalte relativ,{} cursorzeile relativ;{} REAL VAR beginn der arbeitsphase,{} beginn der bearbeitung,{} arbeitsphasenlaenge,{} arbeitsphasenueberziehung,{} pausenueberziehung.{} weise auf arbeitsbeginn hin:{} page (fenster);{} boxinfo (fenster, anwendungstext (252), 5, maxint);{} clear buffer.{} trage grunddaten in tabelle:{} tab.datum := date;{} - tab.uhrzeit := time of day;{} tab.breite := breite;{} tab.hoehe := hoehe;{} tab.kleinster code := kleinster code;{} tab.groesster code := groesster code;{} tab.anzahl aphasen := anzahl aphasen;{} tab.aphasendauer := aphasendauer;{} tab.pausendauer := pausendauer;{} tab.fehlerzeichen := fehlerzeichen;{} tab.nach rechts := nach rechts;{} tab.nach links := nach links;{} tab.nach oben := nach oben;{} - tab.nach unten := nach unten;{} tab.ausbesserung := ausbesserung;{} tab.naechstes := naechstes;{} tab.inversdarstellung := inversdarstellung;{} tab.bewertung := bewertung;{} eintragzaehler := 1.{} simuliere:{} REP{} gib holehinweis;{} hole werkstueck (werkstueck, produktionsfehler);{} zeige werkstueck (werkstueck, fenster);{} lasse werkstueck bearbeiten{} UNTIL simulationsende erreicht PER.{} gib holehinweis:{} - page (fenster);{} cursor (fenster, 2, 3); out (fenster, anwendungstext (253)).{} lasse werkstueck bearbeiten:{} initialisiere den relativcursor;{} setze cursor;{} clear buffer;{} bearbeite das werkstueck.{} initialisiere den relativcursor:{} cursorspalte relativ := 1;{} cursorzeile relativ := 1.{} setze cursor:{} IF inversdarstellung{} THEN cursor (fenster, eckspalte + cursorspalte relativ,{} eckzeile + cursorzeile relativ - 1);{} - ELSE cursor (fenster, eckspalte + cursorspalte relativ - 1,{} eckzeile + cursorzeile relativ - 1);{} FI.{} bearbeite das werkstueck:{} BOOL VAR werkstueck voll bearbeitet :: FALSE;{} REP{} hole eingabe und werte aus{} UNTIL werkstueck voll bearbeitet PER.{} hole eingabe und werte aus:{} TEXT VAR eingabezeichen := incharety (100);{} SELECT eingabezeichenposition OF{} CASE 1: wenn moeglich nach rechts{} CASE 2: wenn moeglich nach links{} - CASE 3: wenn moeglich nach oben{} CASE 4: wenn moeglich nach unten{} CASE 5: wenn moeglich ausbessern{} CASE 6: beende werkstueckbearbeitung{} OTHERWISE entscheide ob gepiepst wird{} END SELECT.{} eingabezeichenposition:{} pos (moegliche eingabezeichen, eingabezeichen).{} wenn moeglich nach rechts:{} IF cursorspalte relativ < breite{} THEN cursorspalte relativ INCR 1;{} setze cursor{} ELSE registriere bedienfehler{} FI.{} wenn moeglich nach links:{} - IF cursorspalte relativ > 1{} THEN cursorspalte relativ DECR 1;{} setze cursor{} ELSE registriere bedienfehler{} FI.{} wenn moeglich nach oben:{} IF cursorzeile relativ > 1{} THEN cursorzeile relativ DECR 1;{} setze cursor{} ELSE registriere bedienfehler{} FI.{} wenn moeglich nach unten:{} IF cursorzeile relativ < hoehe{} THEN cursorzeile relativ INCR 1;{} setze cursor{} ELSE registriere bedienfehler{} FI.{} - wenn moeglich ausbessern:{} IF werkstueck [cursorspalte relativ][cursorzeile relativ] = code (fehlerzeichen){} THEN werkstueck [cursorspalte relativ][cursorzeile relativ] := code (blank);{} korrekturzaehler INCR 1;{} get cursor (fenster, x, y);{} out (fenster, blank);{} cursor (fenster, x, y);{} ELSE registriere bedienfehler{} FI.{} registriere bedienfehler:{} piepse; bedienfehlerzaehler INCR 1.{} entscheide ob gepiepst wird:{} IF eingabezeichen <> "" THEN piepse FI.{} - beende werkstueckbearbeitung:{} IF simulationsende erreicht{} THEN trage simulationsende in tabelle ein{} ELIF arbeitsphasenende erreicht{} THEN trage werkstueckdaten in tabelle ein;{} ermittle ueberziehung der arbeitsphase;{} lege eine pause ein{} ELSE trage werkstueckdaten in tabelle ein{} FI;{} werkstueck voll bearbeitet := TRUE.{} lege eine pause ein:{} nimm pausendaten;{} weise auf pausenanfang hin;{} pausiere;{} weise auf pausenende hin;{} - registriere pausenueberziehung.{} nimm pausendaten:{} REAL VAR pausenanfang :: clock (1),{} pausenende :: pausenanfang + real (pausendauer * 60);.{} weise auf pausenanfang hin:{} page (fenster);{} boxnotice (fenster, anwendungstext (255), 5, x, y, xsize, ysize).{} pausiere:{} REP{} pause (int ((pausenende - clock (1)) * 10.0)){} UNTIL clock (1) >= pausenende PER.{} weise auf pausenende hin:{} page (fenster);{} pausenanfang := clock (1);{} piepse;{} - clear buffer;{} boxinfo (fenster, anwendungstext (256), 5, maxint);{} pausenende := clock (1).{} registriere pausenueberziehung:{} pausenueberziehung := pausenende - pausenanfang;{} trage pausenueberziehung in tabelle ein.{} trage werkstueckdaten in tabelle ein:{} REAL VAR bearbeitungsende :: clock (1);{} tab.tabelle [eintragzaehler].eintragskennung := werkstueckendekennung;{} tab.tabelle [eintragzaehler].produktionsfehler := produktionsfehler;{} tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;{} - tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;{} tab.tabelle [eintragzaehler].anfang := beginn der bearbeitung;{} tab.tabelle [eintragzaehler].ende := bearbeitungsende;{} tab.tabelle [eintragzaehler].differenz := bearbeitungszeit;{} erhoehe eintragzaehler;{} beginn der bearbeitung := clock (1);{} werkstueckzaehler INCR 1;{} bedienfehlerzaehler := 0;{} korrekturzaehler := 0.{} trage pausenueberziehung in tabelle ein:{} - tab.tabelle [eintragzaehler].eintragskennung := pausenendekennung;{} tab.tabelle [eintragzaehler].produktionsfehler := 0;{} tab.tabelle [eintragzaehler].anzahl korrekturen := 0;{} tab.tabelle [eintragzaehler].anzahl bedienfehler:= 0;{} tab.tabelle [eintragzaehler].anfang := pausenanfang;{} tab.tabelle [eintragzaehler].ende := pausenende;{} tab.tabelle [eintragzaehler].differenz := pausenueberziehung;{} erhoehe eintragzaehler;{} arbeitsphasenzaehler INCR 1;{} - beginn der bearbeitung := clock (1);{} beginn der arbeitsphase := clock (1);{} bearbeitungslaenge bestimmen.{} trage simulationsende in tabelle ein:{} bearbeitungsende := clock (1);{} tab.tabelle [eintragzaehler].eintragskennung := simulationsendekennung;{} tab.tabelle [eintragzaehler].produktionsfehler := produktionsfehler;{} tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler;{} tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler;{} - tab.tabelle [eintragzaehler].anfang := beginn der bearbeitung;{} tab.tabelle [eintragzaehler].ende := bearbeitungsende;{} tab.tabelle [eintragzaehler].differenz := bearbeitungszeit;{} tab.letzter eintrag := eintragzaehler.{} bearbeitungszeit:{} bearbeitungsende - beginn der bearbeitung.{} erhoehe eintragzaehler:{} IF eintragzaehler < maxeintraege{} THEN eintragzaehler INCR 1{} ELSE trage simulationsende in tabelle ein;{} - errorstop (anwendungstext (254)){} FI.{} ermittle ueberziehung der arbeitsphase:{} arbeitsphasenueberziehung := clock (1) - beginn der arbeitsphase{} - arbeitsphasenlaenge.{} bearbeitungslaenge bestimmen:{} arbeitsphasenlaenge := real (aphasendauer * 60){} - arbeitsphasenueberziehung{} - pausenueberziehung.{} arbeitsphasenende erreicht:{} clock (1) - beginn der arbeitsphase >= arbeitsphasenlaenge.{} - simulationsende erreicht:{} arbeitsphasenzaehler = anzahl aphasen AND arbeitsphasenende erreicht.{}END PROC fuehre simulation durch;{}PROC gib bedieninformationen aus (INT CONST zeile):{} WINDOW VAR f1 :: window ( 2, zeile, 35, 6),{} f2 :: window (40, zeile, 39, 6);{} show (f1); show (f2);{} cursor (f1, 2, 1); out (f1, anwendungstext (11));{} out (f1, tastenbezeichnung ( nach rechts));{} cursor (f1, 2, 2); out (f1, anwendungstext (12));{} out (f1, tastenbezeichnung ( nach links));{} - cursor (f1, 2, 3); out (f1, anwendungstext (13));{} out (f1, tastenbezeichnung ( nach oben));{} cursor (f1, 2, 4); out (f1, anwendungstext (14));{} out (f1, tastenbezeichnung ( nach unten));{} cursor (f1, 2, 5); out (f1, anwendungstext (15));{} out (f1, tastenbezeichnung ( ausbesserung));{} cursor (f1, 2, 6); out (f1, anwendungstext (16));{} out (f1, tastenbezeichnung ( naechstes));{} cursor (f2, 2, 1); out (f2, anwendungstext (17));{} - out (f2, text (anzahl aphasen, 4));{} cursor (f2, 2, 2); out (f2, anwendungstext (18));{} out (f2, text (aphasendauer, 4));{} out (f2, anwendungstext (51));{} cursor (f2, 2, 3); out (f2, anwendungstext (19));{} out (f2, text (pausendauer, 4));{} out (f2, anwendungstext (51));{} cursor (f2, 2, 4); out (f2, anwendungstext ( 5));{} out (f2, text (gesamtzeit, 4));{} out (f2, anwendungstext (51));{} - cursor (f2, 2, 6); out (f2, anwendungstext (251));{} out (f2, 3 * blank);{} out (f2, fehlerzeichen).{}END PROC gib bedieninformationen aus;{}INT PROC gesamtzeit:{} anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer{}END PROC gesamtzeit;{}PROC hole werkstueck (WERKSTUECK VAR w, INT VAR anzahl fehler):{} INT VAR spaltenzaehler, zeilenzaehler;{} anzahl fehler := 0;{} FOR zeilenzaehler FROM 1 UPTO hoehe REP{} ermittle eine zeile{} PER.{} - ermittle eine zeile:{} FOR spaltenzaehler FROM 1 UPTO breite REP{} ermittle eine position;{} ggf fehler registrieren{} PER.{} ermittle eine position:{} w [spaltenzaehler][zeilenzaehler] := zufallscode.{} zufallscode:{} random (kleinster code, groesster code).{} ggf fehler registrieren:{} IF w [spaltenzaehler][zeilenzaehler] = code (fehlerzeichen){} THEN anzahl fehler INCR 1{} FI.{}END PROC hole werkstueck;{}PROC zeige werkstueck (WERKSTUECK CONST w, WINDOW VAR f):{} - INT VAR spaltenzaehler, zeilenzaehler;{} page (f);{} FOR zeilenzaehler FROM 1 UPTO hoehe REP{} zeige eine zeile{} PER.{} zeige eine zeile:{} cursor (f, eckspalte, eckzeile + zeilenzaehler - 1);{} ggf invers einschalten;{} FOR spaltenzaehler FROM 1 UPTO breite REP{} out (f, code (w [spaltenzaehler][zeilenzaehler])){} PER;{} ggf invers ausschalten.{} ggf invers einschalten:{} IF inversdarstellung THEN out (f, markierung ein) FI.{} ggf invers ausschalten:{} IF inversdarstellung THEN out (f, markierung aus) FI.{} -END PROC zeige werkstueck;{}PROC kurzauswertung auf bildschirm (TEXT CONST dateiname):{} WINDOW VAR fenster :: window ( 2, 10, 77, 13);{} show (fenster);{} clear buffer;{} notiere ueberschrift;{} notiere ergebnis.{} notiere ueberschrift:{} cursor (fenster, 1, 1);{} out (fenster, center (fenster, anwendungstext (275)));{} cursor (fenster, 1, 2);{} out (fenster, center (fenster, anwendungstext (276))).{} notiere ergebnis:{} BOUND KONTROLLTABELLE CONST k := old (dateiname);{} ermittle die simulationsdaten;{} - notiere gesamtzahl werkstuecke;{} notiere zeichengesamtzahl;{} notiere bedienfehler;{} notiere benoetigte zeit;{} notiere gesamtausbesserungsrate;{} notiere gesamtbewertungsfaktor;{} notiere gesamtbewertungszahl mit pausenueberziehung;{} cursor (1, 24); out (anwendungstext (2));{} pause.{} ermittle die simulationsdaten:{} INT VAR z, anzahl zeichen pro werkstueck,{} anzahl werkstuecke :: 0,{} anzahl bedienfehler :: 0,{} anzahl produktionsfehler :: 0,{} - anzahl korrekturen :: 0;{} REAL VAR gesamtzahl zeichen, anteil korrekturen,{} gesamtzeit :: 0.0,{} pausenueberzug :: 0.0;{} FOR z FROM 1 UPTO k.letzter eintrag REP{} IF k.tabelle [z].eintragskennung = werkstueckendekennung{} THEN anzahl werkstuecke INCR 1;{} anzahl bedienfehler INCR k.tabelle [z].anzahl bedienfehler;{} anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;{} - anzahl korrekturen INCR k.tabelle [z].anzahl korrekturen;{} gesamtzeit INCR k.tabelle [z].differenz;{} ELIF k.tabelle [z].eintragskennung = pausenendekennung{} THEN pausenueberzug INCR k.tabelle [z].differenz;{} FI{} PER;{} anzahl zeichen pro werkstueck := k.breite * k.hoehe;{} gesamtzahl zeichen := real (anzahl werkstuecke){} * real (anzahl zeichen pro werkstueck);{} - IF anzahl produktionsfehler = 0{} THEN anteil korrekturen := 1.0{} ELSE anteil korrekturen := real (anzahl korrekturen){} / real (anzahl produktionsfehler){} FI.{} notiere gesamtzahl werkstuecke:{} cursor (fenster, 12, 4); out (fenster, anwendungstext (277));{} out (fenster, text (anzahl werkstuecke, 8)).{} notiere zeichengesamtzahl:{} cursor (fenster, 12, 5); out (fenster, anwendungstext (278));{} out (fenster, zahl aus zeichenkette).{} - zahl aus zeichenkette:{} subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).{} notiere bedienfehler:{} cursor (fenster, 12, 6); out (fenster, anwendungstext (279));{} out (fenster, text (anzahl bedienfehler, 8)).{} notiere benoetigte zeit:{} cursor (fenster, 12, 7); out (fenster, anwendungstext (280));{} out (fenster, text (gesamtzeit, 8, 2)).{} notiere gesamtausbesserungsrate:{} cursor (fenster, 12, 9); out (fenster, anwendungstext (281));{} - out (fenster, text (anteil korrekturen, 8, 2)).{} notiere gesamtbewertungsfaktor:{} cursor (fenster, 12,10); out (fenster, anwendungstext (282));{} out (fenster, text (bewertungsfaktor, 8, 2)).{} bewertungsfaktor:{} bewertungsmasszahl (anteil korrekturen).{} notiere gesamtbewertungszahl mit pausenueberziehung:{} cursor (fenster, 12, 12); out (fenster, (anwendungstext (283)));{} out (fenster, text (gesamtwertung, 8, 2));{} - cursor (fenster, 12, 13); out (fenster, (anwendungstext (284)));{} out (fenster, 8 * "=").{} gesamtwertung:{} IF gesamtzeit = 0.0{} THEN 0.0{} ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug){} * bewertungsfaktor{} FI.{}END PROC kurzauswertung auf bildschirm;{}PROC simulationsauswertung (TEXT CONST dateiname, BOOL CONST mit zeigen):{} TEXT CONST auswertdatei :: dateiname + auswertdateipostfix;{} ermittle die kenndaten aus der protokolldatei (dateiname);{} - notiere ueberschrift 1 (auswertdatei);{} notiere die kenndaten der simulation (auswertdatei);{} notiere die werkstueckkenndaten (auswertdatei);{} notiere ein beispielwerkstueck (auswertdatei);{} notiere ueberschrift 2 (auswertdatei);{} notiere gesamtergebnisse (auswertdatei, dateiname);{} notiere ueberschrift 3 (auswertdatei);{} notiere tabellenkopf (auswertdatei);{} notiere einzelne werkstueckdaten (auswertdatei, dateiname);{} - notiere ggf die anmerkungen;{} zeige ggf auswertung auf bildschirm.{} notiere ggf die anmerkungen:{} IF mit anmerkungen{} THEN notiere anmerkungen (auswertdatei);{} FI.{} zeige ggf auswertung auf bildschirm:{} IF mit zeigen{} THEN cursor on; show (auswertdatei); cursor off{} FI.{}END PROC simulationsauswertung;{}PROC ermittle die kenndaten aus der protokolldatei (TEXT CONST dateiname):{} BOUND KONTROLLTABELLE CONST k := old (dateiname);{} breite := k.breite;{} - hoehe := k.hoehe;{} kleinster code := k.kleinster code;{} groesster code := k.groesster code;{} fehlerzeichen := k.fehlerzeichen;{} inversdarstellung := k.inversdarstellung;{} nach rechts := k.nach rechts;{} nach links := k.nach links;{} nach oben := k.nach oben;{} nach unten := k.nach unten;{} ausbesserung := k.ausbesserung;{} naechstes := k.naechstes;{} - anzahl aphasen := k.anzahl aphasen;{} aphasendauer := k.aphasendauer;{} pausendauer := k.pausendauer;{} datum := k.datum;{} uhrzeit := k.uhrzeit;{} bewertung := k.bewertung;{}END PROC ermittle die kenndaten aus der protokolldatei;{}PROC notiere ueberschrift 1 (TEXT CONST auswertdatei):{} IF exists (auswertdatei){} THEN forget (auswertdatei, quiet){} FI;{} FILE VAR f :: sequential file (output, auswertdatei);{} - IF auswertung geht zum drucker{} THEN schreibe druckeranweisungen{} FI;{} putline (f, center (auswertdatei));{} putline (f, center (length (auswertdatei) * "="));{} put (f, anwendungstext (272)); put (f, datum); put (f, 26 * blank);{} put (f, anwendungstext (273)); putline (f, uhrzeit);{} line (f);{} putline (f, center (anwendungstext (291)));{} putline (f, center (length (anwendungstext (291)) * "=")).{} schreibe druckeranweisungen:{} write (f, "#type (""");{} write (f, protokollschrifttyp);{} - write (f, """)##limit (");{} write (f, text (schreibfeldbreite));{} write (f, ")##pagelength (");{} write (f, text (schreibfeldlaenge));{} write (f, ")##start (");{} write (f, text (xstart));{} write (f, ",");{} write (f, text (ystart));{} write (f, ")#"); line (f).{}END PROC notiere ueberschrift 1;{}PROC notiere ueberschrift 2 (TEXT CONST auswertdatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} putline (f, center (anwendungstext (285)));{} putline (f, center (length (anwendungstext (285)) * "=")){} -END PROC notiere ueberschrift 2;{}PROC notiere ueberschrift 3 (TEXT CONST auswertdatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} line (f, 2);{} putline (f, center (anwendungstext (311)));{} putline (f, center (length (anwendungstext (311)) * "="));{} line (f){}END PROC notiere ueberschrift 3;{}PROC notiere die kenndaten der simulation (TEXT CONST auswertdatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} ROW 6 TEXT VAR ausgabe;{} bestuecke ausgabezeilen;{} schreibe ausgabezeilen.{} - bestuecke ausgabezeilen:{} ausgabe [1] := anwendungstext (11){} + gleichlang (tastenbezeichnung (nach rechts ), 23){} + anwendungstext (17){} + text (anzahl aphasen, 4);{} ausgabe [2] := anwendungstext (12){} + gleichlang (tastenbezeichnung (nach links ), 23){} + anwendungstext (18){} + text (aphasendauer, 4) + anwendungstext (51);{} ausgabe [3] := anwendungstext (13){} - + gleichlang (tastenbezeichnung (nach oben ), 23){} + anwendungstext (19){} + text (pausendauer, 4) + anwendungstext (51);{} ausgabe [4] := anwendungstext (14){} + gleichlang (tastenbezeichnung (nach unten ), 23){} + anwendungstext ( 5){} + text (simulationsdauer, 4) + anwendungstext (51);{} ausgabe [5] := anwendungstext (15){} + gleichlang (tastenbezeichnung (ausbesserung), 23);{} - ausgabe [6] := anwendungstext (16){} + gleichlang (tastenbezeichnung (naechstes ), 23){} + anwendungstext (251){} + (3 * blank) + fehlerzeichen.{} simulationsdauer:{} anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer.{} schreibe ausgabezeilen:{} INT VAR i;{} FOR i FROM 1 UPTO 6 REP{} putline (f, ausgabe [i]){} PER;{} line (f).{}END PROC notiere die kenndaten der simulation;{}PROC notiere die werkstueckkenndaten (TEXT CONST auswertdatei):{} - FILE VAR f :: sequential file (output, auswertdatei);{} ROW 4 TEXT VAR ausgabe;{} bestuecke ausgabezeilen;{} schreibe ausgabezeilen.{} bestuecke ausgabezeilen:{} ausgabe [1] := anwendungstext (292) + text (breite, 4) +{} anwendungstext (296);{} ausgabe [2] := anwendungstext (293) + text (hoehe, 4) +{} anwendungstext (296);{} ausgabe [3] := anwendungstext (294) + text (breite * hoehe, 4) +{} anwendungstext (296);{} - ausgabe [4] := anwendungstext (295) + zeichenumfang.{} zeichenumfang:{} " " + code (kleinster code) + " ... " + code (groesster code) +{} " (" + text (groesster code - kleinster code + 1, 3) +{} anwendungstext (296) + ")".{} schreibe ausgabezeilen:{} INT VAR i;{} FOR i FROM 1 UPTO 4 REP putline (f, ausgabe [i]) PER;{} line (f).{}END PROC notiere die werkstueckkenndaten;{}PROC notiere ein beispielwerkstueck (TEXT CONST auswertdatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} - WERKSTUECK VAR beispiel;{} INT VAR beispielfehler;{} hole werkstueck (beispiel, beispielfehler);{} notiere ueberschrift;{} notiere werkstueckzeilen;{} notiere werkstueckleerzeilen.{} notiere ueberschrift:{} putline (f, center (anwendungstext (297)));{} putline (f, center (length (anwendungstext (297)) * "-")).{} notiere werkstueckzeilen:{} INT VAR bs, bz;{} FOR bz FROM 1 UPTO hoehe REP{} notiere eine zeile{} PER.{} notiere eine zeile:{} TEXT VAR beispielzeile :: "";{} - konstruiere beispielzeile;{} gib beispielzeile aus.{} konstruiere beispielzeile:{} beispielzeile CAT (((80 - breite) DIV 2) * blank);{} FOR bs FROM 1 UPTO breite REP{} beispielzeile CAT code (beispiel [bs][bz]){} PER.{} gib beispielzeile aus:{} putline (f, beispielzeile).{} notiere werkstueckleerzeilen:{} line (f, maxzeilen - hoehe + 1).{}END PROC notiere ein beispielwerkstueck;{}PROC notiere gesamtergebnisse (TEXT CONST auswertdatei, protokolldatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} - BOUND KONTROLLTABELLE CONST k :: old (protokolldatei);{} ermittle die simulationsdaten;{} notiere gesamtzahl werkstuecke;{} notiere anzahl zeichen pro werkstueck;{} notiere zeichengesamtzahl;{} notiere bedienfehler;{} notiere produktionsfehlerzahl;{} notiere fehlerkorrekturen;{} notiere gesamtzeit mit pausenueberziehung;{} notiere zeichenzahl pro sekunde mit;{} notiere gesamtausbesserungsrate;{} notiere gesamtbewertungsfaktor mit;{} notiere gesamtbewertungszahl mit;{} - notiere gesamtzeit ohne pausenueberziehung;{} notiere zeichenzahl pro sekunde ohne;{} notiere gesamtbewertungszahl ohne.{} ermittle die simulationsdaten:{} INT VAR z, anzahl zeichen pro werkstueck,{} anzahl werkstuecke :: 0,{} anzahl bedienfehler :: 0,{} anzahl produktionsfehler :: 0,{} anzahl korrekturen :: 0;{} REAL VAR gesamtzahl zeichen, anteil korrekturen,{} gesamtzeit :: 0.0,{} - pausenueberzug :: 0.0;{} FOR z FROM 1 UPTO k.letzter eintrag REP{} IF k.tabelle [z].eintragskennung = werkstueckendekennung{} THEN anzahl werkstuecke INCR 1;{} anzahl bedienfehler INCR k.tabelle [z].anzahl bedienfehler;{} anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler;{} anzahl korrekturen INCR k.tabelle [z].anzahl korrekturen;{} gesamtzeit INCR k.tabelle [z].differenz;{} - ELIF k.tabelle [z].eintragskennung = pausenendekennung{} THEN pausenueberzug INCR k.tabelle [z].differenz;{} FI{} PER;{} anzahl zeichen pro werkstueck := k.breite * k.hoehe;{} gesamtzahl zeichen := real (anzahl werkstuecke){} * real (anzahl zeichen pro werkstueck);{} IF anzahl produktionsfehler = 0{} THEN anteil korrekturen := 1.0{} ELSE anteil korrekturen := real (anzahl korrekturen){} - / real (anzahl produktionsfehler){} FI.{} notiere gesamtzahl werkstuecke:{} put (f, anwendungstext (277)); putline (f, text (anzahl werkstuecke, 8)).{} notiere anzahl zeichen pro werkstueck:{} put (f, anwendungstext (286)); putline (f, text (breite * hoehe, 8)).{} notiere zeichengesamtzahl:{} put (f, anwendungstext (278)); putline (f, zahl aus zeichenkette);{} line (f).{} zahl aus zeichenkette:{} subtext (text (gesamtzahl zeichen, 9, 0), 1, 8).{} - notiere produktionsfehlerzahl:{} put (f, anwendungstext (287)); putline (f, text (anzahl produktionsfehler, 8)).{} notiere fehlerkorrekturen:{} put (f, anwendungstext (288)); putline (f, text (anzahl korrekturen, 8)).{} notiere bedienfehler:{} put (f, anwendungstext (279)); putline (f, text (anzahl bedienfehler,8));{} line (f).{} notiere gesamtzeit mit pausenueberziehung:{} put (f, anwendungstext (301)); put (f, text (gesamtzeit mit, 8, 1));{} putline (f, anwendungstext (300)).{} - gesamtzeit mit:{} gesamtzeit + pausenueberzug.{} notiere zeichenzahl pro sekunde mit:{} put (f, anwendungstext (302));{} putline (f, text (zeichenpro sec mit, 8, 1));{} line (f).{} zeichen pro sec mit:{} IF gesamtzeit + pausenueberzug > 0.0{} THEN gesamtzahl zeichen / (gesamtzeit + pausenueberzug){} ELSE 0.0{} FI.{} notiere gesamtausbesserungsrate:{} put (f, anwendungstext (281)); putline (f, text (anteil korrekturen, 8, 1)).{} notiere gesamtbewertungsfaktor mit:{} - put (f, anwendungstext (282)); putline (f, text (bewertungsfaktor, 8, 1));{} line (f).{} bewertungsfaktor:{} bewertungsmasszahl (anteil korrekturen).{} notiere gesamtbewertungszahl mit:{} put (f, (anwendungstext (283))); putline (f, text (gesamtwertung mit, 8, 1));{} put (f, (anwendungstext (284))); putline (f, 8 * "=").{} gesamtwertung mit:{} IF gesamtzeit = 0.0{} THEN 0.0{} ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug){} * bewertungsfaktor{} - FI.{} notiere gesamtzeit ohne pausenueberziehung:{} put (f, anwendungstext (303)); put (f, text (gesamtzeit, 8, 1));{} putline (f, anwendungstext (300)).{} notiere zeichenzahl pro sekunde ohne:{} put (f, anwendungstext (302));{} putline (f, text (zeichenpro sec ohne, 8, 1)).{} zeichen pro sec ohne:{} IF gesamtzeit > 0.0{} THEN gesamtzahl zeichen / gesamtzeit{} ELSE 0.0{} FI.{} notiere gesamtbewertungszahl ohne:{} put (f, (anwendungstext (304))); putline (f, text (gesamtwertung ohne, 8, 1));{} - put (f, (anwendungstext (284))); putline (f, 8 * "=").{} gesamtwertung ohne:{} IF gesamtzeit = 0.0{} THEN 0.0{} ELSE gesamtzahl zeichen / gesamtzeit * bewertungsfaktor{} FI.{}END PROC notiere gesamtergebnisse;{}PROC notiere tabellenkopf (TEXT CONST auswertdatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} putline (f, anwendungstext (312));{} putline (f, anwendungstext (313));{} putline (f, anwendungstext (314));{} putline (f, anwendungstext (315));{} putline (f, anwendungstext (316));{} - putline (f, anwendungstext (317));{} putline (f, anwendungstext (318));{}END PROC notiere tabellenkopf;{}PROC notiere einzelne werkstueckdaten (TEXT CONST auswertdatei, dateiname):{} BOUND KONTROLLTABELLE CONST k :: old (dateiname);{} FILE VAR f :: sequential file (output, auswertdatei);{} INT VAR zeiger, werkstuecknummer :: 0;{} TEXT VAR ausgabezeile :: "";{} FOR zeiger FROM 1 UPTO k.letzter eintrag REP{} notiere bearbeitungszeile{} PER.{} notiere bearbeitungszeile:{} IF k.tabelle [zeiger].eintragskennung = werkstueckendekennung{} - THEN werkstuecknummer INCR 1;{} schreibe werkstueckzeile{} ELIF k.tabelle [zeiger].eintragskennung = pausenendekennung{} THEN schreibe pausenzeile{} ELIF k.tabelle [zeiger].eintragskennung = simulationsendekennung{} THEN werkstuecknummer INCR 1;{} schreibe abschluss{} ELSE putline (f, 75 * "?"){} FI.{} schreibe werkstueckzeile:{} konstruiere ausgabezeile;{} putline (f, ausgabezeile).{} konstruiere ausgabezeile:{} ausgabezeile := "";{} - ausgabezeile CAT text (werkstuecknummer, 5);{} ausgabezeile CAT 2 * blank;{} ausgabezeile CAT trenn;{} ausgabezeile CAT text (k.tabelle [zeiger].anzahl bedienfehler, 5);{} ausgabezeile CAT 3 * blank;{} ausgabezeile CAT trenn;{} ausgabezeile CAT text (k.tabelle [zeiger].produktionsfehler, 6);{} ausgabezeile CAT 2 * blank;{} ausgabezeile CAT trenn;{} ausgabezeile CAT text (k.tabelle [zeiger].anzahl korrekturen, 6);{} ausgabezeile CAT 2 * blank;{} ausgabezeile CAT trenn;{} - ausgabezeile CAT text (k.tabelle [zeiger].differenz, 6, 1);{} ausgabezeile CAT blank;{} ausgabezeile CAT trenn;{} ausgabezeile CAT text (zeichen pro zeiteinheit, 6, 1);{} ausgabezeile CAT blank;{} ausgabezeile CAT trenn;{} ausgabezeile CAT text (einzelausbesserungsrate, 6, 1);{} ausgabezeile CAT blank;{} ausgabezeile CAT trenn;{} ausgabezeile CAT text (bewertungsmasszahl (einzelausbesserungsrate), 6, 1);{} ausgabezeile CAT blank;{} ausgabezeile CAT trenn;{} - ausgabezeile CAT text (endbewertungszahl, 6, 1);{} ausgabezeile CAT blank.{} zeichen pro zeiteinheit:{} real (breite * hoehe) / k.tabelle [zeiger].differenz.{} einzelausbesserungsrate:{} IF k.tabelle [zeiger].produktionsfehler = 0{} THEN 0.0{} ELSE real (k.tabelle [zeiger].anzahl korrekturen){} / real (k.tabelle [zeiger].produktionsfehler ){} FI.{} endbewertungszahl:{} real (breite * hoehe) / k.tabelle [zeiger].differenz{} * bewertungsmasszahl (einzelausbesserungsrate).{} - schreibe pausenzeile:{} line (f);{} put (f, anwendungstext (320));{} put (f, text (k.tabelle [zeiger].differenz, 6, 1));{} putline (f, anwendungstext (300));{} line (f).{} schreibe abschluss:{} putline (f, anwendungstext (318));{} putline (f, anwendungstext (319));{} line (f);{} konstruiere ausgabezeile;{} ausgabezeile := "(" +{} subtext (ausgabezeile, 2, length (ausgabezeile) - 1) +{} ")";{} putline (f, ausgabezeile).{} -END PROC notiere einzelne werkstueckdaten;{}PROC notiere anmerkungen (TEXT CONST auswertdatei):{} FILE VAR f :: sequential file (output, auswertdatei);{} line (f);{} schreibe kopf;{} schreibe hinweis auf letztes werkstueck;{} schreibe hinweis auf bedienfehler;{} erlaeutere bewertungsschluessel;{} stelle bewertungsschluessel graphisch dar;{} schreibe rest.{} schreibe kopf:{} putline (f, center (anwendungstext (325)));{} putline (f, center (length (anwendungstext (325)) * "="));{} line (f).{} - schreibe hinweis auf letztes werkstueck:{} INT VAR i;{} FOR i FROM 326 UPTO 337 REP{} putline (f, anwendungstext (i)){} PER;{} line (f).{} schreibe hinweis auf bedienfehler:{} FOR i FROM 339 UPTO 341 REP{} putline (f, anwendungstext (i)){} PER;{} line (f).{} erlaeutere bewertungsschluessel:{} FOR i FROM 343 UPTO 372 REP{} putline (f, anwendungstext (i)){} PER.{} stelle bewertungsschluessel graphisch dar:{} putline (f, anwendungstext (374));{} putline (f, anwendungstext (375));{} - ermittle die startposition;{} zeichne diagramm;{} trage werte ein.{} ermittle die startposition:{} modify (f);{} INT VAR zeilenpos :: lines (f) + 2, spaltenpos :: 18.{} zeichne diagramm:{} cursor (f, spaltenpos, zeilenpos , anwendungstext (20));{} cursor (f, spaltenpos, zeilenpos + 1, anwendungstext (21));{} cursor (f, spaltenpos, zeilenpos + 3, anwendungstext (23));{} cursor (f, spaltenpos, zeilenpos + 4, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 5, anwendungstext (22));{} - cursor (f, spaltenpos, zeilenpos + 6, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 7, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 8, anwendungstext (24));{} cursor (f, spaltenpos, zeilenpos + 9, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 10, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 11, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 12, anwendungstext (22));{} cursor (f, spaltenpos, zeilenpos + 13, anwendungstext (25));{} - cursor (f, spaltenpos, zeilenpos + 14, anwendungstext (26));{} cursor (f, spaltenpos, zeilenpos + 15, anwendungstext (27)).{} trage werte ein:{} zeilenpos INCR 13;{} INT VAR bwzeiger;{} FOR bwzeiger FROM 1 UPTO 11 REP{} cursor (f, spaltenpos + 3 * bwzeiger, zeilenpos - konkreter wert, "+"){} PER.{} konkreter wert:{} int (bewertung [bwzeiger] * 10.0).{} schreibe rest:{} output (f);{} line (f, 2);{} FOR i FROM 377 UPTO 387 REP{} putline (f, anwendungstext (i)){} - PER;{} haenge an jede zeile ein blank an.{} haenge an jede zeile ein blank an:{} TEXT VAR inhalt;{} INT VAR zeilenzeiger;{} modify (f);{} FOR zeilenzeiger FROM 1 UPTO lines (f) REP{} to line (f, zeilenzeiger);{} read record (f, inhalt);{} inhalt CAT blank;{} write record (f, inhalt){} PER;{} to line (f,1).{}END PROC notiere anmerkungen;{}PROC cursor (FILE VAR f, INT CONST spa, zei, TEXT CONST text):{} positioniere an zeile;{} positioniere an spalte;{} - gib text an position aus.{} positioniere an zeile:{} IF zeile noch nicht vorhanden{} THEN schaffe zeile und gehe dorthin{} ELSE to line (f,zei){} FI.{} zeile noch nicht vorhanden:{} zei > lines (f).{} schaffe zeile und gehe dorthin:{} INT VAR zaehler 1;{} IF lines (f) = 0{} THEN to line (f,lines (f));{} insert record (f);{} FI;{} FOR zaehler 1 FROM lines (f) UPTO zei REP{} to line (f,lines (f));{} down (f);insert record (f){} PER;{} - to line(f,zei).{} positioniere an spalte:{} TEXT VAR alter satz :: "", neuer satz :: "", restsatz ::"";{} INT VAR satzlaenge;{} read record (f,alter satz);{} satzlaenge := length (alter satz);{} IF satzlaenge = 0{} THEN neuer satz CAT (spa -1) * " "{} ELIF satzlaenge >= spa{} THEN neuer satz := subtext(alter satz,1,spa-1);{} restsatz := subtext(alter satz, spa + length (text));{} ELSE neuer satz := alter satz;{} neuer satz CAT (spa - satzlaenge - 1) * " "{} - FI.{} gib text an position aus:{} neuer satz CAT text;{} IF restsatz <> ""{} THEN neuer satz CAT restsatz{} FI;{} write record(f,neuer satz).{} END PROC cursor;{}TEXT PROC gleichlang (TEXT CONST text, INT CONST laenge):{} TEXT VAR intern :: compress (text);{} INT VAR anzahl :: laenge - length (intern);{} IF anzahl < 0{} THEN subtext (intern, 1, laenge){} ELSE intern + (anzahl * blank){} FI{}END PROC gleichlang;{}REAL PROC bewertungsmasszahl (REAL CONST wert):{} REAL VAR interner wert := round (wert, 1);{} - IF interner wert > wert{} THEN interner wert DECR 0.1{} FI;{} interpoliere.{} interpoliere:{} REAL VAR unterer wert, oberer wert;{} unterer wert := interner wert;{} IF unterer wert = 1.0{} THEN oberer wert := 1.0{} ELSE oberer wert := unterer wert + 0.1{} FI;{} unterer wert := bewertung (int (unterer wert * 10.0) + 1);{} oberer wert := bewertung (int (oberer wert * 10.0) + 1);{} unterer wert + (oberer wert - unterer wert) * faktor.{} faktor:{} frac (wert * 10.0).{} -END PROC bewertungsmasszahl;{}PROC zeige aktuellen protokollumfang an:{} WINDOW VAR w :: window (2, 2, 34, 5);{} show (w);{} cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));{} IF mit anmerkungen{} THEN cursor (w, 2, 4); out (w, anwendungstext (432)){} ELSE cursor (w, 2, 4); out (w, anwendungstext (433));{} FI.{}END PROC zeige aktuellen protokollumfang an;{}PROC gib erlaeuterungen zum protokollumfang:{} WINDOW VAR f :: window ( 2, 9, 77, 15);{} show (f);{} cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (434))));{} - cursor (f, 5, 3); out (f, anwendungstext (435));{} cursor (f, 5, 4); out (f, anwendungstext (436));{} cursor (f, 5, 5); out (f, anwendungstext (437));{} cursor (f, 5, 6); out (f, anwendungstext (438));{} cursor (f, 5, 8); out (f, anwendungstext (439));{} cursor (f, 5, 9); out (f, anwendungstext (440));{} cursor (f, 5,10); out (f, anwendungstext (441));{} cursor (f, 5,11); out (f, anwendungstext (442));{} cursor (f, 5,13); out (f, anwendungstext (443));{} cursor (f, 5,14); out (f, anwendungstext (444));{} -END PROC gib erlaeuterungen zum protokollumfang;{}PROC frage nach umfangsaenderung:{} WINDOW VAR fenster :: window (38, 2, 41, 5);{} show (fenster);{} cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (451))));{} cursor (fenster, 4, 3); out (fenster, anwendungstext (452));{} cursor (fenster, 4, 4);{} IF yes (fenster, anwendungstext (453)){} THEN mit anmerkungen := NOT mit anmerkungen{} FI.{}END PROC frage nach umfangsaenderung;{}PROC zeige aktuelle kurzauswertungseinstellung an:{} - WINDOW VAR w :: window ( 2, 2, 34, 5);{} show (w);{} cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431))));{} IF mit kurzprotokoll{} THEN cursor (w, 7, 4); out (w, anwendungstext (461));{} ELSE cursor (w, 7, 4); out (w, anwendungstext (462));{} FI.{}END PROC zeige aktuelle kurzauswertungseinstellung an;{}PROC gib erlaeuterungen zur kurzauswertung:{} WINDOW VAR f :: window ( 2, 9, 77, 15);{} show (f);{} cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (463))));{} - cursor (f, 5, 3); out (f, anwendungstext (464));{} cursor (f, 5, 4); out (f, anwendungstext (465));{} cursor (f, 5, 5); out (f, anwendungstext (466));{} cursor (f, 5, 6); out (f, anwendungstext (467));{} cursor (f, 5, 8); out (f, anwendungstext (468));{} cursor (f, 5, 9); out (f, anwendungstext (469));{} cursor (f, 5,10); out (f, anwendungstext (470));{} cursor (f, 5,11); out (f, anwendungstext (471));{} cursor (f, 5,13); out (f, anwendungstext (472));{} cursor (f, 5,14); out (f, anwendungstext (473));{} -END PROC gib erlaeuterungen zur kurzauswertung;{}PROC frage nach kurzauswertungsaenderung:{} WINDOW VAR fenster :: window (38, 2, 41, 5);{} show (fenster);{} cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (481))));{} cursor (fenster, 5, 3); out (fenster, anwendungstext (482));{} cursor (fenster, 5, 4);{} IF yes (fenster, anwendungstext (483)){} THEN mit kurzprotokoll := NOT mit kurzprotokoll{} FI.{}END PROC frage nach kurzauswertungsaenderung;{}END PACKET ls mp bap 2;{} + maxzeilen = 14, + blank = " ", + trenn = "|", + werkstueckendekennung = 1, + pausenendekennung = 2, + simulationsendekennung = 3, + markierung ein = ""15"", + markierung aus = " "14"", + stdschrifttyp = "", + + stdxstart = 0.0, + stdystart = 0.0, + stdfeldbreite = 21.0, + stdfeldlaenge = 29.5; +LET KONTROLLTABELLE = STRUCT (INT letzter eintrag, + breite, hoehe, + kleinster code, groesster code, + anzahl aphasen, aphasendauer, + pausendauer, + + TEXT datum, uhrzeit, fehlerzeichen, + nach rechts, nach links, + nach oben, nach unten, + ausbesserung, naechstes, + BOOL inversdarstellung, + ROW 11 REAL bewertung, + ROW maxeintraege KONTROLLE tabelle), + KONTROLLE = STRUCT (INT eintragskennung, + produktionsfehler, + + anzahl korrekturen, + anzahl bedienfehler, + REAL anfang, ende, differenz), + WERKSTUECK = ROW maxspalten ROW maxzeilen INT; +INT VAR breite, hoehe, kleinster code, groesster code, + anzahl aphasen, aphasendauer, pausendauer, + eckspalte, eckzeile, x, y, xsize, ysize; +TEXT VAR fehlerzeichen, nach rechts, nach links, nach oben, nach unten, + ausbesserung, naechstes, datum, uhrzeit; + +TEXT VAR protokollschrifttyp :: stdschrifttyp; +REAL VAR xstart :: stdxstart, + ystart :: stdystart, + schreibfeldbreite :: stdfeldbreite, + schreibfeldlaenge :: stdfeldlaenge; +ROW 11 REAL VAR bewertung; +BOOL VAR inversdarstellung, + kontrolldatei zur vatertask :: TRUE, + mit kurzprotokoll :: TRUE, + mit anmerkungen :: TRUE, + auswertung geht zum drucker :: FALSE; +WERKSTUECK VAR werkstueck; + +PROC bildschirmarbeitsplatz: + kontrolldatei zur vatertask := FALSE; + install menu (menukarte); + handle menu (menubezeichnung); +END PROC bildschirmarbeitsplatz; +PROC bap: + bildschirmarbeitsplatz +END PROC bap; +PROC materialpruefung: + TEXT VAR benutzerkennung :: "", protokollname, alter dateiname :: std; + install menu (menukarte, FALSE); + kontrolldatei zur vatertask := TRUE; + ermittle eingestellte parameter; + bereite den bildschirm vor; + ermittle die benutzerkennung; + gib benutzerhinweise aus; + + arbeitsplatzsimulation ausfuehren (benutzerkennung, protokollname); + forget (protokollname, quiet); + last param (alter dateiname). + bereite den bildschirm vor: + WINDOW VAR w :: window ( 2, 10, 77, 14); + page; + show (w); + out (w, center (w, anwendungstext (400))). + ermittle die benutzerkennung: + benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5)); + IF benutzerkennung = "" + THEN cursor on; page; + LEAVE materialpruefung + FI. + + gib benutzerhinweise aus: + boxinfo (w, anwendungstext (402)); + boxinfo (w, anwendungstext (403)); + boxinfo (w, anwendungstext (404)); + gib bedieninformationen aus (2); + boxinfo (w, anwendungstext (405)); + boxinfo (w, anwendungstext (406)); + boxinfo (w, anwendungstext (407)); + boxinfo (w, anwendungstext (408)). +END PROC materialpruefung; +PROC mp: + materialpruefung +END PROC mp; +PROC mp bap simulation ausfuehren: + TEXT VAR benutzerkennung :: "", dateiname; + + kontrolldatei zur vatertask := FALSE; + ermittle eingestellte parameter; + bereite den bildschirm vor; + ermittle die benutzerkennung; + arbeitsplatzsimulation ausfuehren (benutzerkennung, dateiname); + regenerate menuscreen. + bereite den bildschirm vor: + WINDOW VAR w :: window (2,2,77,22); + page; + out (w, center (w, anwendungstext (399))). + ermittle die benutzerkennung: + benutzerkennung := compress (boxanswer (w, anwendungstext (401), "", 5)); + IF benutzerkennung = "" + + THEN regenerate menuscreen; + LEAVE mp bap simulation ausfuehren + FI. +END PROC mp bap simulation ausfuehren; +PROC mp bap auswertung auf bildschirm: + auswertung geht zum drucker := FALSE; + lasse protokolldateien auswaehlen; + werte protokolldateien aus; + regenerate menuscreen. + lasse protokolldateien auswaehlen: + THESAURUS VAR verfuegbare; + verfuegbare := infix namen (ALL myself, protokolldateipraefix, + protokolldateityp); + + IF NOT not empty (verfuegbare) + THEN noch kein protokoll + ELSE biete auswahl an + FI. + noch kein protokoll: + regenerate menuscreen; + menuinfo (anwendungstext (424)); + LEAVE mp bap auswertung auf bildschirm. + biete auswahl an: + verfuegbare := menusome (verfuegbare, anwendungstext (421), + anwendungstext (422), FALSE). + werte protokolldateien aus: + INT VAR k; + steige ggf bei leerem thesaurus aus; + FOR k FROM 1 UPTO highest entry (verfuegbare) REP + + IF name (verfuegbare, k) <> "" + THEN disable stop; + gib hinweis auf auswertung; + simulationsauswertung (name (verfuegbare, k), TRUE); + forget (name (verfuegbare, k) + auswertdateipostfix, quiet); + fehlerbehandlung + FI + PER. + steige ggf bei leerem thesaurus aus: + IF NOT not empty (verfuegbare) + THEN regenerate menuscreen; + menuinfo (anwendungstext (423)); + LEAVE mp bap auswertung auf bildschirm + + FI. + gib hinweis auf auswertung: + page; + WINDOW VAR fenster :: window ( 2, 2, 77, 22); + show (fenster); + cursor (fenster, 1, 9); out (fenster, center (fenster, name (verfuegbare, k))); + cursor (fenster, 1, 12); out (fenster, center (anwendungstext (274))). + fehlerbehandlung: + IF is error + THEN regenerate menuscreen; + menuinfo (invers (errormessage)); + clear error; enable stop; + LEAVE mp bap auswertung auf bildschirm + FI. + +END PROC mp bap auswertung auf bildschirm; +PROC mp bap drucken von auswertungen: + auswertung geht zum drucker := TRUE; + lasse protokolldateien auswaehlen; + werte protokolldateien aus; + regenerate menuscreen. + lasse protokolldateien auswaehlen: + THESAURUS VAR verfuegbare; + verfuegbare := infix namen (ALL myself, protokolldateipraefix, + protokolldateityp); + IF NOT not empty (verfuegbare) + THEN noch kein protokoll + ELSE biete auswahl an + + FI. + noch kein protokoll: + regenerate menuscreen; + menuinfo (anwendungstext (424)); + LEAVE mp bap drucken von auswertungen. + biete auswahl an: + verfuegbare := menusome (verfuegbare, anwendungstext (425), + anwendungstext (422), FALSE). + werte protokolldateien aus: + INT VAR k; + steige ggf bei leerem thesaurus aus; + FOR k FROM 1 UPTO highest entry (verfuegbare) REP + IF name (verfuegbare, k) <> "" + THEN disable stop; + gib hinweis auf auswertung; + + simulationsauswertung (name (verfuegbare, k), FALSE); + print (name (verfuegbare, k) + auswertdateipostfix); + forget (name (verfuegbare, k) + auswertdateipostfix, quiet); + fehlerbehandlung + FI + PER. + steige ggf bei leerem thesaurus aus: + IF NOT not empty (verfuegbare) + THEN regenerate menuscreen; + menuinfo (anwendungstext (423)); + LEAVE mp bap drucken von auswertungen + FI. + gib hinweis auf auswertung: + + page; + WINDOW VAR fenster :: window ( 2, 2, 77, 22); + show (fenster); + cursor (fenster, 1, 9); out (fenster, center (fenster, name (verfuegbare, k))); + cursor (fenster, 1, 12); out (fenster, center (anwendungstext (270))). + fehlerbehandlung: + IF is error + THEN regenerate menuscreen; + menuinfo (invers (errormessage)); + clear error; enable stop; + LEAVE mp bap drucken von auswertungen + FI. +END PROC mp bap drucken von auswertungen; + +PROC mp bap protokollumfang festlegen: + page; + zeige aktuellen protokollumfang an; + gib erlaeuterungen zum protokollumfang; + frage nach umfangsaenderung; + regenerate menuscreen +END PROC mp bap protokollumfang festlegen; +PROC mp bap kurzauswertung: + page; + zeige aktuelle kurzauswertungseinstellung an; + gib erlaeuterungen zur kurzauswertung; + frage nach kurzauswertungsaenderung; + regenerate menuscreen +END PROC mp bap kurzauswertung; +PROC druckereinstellung fuer protokolldatei (TEXT CONST schrifttyp, + + REAL CONST linker rand, + oberer rand, + feldbreite, + feldlaenge): + protokollschrifttyp := schrifttyp; + xstart := linker rand; + ystart := oberer rand; + schreibfeldbreite := feldbreite; + schreibfeldlaenge := feldlaenge; +END PROC druckereinstellung fuer protokolldatei; + +PROC stddruckereinstellung fuer protokolldatei: + protokollschrifttyp := stdschrifttyp; + xstart := stdxstart; + ystart := stdystart; + schreibfeldbreite := stdfeldbreite; + schreibfeldlaenge := stdfeldlaenge +END PROC stddruckereinstellung fuer protokolldatei; + (********************************) +PROC arbeitsplatzsimulation ausfuehren (TEXT CONST kennung, + TEXT VAR dateiname): + ermittle eingestellte parameter; + + lege datei mit kennung an (kennung, dateiname); + cursor on; + fuehre simulation durch (dateiname); + schicke ggf protokolldatei zur vatertask; + gib ggf kurzprotokoll aus. + schicke ggf protokolldatei zur vatertask: + IF kontrolldatei zur vatertask + THEN command dialogue (FALSE); + save (dateiname); + command dialogue (TRUE) + FI. + gib ggf kurzprotokoll aus: + IF mit kurzprotokoll + THEN kurzauswertung auf bildschirm (dateiname) + ELSE page; put (anwendungstext (271)) + + FI. +END PROC arbeitsplatzsimulation ausfuehren; +PROC ermittle eingestellte parameter: + werkstueckdefinition (breite, hoehe, kleinster code, groesster code, + fehlerzeichen, inversdarstellung); + tastendefinition (nach rechts, nach links, nach oben, nach unten, + ausbesserung, naechstes); + phasendefinition (anzahl aphasen, aphasendauer, pausendauer); + bewertungsschluessel (bewertung); +END PROC ermittle eingestellte parameter; +PROC lege datei mit kennung an (TEXT CONST kennung, TEXT VAR datname): + + BOUND KONTROLLTABELLE VAR tab; + TEXT VAR interner name :: protokolldateipraefix; + interner name CAT kennung; + lege neue datei an; + type (old (datname), protokolldateityp). + lege neue datei an: + INT VAR i :: 0; TEXT VAR bezeichnung; + REP + i INCR 1; + bezeichnung := interner name + " /" + text (i) + UNTIL NOT exists (bezeichnung) PER; + tab := new (bezeichnung); + initialisiere tabelle; + datname := bezeichnung. + initialisiere tabelle: + tab.letzter eintrag := 0. + +END PROC lege datei mit kennung an; +PROC fuehre simulation durch (TEXT CONST dateiname): + BOUND KONTROLLTABELLE VAR tab :: old (dateiname); + TEXT CONST moegliche eingabezeichen :: nach rechts + nach links + + nach oben + nach unten + + ausbesserung + naechstes; + treffe vorbereitungen; + trage grunddaten in tabelle; + simuliere. + treffe vorbereitungen: + initialisierungen; + WINDOW VAR fenster :: window ( 1, 9, 79, 16); + + page; + gib bedieninformationen aus (2); + werkstueckaufhaenger (eckspalte, eckzeile); + weise auf arbeitsbeginn hin; + beginn der arbeitsphase := clock (1); + beginn der bearbeitung := beginn der arbeitsphase; + arbeitsphasenlaenge := real (aphasendauer * 60). + initialisierungen: + INT VAR eintragzaehler :: 0, + arbeitsphasenzaehler :: 1, + werkstueckzaehler :: 0, + bedienfehlerzaehler :: 0, + + korrekturzaehler :: 0, + produktionsfehler, + cursorspalte relativ, + cursorzeile relativ; + REAL VAR beginn der arbeitsphase, + beginn der bearbeitung, + arbeitsphasenlaenge, + arbeitsphasenueberziehung, + pausenueberziehung. + weise auf arbeitsbeginn hin: + page (fenster); + boxinfo (fenster, anwendungstext (252), 5, maxint); + clear buffer. + trage grunddaten in tabelle: + tab.datum := date; + + tab.uhrzeit := time of day; + tab.breite := breite; + tab.hoehe := hoehe; + tab.kleinster code := kleinster code; + tab.groesster code := groesster code; + tab.anzahl aphasen := anzahl aphasen; + tab.aphasendauer := aphasendauer; + tab.pausendauer := pausendauer; + tab.fehlerzeichen := fehlerzeichen; + tab.nach rechts := nach rechts; + tab.nach links := nach links; + tab.nach oben := nach oben; + + tab.nach unten := nach unten; + tab.ausbesserung := ausbesserung; + tab.naechstes := naechstes; + tab.inversdarstellung := inversdarstellung; + tab.bewertung := bewertung; + eintragzaehler := 1. + simuliere: + REP + gib holehinweis; + hole werkstueck (werkstueck, produktionsfehler); + zeige werkstueck (werkstueck, fenster); + lasse werkstueck bearbeiten + UNTIL simulationsende erreicht PER. + gib holehinweis: + + page (fenster); + cursor (fenster, 2, 3); out (fenster, anwendungstext (253)). + lasse werkstueck bearbeiten: + initialisiere den relativcursor; + setze cursor; + clear buffer; + bearbeite das werkstueck. + initialisiere den relativcursor: + cursorspalte relativ := 1; + cursorzeile relativ := 1. + setze cursor: + IF inversdarstellung + THEN cursor (fenster, eckspalte + cursorspalte relativ, + eckzeile + cursorzeile relativ - 1); + + ELSE cursor (fenster, eckspalte + cursorspalte relativ - 1, + eckzeile + cursorzeile relativ - 1); + FI. + bearbeite das werkstueck: + BOOL VAR werkstueck voll bearbeitet :: FALSE; + REP + hole eingabe und werte aus + UNTIL werkstueck voll bearbeitet PER. + hole eingabe und werte aus: + TEXT VAR eingabezeichen := incharety (100); + SELECT eingabezeichenposition OF + CASE 1: wenn moeglich nach rechts + CASE 2: wenn moeglich nach links + + CASE 3: wenn moeglich nach oben + CASE 4: wenn moeglich nach unten + CASE 5: wenn moeglich ausbessern + CASE 6: beende werkstueckbearbeitung + OTHERWISE entscheide ob gepiepst wird + END SELECT. + eingabezeichenposition: + pos (moegliche eingabezeichen, eingabezeichen). + wenn moeglich nach rechts: + IF cursorspalte relativ < breite + THEN cursorspalte relativ INCR 1; + setze cursor + ELSE registriere bedienfehler + FI. + wenn moeglich nach links: + + IF cursorspalte relativ > 1 + THEN cursorspalte relativ DECR 1; + setze cursor + ELSE registriere bedienfehler + FI. + wenn moeglich nach oben: + IF cursorzeile relativ > 1 + THEN cursorzeile relativ DECR 1; + setze cursor + ELSE registriere bedienfehler + FI. + wenn moeglich nach unten: + IF cursorzeile relativ < hoehe + THEN cursorzeile relativ INCR 1; + setze cursor + ELSE registriere bedienfehler + FI. + + wenn moeglich ausbessern: + IF werkstueck [cursorspalte relativ][cursorzeile relativ] = code (fehlerzeichen) + THEN werkstueck [cursorspalte relativ][cursorzeile relativ] := code (blank); + korrekturzaehler INCR 1; + get cursor (fenster, x, y); + out (fenster, blank); + cursor (fenster, x, y); + ELSE registriere bedienfehler + FI. + registriere bedienfehler: + piepse; bedienfehlerzaehler INCR 1. + entscheide ob gepiepst wird: + IF eingabezeichen <> "" THEN piepse FI. + + beende werkstueckbearbeitung: + IF simulationsende erreicht + THEN trage simulationsende in tabelle ein + ELIF arbeitsphasenende erreicht + THEN trage werkstueckdaten in tabelle ein; + ermittle ueberziehung der arbeitsphase; + lege eine pause ein + ELSE trage werkstueckdaten in tabelle ein + FI; + werkstueck voll bearbeitet := TRUE. + lege eine pause ein: + nimm pausendaten; + weise auf pausenanfang hin; + pausiere; + weise auf pausenende hin; + + registriere pausenueberziehung. + nimm pausendaten: + REAL VAR pausenanfang :: clock (1), + pausenende :: pausenanfang + real (pausendauer * 60);. + weise auf pausenanfang hin: + page (fenster); + boxnotice (fenster, anwendungstext (255), 5, x, y, xsize, ysize). + pausiere: + REP + pause (int ((pausenende - clock (1)) * 10.0)) + UNTIL clock (1) >= pausenende PER. + weise auf pausenende hin: + page (fenster); + pausenanfang := clock (1); + piepse; + + clear buffer; + boxinfo (fenster, anwendungstext (256), 5, maxint); + pausenende := clock (1). + registriere pausenueberziehung: + pausenueberziehung := pausenende - pausenanfang; + trage pausenueberziehung in tabelle ein. + trage werkstueckdaten in tabelle ein: + REAL VAR bearbeitungsende :: clock (1); + tab.tabelle [eintragzaehler].eintragskennung := werkstueckendekennung; + tab.tabelle [eintragzaehler].produktionsfehler := produktionsfehler; + tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler; + + tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler; + tab.tabelle [eintragzaehler].anfang := beginn der bearbeitung; + tab.tabelle [eintragzaehler].ende := bearbeitungsende; + tab.tabelle [eintragzaehler].differenz := bearbeitungszeit; + erhoehe eintragzaehler; + beginn der bearbeitung := clock (1); + werkstueckzaehler INCR 1; + bedienfehlerzaehler := 0; + korrekturzaehler := 0. + trage pausenueberziehung in tabelle ein: + + tab.tabelle [eintragzaehler].eintragskennung := pausenendekennung; + tab.tabelle [eintragzaehler].produktionsfehler := 0; + tab.tabelle [eintragzaehler].anzahl korrekturen := 0; + tab.tabelle [eintragzaehler].anzahl bedienfehler:= 0; + tab.tabelle [eintragzaehler].anfang := pausenanfang; + tab.tabelle [eintragzaehler].ende := pausenende; + tab.tabelle [eintragzaehler].differenz := pausenueberziehung; + erhoehe eintragzaehler; + arbeitsphasenzaehler INCR 1; + + beginn der bearbeitung := clock (1); + beginn der arbeitsphase := clock (1); + bearbeitungslaenge bestimmen. + trage simulationsende in tabelle ein: + bearbeitungsende := clock (1); + tab.tabelle [eintragzaehler].eintragskennung := simulationsendekennung; + tab.tabelle [eintragzaehler].produktionsfehler := produktionsfehler; + tab.tabelle [eintragzaehler].anzahl korrekturen := korrekturzaehler; + tab.tabelle [eintragzaehler].anzahl bedienfehler:= bedienfehlerzaehler; + + tab.tabelle [eintragzaehler].anfang := beginn der bearbeitung; + tab.tabelle [eintragzaehler].ende := bearbeitungsende; + tab.tabelle [eintragzaehler].differenz := bearbeitungszeit; + tab.letzter eintrag := eintragzaehler. + bearbeitungszeit: + bearbeitungsende - beginn der bearbeitung. + erhoehe eintragzaehler: + IF eintragzaehler < maxeintraege + THEN eintragzaehler INCR 1 + ELSE trage simulationsende in tabelle ein; + + errorstop (anwendungstext (254)) + FI. + ermittle ueberziehung der arbeitsphase: + arbeitsphasenueberziehung := clock (1) - beginn der arbeitsphase + - arbeitsphasenlaenge. + bearbeitungslaenge bestimmen: + arbeitsphasenlaenge := real (aphasendauer * 60) + - arbeitsphasenueberziehung + - pausenueberziehung. + arbeitsphasenende erreicht: + clock (1) - beginn der arbeitsphase >= arbeitsphasenlaenge. + + simulationsende erreicht: + arbeitsphasenzaehler = anzahl aphasen AND arbeitsphasenende erreicht. +END PROC fuehre simulation durch; +PROC gib bedieninformationen aus (INT CONST zeile): + WINDOW VAR f1 :: window ( 2, zeile, 35, 6), + f2 :: window (40, zeile, 39, 6); + show (f1); show (f2); + cursor (f1, 2, 1); out (f1, anwendungstext (11)); + out (f1, tastenbezeichnung ( nach rechts)); + cursor (f1, 2, 2); out (f1, anwendungstext (12)); + out (f1, tastenbezeichnung ( nach links)); + + cursor (f1, 2, 3); out (f1, anwendungstext (13)); + out (f1, tastenbezeichnung ( nach oben)); + cursor (f1, 2, 4); out (f1, anwendungstext (14)); + out (f1, tastenbezeichnung ( nach unten)); + cursor (f1, 2, 5); out (f1, anwendungstext (15)); + out (f1, tastenbezeichnung ( ausbesserung)); + cursor (f1, 2, 6); out (f1, anwendungstext (16)); + out (f1, tastenbezeichnung ( naechstes)); + cursor (f2, 2, 1); out (f2, anwendungstext (17)); + + out (f2, text (anzahl aphasen, 4)); + cursor (f2, 2, 2); out (f2, anwendungstext (18)); + out (f2, text (aphasendauer, 4)); + out (f2, anwendungstext (51)); + cursor (f2, 2, 3); out (f2, anwendungstext (19)); + out (f2, text (pausendauer, 4)); + out (f2, anwendungstext (51)); + cursor (f2, 2, 4); out (f2, anwendungstext ( 5)); + out (f2, text (gesamtzeit, 4)); + out (f2, anwendungstext (51)); + + cursor (f2, 2, 6); out (f2, anwendungstext (251)); + out (f2, 3 * blank); + out (f2, fehlerzeichen). +END PROC gib bedieninformationen aus; +INT PROC gesamtzeit: + anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer +END PROC gesamtzeit; +PROC hole werkstueck (WERKSTUECK VAR w, INT VAR anzahl fehler): + INT VAR spaltenzaehler, zeilenzaehler; + anzahl fehler := 0; + FOR zeilenzaehler FROM 1 UPTO hoehe REP + ermittle eine zeile + PER. + + ermittle eine zeile: + FOR spaltenzaehler FROM 1 UPTO breite REP + ermittle eine position; + ggf fehler registrieren + PER. + ermittle eine position: + w [spaltenzaehler][zeilenzaehler] := zufallscode. + zufallscode: + random (kleinster code, groesster code). + ggf fehler registrieren: + IF w [spaltenzaehler][zeilenzaehler] = code (fehlerzeichen) + THEN anzahl fehler INCR 1 + FI. +END PROC hole werkstueck; +PROC zeige werkstueck (WERKSTUECK CONST w, WINDOW VAR f): + + INT VAR spaltenzaehler, zeilenzaehler; + page (f); + FOR zeilenzaehler FROM 1 UPTO hoehe REP + zeige eine zeile + PER. + zeige eine zeile: + cursor (f, eckspalte, eckzeile + zeilenzaehler - 1); + ggf invers einschalten; + FOR spaltenzaehler FROM 1 UPTO breite REP + out (f, code (w [spaltenzaehler][zeilenzaehler])) + PER; + ggf invers ausschalten. + ggf invers einschalten: + IF inversdarstellung THEN out (f, markierung ein) FI. + ggf invers ausschalten: + IF inversdarstellung THEN out (f, markierung aus) FI. + +END PROC zeige werkstueck; +PROC kurzauswertung auf bildschirm (TEXT CONST dateiname): + WINDOW VAR fenster :: window ( 2, 10, 77, 13); + show (fenster); + clear buffer; + notiere ueberschrift; + notiere ergebnis. + notiere ueberschrift: + cursor (fenster, 1, 1); + out (fenster, center (fenster, anwendungstext (275))); + cursor (fenster, 1, 2); + out (fenster, center (fenster, anwendungstext (276))). + notiere ergebnis: + BOUND KONTROLLTABELLE CONST k := old (dateiname); + ermittle die simulationsdaten; + + notiere gesamtzahl werkstuecke; + notiere zeichengesamtzahl; + notiere bedienfehler; + notiere benoetigte zeit; + notiere gesamtausbesserungsrate; + notiere gesamtbewertungsfaktor; + notiere gesamtbewertungszahl mit pausenueberziehung; + cursor (1, 24); out (anwendungstext (2)); + pause. + ermittle die simulationsdaten: + INT VAR z, anzahl zeichen pro werkstueck, + anzahl werkstuecke :: 0, + anzahl bedienfehler :: 0, + anzahl produktionsfehler :: 0, + + anzahl korrekturen :: 0; + REAL VAR gesamtzahl zeichen, anteil korrekturen, + gesamtzeit :: 0.0, + pausenueberzug :: 0.0; + FOR z FROM 1 UPTO k.letzter eintrag REP + IF k.tabelle [z].eintragskennung = werkstueckendekennung + THEN anzahl werkstuecke INCR 1; + anzahl bedienfehler INCR k.tabelle [z].anzahl bedienfehler; + anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler; + + anzahl korrekturen INCR k.tabelle [z].anzahl korrekturen; + gesamtzeit INCR k.tabelle [z].differenz; + ELIF k.tabelle [z].eintragskennung = pausenendekennung + THEN pausenueberzug INCR k.tabelle [z].differenz; + FI + PER; + anzahl zeichen pro werkstueck := k.breite * k.hoehe; + gesamtzahl zeichen := real (anzahl werkstuecke) + * real (anzahl zeichen pro werkstueck); + + IF anzahl produktionsfehler = 0 + THEN anteil korrekturen := 1.0 + ELSE anteil korrekturen := real (anzahl korrekturen) + / real (anzahl produktionsfehler) + FI. + notiere gesamtzahl werkstuecke: + cursor (fenster, 12, 4); out (fenster, anwendungstext (277)); + out (fenster, text (anzahl werkstuecke, 8)). + notiere zeichengesamtzahl: + cursor (fenster, 12, 5); out (fenster, anwendungstext (278)); + out (fenster, zahl aus zeichenkette). + + zahl aus zeichenkette: + subtext (text (gesamtzahl zeichen, 9, 0), 1, 8). + notiere bedienfehler: + cursor (fenster, 12, 6); out (fenster, anwendungstext (279)); + out (fenster, text (anzahl bedienfehler, 8)). + notiere benoetigte zeit: + cursor (fenster, 12, 7); out (fenster, anwendungstext (280)); + out (fenster, text (gesamtzeit, 8, 2)). + notiere gesamtausbesserungsrate: + cursor (fenster, 12, 9); out (fenster, anwendungstext (281)); + + out (fenster, text (anteil korrekturen, 8, 2)). + notiere gesamtbewertungsfaktor: + cursor (fenster, 12,10); out (fenster, anwendungstext (282)); + out (fenster, text (bewertungsfaktor, 8, 2)). + bewertungsfaktor: + bewertungsmasszahl (anteil korrekturen). + notiere gesamtbewertungszahl mit pausenueberziehung: + cursor (fenster, 12, 12); out (fenster, (anwendungstext (283))); + out (fenster, text (gesamtwertung, 8, 2)); + + cursor (fenster, 12, 13); out (fenster, (anwendungstext (284))); + out (fenster, 8 * "="). + gesamtwertung: + IF gesamtzeit = 0.0 + THEN 0.0 + ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug) + * bewertungsfaktor + FI. +END PROC kurzauswertung auf bildschirm; +PROC simulationsauswertung (TEXT CONST dateiname, BOOL CONST mit zeigen): + TEXT CONST auswertdatei :: dateiname + auswertdateipostfix; + ermittle die kenndaten aus der protokolldatei (dateiname); + + notiere ueberschrift 1 (auswertdatei); + notiere die kenndaten der simulation (auswertdatei); + notiere die werkstueckkenndaten (auswertdatei); + notiere ein beispielwerkstueck (auswertdatei); + notiere ueberschrift 2 (auswertdatei); + notiere gesamtergebnisse (auswertdatei, dateiname); + notiere ueberschrift 3 (auswertdatei); + notiere tabellenkopf (auswertdatei); + notiere einzelne werkstueckdaten (auswertdatei, dateiname); + + notiere ggf die anmerkungen; + zeige ggf auswertung auf bildschirm. + notiere ggf die anmerkungen: + IF mit anmerkungen + THEN notiere anmerkungen (auswertdatei); + FI. + zeige ggf auswertung auf bildschirm: + IF mit zeigen + THEN cursor on; show (auswertdatei); cursor off + FI. +END PROC simulationsauswertung; +PROC ermittle die kenndaten aus der protokolldatei (TEXT CONST dateiname): + BOUND KONTROLLTABELLE CONST k := old (dateiname); + breite := k.breite; + + hoehe := k.hoehe; + kleinster code := k.kleinster code; + groesster code := k.groesster code; + fehlerzeichen := k.fehlerzeichen; + inversdarstellung := k.inversdarstellung; + nach rechts := k.nach rechts; + nach links := k.nach links; + nach oben := k.nach oben; + nach unten := k.nach unten; + ausbesserung := k.ausbesserung; + naechstes := k.naechstes; + + anzahl aphasen := k.anzahl aphasen; + aphasendauer := k.aphasendauer; + pausendauer := k.pausendauer; + datum := k.datum; + uhrzeit := k.uhrzeit; + bewertung := k.bewertung; +END PROC ermittle die kenndaten aus der protokolldatei; +PROC notiere ueberschrift 1 (TEXT CONST auswertdatei): + IF exists (auswertdatei) + THEN forget (auswertdatei, quiet) + FI; + FILE VAR f :: sequential file (output, auswertdatei); + + IF auswertung geht zum drucker + THEN schreibe druckeranweisungen + FI; + putline (f, center (auswertdatei)); + putline (f, center (length (auswertdatei) * "=")); + put (f, anwendungstext (272)); put (f, datum); put (f, 26 * blank); + put (f, anwendungstext (273)); putline (f, uhrzeit); + line (f); + putline (f, center (anwendungstext (291))); + putline (f, center (length (anwendungstext (291)) * "=")). + schreibe druckeranweisungen: + write (f, "#type ("""); + write (f, protokollschrifttyp); + + write (f, """)##limit ("); + write (f, text (schreibfeldbreite)); + write (f, ")##pagelength ("); + write (f, text (schreibfeldlaenge)); + write (f, ")##start ("); + write (f, text (xstart)); + write (f, ","); + write (f, text (ystart)); + write (f, ")#"); line (f). +END PROC notiere ueberschrift 1; +PROC notiere ueberschrift 2 (TEXT CONST auswertdatei): + FILE VAR f :: sequential file (output, auswertdatei); + putline (f, center (anwendungstext (285))); + putline (f, center (length (anwendungstext (285)) * "=")) + +END PROC notiere ueberschrift 2; +PROC notiere ueberschrift 3 (TEXT CONST auswertdatei): + FILE VAR f :: sequential file (output, auswertdatei); + line (f, 2); + putline (f, center (anwendungstext (311))); + putline (f, center (length (anwendungstext (311)) * "=")); + line (f) +END PROC notiere ueberschrift 3; +PROC notiere die kenndaten der simulation (TEXT CONST auswertdatei): + FILE VAR f :: sequential file (output, auswertdatei); + ROW 6 TEXT VAR ausgabe; + bestuecke ausgabezeilen; + schreibe ausgabezeilen. + + bestuecke ausgabezeilen: + ausgabe [1] := anwendungstext (11) + + gleichlang (tastenbezeichnung (nach rechts ), 23) + + anwendungstext (17) + + text (anzahl aphasen, 4); + ausgabe [2] := anwendungstext (12) + + gleichlang (tastenbezeichnung (nach links ), 23) + + anwendungstext (18) + + text (aphasendauer, 4) + anwendungstext (51); + ausgabe [3] := anwendungstext (13) + + + gleichlang (tastenbezeichnung (nach oben ), 23) + + anwendungstext (19) + + text (pausendauer, 4) + anwendungstext (51); + ausgabe [4] := anwendungstext (14) + + gleichlang (tastenbezeichnung (nach unten ), 23) + + anwendungstext ( 5) + + text (simulationsdauer, 4) + anwendungstext (51); + ausgabe [5] := anwendungstext (15) + + gleichlang (tastenbezeichnung (ausbesserung), 23); + + ausgabe [6] := anwendungstext (16) + + gleichlang (tastenbezeichnung (naechstes ), 23) + + anwendungstext (251) + + (3 * blank) + fehlerzeichen. + simulationsdauer: + anzahl aphasen * aphasendauer + (anzahl aphasen - 1) * pausendauer. + schreibe ausgabezeilen: + INT VAR i; + FOR i FROM 1 UPTO 6 REP + putline (f, ausgabe [i]) + PER; + line (f). +END PROC notiere die kenndaten der simulation; +PROC notiere die werkstueckkenndaten (TEXT CONST auswertdatei): + + FILE VAR f :: sequential file (output, auswertdatei); + ROW 4 TEXT VAR ausgabe; + bestuecke ausgabezeilen; + schreibe ausgabezeilen. + bestuecke ausgabezeilen: + ausgabe [1] := anwendungstext (292) + text (breite, 4) + + anwendungstext (296); + ausgabe [2] := anwendungstext (293) + text (hoehe, 4) + + anwendungstext (296); + ausgabe [3] := anwendungstext (294) + text (breite * hoehe, 4) + + anwendungstext (296); + + ausgabe [4] := anwendungstext (295) + zeichenumfang. + zeichenumfang: + " " + code (kleinster code) + " ... " + code (groesster code) + + " (" + text (groesster code - kleinster code + 1, 3) + + anwendungstext (296) + ")". + schreibe ausgabezeilen: + INT VAR i; + FOR i FROM 1 UPTO 4 REP putline (f, ausgabe [i]) PER; + line (f). +END PROC notiere die werkstueckkenndaten; +PROC notiere ein beispielwerkstueck (TEXT CONST auswertdatei): + FILE VAR f :: sequential file (output, auswertdatei); + + WERKSTUECK VAR beispiel; + INT VAR beispielfehler; + hole werkstueck (beispiel, beispielfehler); + notiere ueberschrift; + notiere werkstueckzeilen; + notiere werkstueckleerzeilen. + notiere ueberschrift: + putline (f, center (anwendungstext (297))); + putline (f, center (length (anwendungstext (297)) * "-")). + notiere werkstueckzeilen: + INT VAR bs, bz; + FOR bz FROM 1 UPTO hoehe REP + notiere eine zeile + PER. + notiere eine zeile: + TEXT VAR beispielzeile :: ""; + + konstruiere beispielzeile; + gib beispielzeile aus. + konstruiere beispielzeile: + beispielzeile CAT (((80 - breite) DIV 2) * blank); + FOR bs FROM 1 UPTO breite REP + beispielzeile CAT code (beispiel [bs][bz]) + PER. + gib beispielzeile aus: + putline (f, beispielzeile). + notiere werkstueckleerzeilen: + line (f, maxzeilen - hoehe + 1). +END PROC notiere ein beispielwerkstueck; +PROC notiere gesamtergebnisse (TEXT CONST auswertdatei, protokolldatei): + FILE VAR f :: sequential file (output, auswertdatei); + + BOUND KONTROLLTABELLE CONST k :: old (protokolldatei); + ermittle die simulationsdaten; + notiere gesamtzahl werkstuecke; + notiere anzahl zeichen pro werkstueck; + notiere zeichengesamtzahl; + notiere bedienfehler; + notiere produktionsfehlerzahl; + notiere fehlerkorrekturen; + notiere gesamtzeit mit pausenueberziehung; + notiere zeichenzahl pro sekunde mit; + notiere gesamtausbesserungsrate; + notiere gesamtbewertungsfaktor mit; + notiere gesamtbewertungszahl mit; + + notiere gesamtzeit ohne pausenueberziehung; + notiere zeichenzahl pro sekunde ohne; + notiere gesamtbewertungszahl ohne. + ermittle die simulationsdaten: + INT VAR z, anzahl zeichen pro werkstueck, + anzahl werkstuecke :: 0, + anzahl bedienfehler :: 0, + anzahl produktionsfehler :: 0, + anzahl korrekturen :: 0; + REAL VAR gesamtzahl zeichen, anteil korrekturen, + gesamtzeit :: 0.0, + + pausenueberzug :: 0.0; + FOR z FROM 1 UPTO k.letzter eintrag REP + IF k.tabelle [z].eintragskennung = werkstueckendekennung + THEN anzahl werkstuecke INCR 1; + anzahl bedienfehler INCR k.tabelle [z].anzahl bedienfehler; + anzahl produktionsfehler INCR k.tabelle [z].produktionsfehler; + anzahl korrekturen INCR k.tabelle [z].anzahl korrekturen; + gesamtzeit INCR k.tabelle [z].differenz; + + ELIF k.tabelle [z].eintragskennung = pausenendekennung + THEN pausenueberzug INCR k.tabelle [z].differenz; + FI + PER; + anzahl zeichen pro werkstueck := k.breite * k.hoehe; + gesamtzahl zeichen := real (anzahl werkstuecke) + * real (anzahl zeichen pro werkstueck); + IF anzahl produktionsfehler = 0 + THEN anteil korrekturen := 1.0 + ELSE anteil korrekturen := real (anzahl korrekturen) + + / real (anzahl produktionsfehler) + FI. + notiere gesamtzahl werkstuecke: + put (f, anwendungstext (277)); putline (f, text (anzahl werkstuecke, 8)). + notiere anzahl zeichen pro werkstueck: + put (f, anwendungstext (286)); putline (f, text (breite * hoehe, 8)). + notiere zeichengesamtzahl: + put (f, anwendungstext (278)); putline (f, zahl aus zeichenkette); + line (f). + zahl aus zeichenkette: + subtext (text (gesamtzahl zeichen, 9, 0), 1, 8). + + notiere produktionsfehlerzahl: + put (f, anwendungstext (287)); putline (f, text (anzahl produktionsfehler, 8)). + notiere fehlerkorrekturen: + put (f, anwendungstext (288)); putline (f, text (anzahl korrekturen, 8)). + notiere bedienfehler: + put (f, anwendungstext (279)); putline (f, text (anzahl bedienfehler,8)); + line (f). + notiere gesamtzeit mit pausenueberziehung: + put (f, anwendungstext (301)); put (f, text (gesamtzeit mit, 8, 1)); + putline (f, anwendungstext (300)). + + gesamtzeit mit: + gesamtzeit + pausenueberzug. + notiere zeichenzahl pro sekunde mit: + put (f, anwendungstext (302)); + putline (f, text (zeichenpro sec mit, 8, 1)); + line (f). + zeichen pro sec mit: + IF gesamtzeit + pausenueberzug > 0.0 + THEN gesamtzahl zeichen / (gesamtzeit + pausenueberzug) + ELSE 0.0 + FI. + notiere gesamtausbesserungsrate: + put (f, anwendungstext (281)); putline (f, text (anteil korrekturen, 8, 1)). + notiere gesamtbewertungsfaktor mit: + + put (f, anwendungstext (282)); putline (f, text (bewertungsfaktor, 8, 1)); + line (f). + bewertungsfaktor: + bewertungsmasszahl (anteil korrekturen). + notiere gesamtbewertungszahl mit: + put (f, (anwendungstext (283))); putline (f, text (gesamtwertung mit, 8, 1)); + put (f, (anwendungstext (284))); putline (f, 8 * "="). + gesamtwertung mit: + IF gesamtzeit = 0.0 + THEN 0.0 + ELSE gesamtzahl zeichen / (gesamtzeit + pausenueberzug) + * bewertungsfaktor + + FI. + notiere gesamtzeit ohne pausenueberziehung: + put (f, anwendungstext (303)); put (f, text (gesamtzeit, 8, 1)); + putline (f, anwendungstext (300)). + notiere zeichenzahl pro sekunde ohne: + put (f, anwendungstext (302)); + putline (f, text (zeichenpro sec ohne, 8, 1)). + zeichen pro sec ohne: + IF gesamtzeit > 0.0 + THEN gesamtzahl zeichen / gesamtzeit + ELSE 0.0 + FI. + notiere gesamtbewertungszahl ohne: + put (f, (anwendungstext (304))); putline (f, text (gesamtwertung ohne, 8, 1)); + + put (f, (anwendungstext (284))); putline (f, 8 * "="). + gesamtwertung ohne: + IF gesamtzeit = 0.0 + THEN 0.0 + ELSE gesamtzahl zeichen / gesamtzeit * bewertungsfaktor + FI. +END PROC notiere gesamtergebnisse; +PROC notiere tabellenkopf (TEXT CONST auswertdatei): + FILE VAR f :: sequential file (output, auswertdatei); + putline (f, anwendungstext (312)); + putline (f, anwendungstext (313)); + putline (f, anwendungstext (314)); + putline (f, anwendungstext (315)); + putline (f, anwendungstext (316)); + + putline (f, anwendungstext (317)); + putline (f, anwendungstext (318)); +END PROC notiere tabellenkopf; +PROC notiere einzelne werkstueckdaten (TEXT CONST auswertdatei, dateiname): + BOUND KONTROLLTABELLE CONST k :: old (dateiname); + FILE VAR f :: sequential file (output, auswertdatei); + INT VAR zeiger, werkstuecknummer :: 0; + TEXT VAR ausgabezeile :: ""; + FOR zeiger FROM 1 UPTO k.letzter eintrag REP + notiere bearbeitungszeile + PER. + notiere bearbeitungszeile: + IF k.tabelle [zeiger].eintragskennung = werkstueckendekennung + + THEN werkstuecknummer INCR 1; + schreibe werkstueckzeile + ELIF k.tabelle [zeiger].eintragskennung = pausenendekennung + THEN schreibe pausenzeile + ELIF k.tabelle [zeiger].eintragskennung = simulationsendekennung + THEN werkstuecknummer INCR 1; + schreibe abschluss + ELSE putline (f, 75 * "?") + FI. + schreibe werkstueckzeile: + konstruiere ausgabezeile; + putline (f, ausgabezeile). + konstruiere ausgabezeile: + ausgabezeile := ""; + + ausgabezeile CAT text (werkstuecknummer, 5); + ausgabezeile CAT 2 * blank; + ausgabezeile CAT trenn; + ausgabezeile CAT text (k.tabelle [zeiger].anzahl bedienfehler, 5); + ausgabezeile CAT 3 * blank; + ausgabezeile CAT trenn; + ausgabezeile CAT text (k.tabelle [zeiger].produktionsfehler, 6); + ausgabezeile CAT 2 * blank; + ausgabezeile CAT trenn; + ausgabezeile CAT text (k.tabelle [zeiger].anzahl korrekturen, 6); + ausgabezeile CAT 2 * blank; + ausgabezeile CAT trenn; + + ausgabezeile CAT text (k.tabelle [zeiger].differenz, 6, 1); + ausgabezeile CAT blank; + ausgabezeile CAT trenn; + ausgabezeile CAT text (zeichen pro zeiteinheit, 6, 1); + ausgabezeile CAT blank; + ausgabezeile CAT trenn; + ausgabezeile CAT text (einzelausbesserungsrate, 6, 1); + ausgabezeile CAT blank; + ausgabezeile CAT trenn; + ausgabezeile CAT text (bewertungsmasszahl (einzelausbesserungsrate), 6, 1); + ausgabezeile CAT blank; + ausgabezeile CAT trenn; + + ausgabezeile CAT text (endbewertungszahl, 6, 1); + ausgabezeile CAT blank. + zeichen pro zeiteinheit: + real (breite * hoehe) / k.tabelle [zeiger].differenz. + einzelausbesserungsrate: + IF k.tabelle [zeiger].produktionsfehler = 0 + THEN 0.0 + ELSE real (k.tabelle [zeiger].anzahl korrekturen) + / real (k.tabelle [zeiger].produktionsfehler ) + FI. + endbewertungszahl: + real (breite * hoehe) / k.tabelle [zeiger].differenz + * bewertungsmasszahl (einzelausbesserungsrate). + + schreibe pausenzeile: + line (f); + put (f, anwendungstext (320)); + put (f, text (k.tabelle [zeiger].differenz, 6, 1)); + putline (f, anwendungstext (300)); + line (f). + schreibe abschluss: + putline (f, anwendungstext (318)); + putline (f, anwendungstext (319)); + line (f); + konstruiere ausgabezeile; + ausgabezeile := "(" + + subtext (ausgabezeile, 2, length (ausgabezeile) - 1) + + ")"; + putline (f, ausgabezeile). + +END PROC notiere einzelne werkstueckdaten; +PROC notiere anmerkungen (TEXT CONST auswertdatei): + FILE VAR f :: sequential file (output, auswertdatei); + line (f); + schreibe kopf; + schreibe hinweis auf letztes werkstueck; + schreibe hinweis auf bedienfehler; + erlaeutere bewertungsschluessel; + stelle bewertungsschluessel graphisch dar; + schreibe rest. + schreibe kopf: + putline (f, center (anwendungstext (325))); + putline (f, center (length (anwendungstext (325)) * "=")); + line (f). + + schreibe hinweis auf letztes werkstueck: + INT VAR i; + FOR i FROM 326 UPTO 337 REP + putline (f, anwendungstext (i)) + PER; + line (f). + schreibe hinweis auf bedienfehler: + FOR i FROM 339 UPTO 341 REP + putline (f, anwendungstext (i)) + PER; + line (f). + erlaeutere bewertungsschluessel: + FOR i FROM 343 UPTO 372 REP + putline (f, anwendungstext (i)) + PER. + stelle bewertungsschluessel graphisch dar: + putline (f, anwendungstext (374)); + putline (f, anwendungstext (375)); + + ermittle die startposition; + zeichne diagramm; + trage werte ein. + ermittle die startposition: + modify (f); + INT VAR zeilenpos :: lines (f) + 2, spaltenpos :: 18. + zeichne diagramm: + cursor (f, spaltenpos, zeilenpos , anwendungstext (20)); + cursor (f, spaltenpos, zeilenpos + 1, anwendungstext (21)); + cursor (f, spaltenpos, zeilenpos + 3, anwendungstext (23)); + cursor (f, spaltenpos, zeilenpos + 4, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 5, anwendungstext (22)); + + cursor (f, spaltenpos, zeilenpos + 6, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 7, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 8, anwendungstext (24)); + cursor (f, spaltenpos, zeilenpos + 9, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 10, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 11, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 12, anwendungstext (22)); + cursor (f, spaltenpos, zeilenpos + 13, anwendungstext (25)); + + cursor (f, spaltenpos, zeilenpos + 14, anwendungstext (26)); + cursor (f, spaltenpos, zeilenpos + 15, anwendungstext (27)). + trage werte ein: + zeilenpos INCR 13; + INT VAR bwzeiger; + FOR bwzeiger FROM 1 UPTO 11 REP + cursor (f, spaltenpos + 3 * bwzeiger, zeilenpos - konkreter wert, "+") + PER. + konkreter wert: + int (bewertung [bwzeiger] * 10.0). + schreibe rest: + output (f); + line (f, 2); + FOR i FROM 377 UPTO 387 REP + putline (f, anwendungstext (i)) + + PER; + haenge an jede zeile ein blank an. + haenge an jede zeile ein blank an: + TEXT VAR inhalt; + INT VAR zeilenzeiger; + modify (f); + FOR zeilenzeiger FROM 1 UPTO lines (f) REP + to line (f, zeilenzeiger); + read record (f, inhalt); + inhalt CAT blank; + write record (f, inhalt) + PER; + to line (f,1). +END PROC notiere anmerkungen; +PROC cursor (FILE VAR f, INT CONST spa, zei, TEXT CONST text): + positioniere an zeile; + positioniere an spalte; + + gib text an position aus. + positioniere an zeile: + IF zeile noch nicht vorhanden + THEN schaffe zeile und gehe dorthin + ELSE to line (f,zei) + FI. + zeile noch nicht vorhanden: + zei > lines (f). + schaffe zeile und gehe dorthin: + INT VAR zaehler 1; + IF lines (f) = 0 + THEN to line (f,lines (f)); + insert record (f); + FI; + FOR zaehler 1 FROM lines (f) UPTO zei REP + to line (f,lines (f)); + down (f);insert record (f) + PER; + + to line(f,zei). + positioniere an spalte: + TEXT VAR alter satz :: "", neuer satz :: "", restsatz ::""; + INT VAR satzlaenge; + read record (f,alter satz); + satzlaenge := length (alter satz); + IF satzlaenge = 0 + THEN neuer satz CAT (spa -1) * " " + ELIF satzlaenge >= spa + THEN neuer satz := subtext(alter satz,1,spa-1); + restsatz := subtext(alter satz, spa + length (text)); + ELSE neuer satz := alter satz; + neuer satz CAT (spa - satzlaenge - 1) * " " + + FI. + gib text an position aus: + neuer satz CAT text; + IF restsatz <> "" + THEN neuer satz CAT restsatz + FI; + write record(f,neuer satz). + END PROC cursor; +TEXT PROC gleichlang (TEXT CONST text, INT CONST laenge): + TEXT VAR intern :: compress (text); + INT VAR anzahl :: laenge - length (intern); + IF anzahl < 0 + THEN subtext (intern, 1, laenge) + ELSE intern + (anzahl * blank) + FI +END PROC gleichlang; +REAL PROC bewertungsmasszahl (REAL CONST wert): + REAL VAR interner wert := round (wert, 1); + + IF interner wert > wert + THEN interner wert DECR 0.1 + FI; + interpoliere. + interpoliere: + REAL VAR unterer wert, oberer wert; + unterer wert := interner wert; + IF unterer wert = 1.0 + THEN oberer wert := 1.0 + ELSE oberer wert := unterer wert + 0.1 + FI; + unterer wert := bewertung (int (unterer wert * 10.0) + 1); + oberer wert := bewertung (int (oberer wert * 10.0) + 1); + unterer wert + (oberer wert - unterer wert) * faktor. + faktor: + frac (wert * 10.0). + +END PROC bewertungsmasszahl; +PROC zeige aktuellen protokollumfang an: + WINDOW VAR w :: window (2, 2, 34, 5); + show (w); + cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431)))); + IF mit anmerkungen + THEN cursor (w, 2, 4); out (w, anwendungstext (432)) + ELSE cursor (w, 2, 4); out (w, anwendungstext (433)); + FI. +END PROC zeige aktuellen protokollumfang an; +PROC gib erlaeuterungen zum protokollumfang: + WINDOW VAR f :: window ( 2, 9, 77, 15); + show (f); + cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (434)))); + + cursor (f, 5, 3); out (f, anwendungstext (435)); + cursor (f, 5, 4); out (f, anwendungstext (436)); + cursor (f, 5, 5); out (f, anwendungstext (437)); + cursor (f, 5, 6); out (f, anwendungstext (438)); + cursor (f, 5, 8); out (f, anwendungstext (439)); + cursor (f, 5, 9); out (f, anwendungstext (440)); + cursor (f, 5,10); out (f, anwendungstext (441)); + cursor (f, 5,11); out (f, anwendungstext (442)); + cursor (f, 5,13); out (f, anwendungstext (443)); + cursor (f, 5,14); out (f, anwendungstext (444)); + +END PROC gib erlaeuterungen zum protokollumfang; +PROC frage nach umfangsaenderung: + WINDOW VAR fenster :: window (38, 2, 41, 5); + show (fenster); + cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (451)))); + cursor (fenster, 4, 3); out (fenster, anwendungstext (452)); + cursor (fenster, 4, 4); + IF yes (fenster, anwendungstext (453)) + THEN mit anmerkungen := NOT mit anmerkungen + FI. +END PROC frage nach umfangsaenderung; +PROC zeige aktuelle kurzauswertungseinstellung an: + + WINDOW VAR w :: window ( 2, 2, 34, 5); + show (w); + cursor (w, 1, 1); out (w, center (w, invers (anwendungstext (431)))); + IF mit kurzprotokoll + THEN cursor (w, 7, 4); out (w, anwendungstext (461)); + ELSE cursor (w, 7, 4); out (w, anwendungstext (462)); + FI. +END PROC zeige aktuelle kurzauswertungseinstellung an; +PROC gib erlaeuterungen zur kurzauswertung: + WINDOW VAR f :: window ( 2, 9, 77, 15); + show (f); + cursor (f, 1, 1); out (f, center (f, invers (anwendungstext (463)))); + + cursor (f, 5, 3); out (f, anwendungstext (464)); + cursor (f, 5, 4); out (f, anwendungstext (465)); + cursor (f, 5, 5); out (f, anwendungstext (466)); + cursor (f, 5, 6); out (f, anwendungstext (467)); + cursor (f, 5, 8); out (f, anwendungstext (468)); + cursor (f, 5, 9); out (f, anwendungstext (469)); + cursor (f, 5,10); out (f, anwendungstext (470)); + cursor (f, 5,11); out (f, anwendungstext (471)); + cursor (f, 5,13); out (f, anwendungstext (472)); + cursor (f, 5,14); out (f, anwendungstext (473)); + +END PROC gib erlaeuterungen zur kurzauswertung; +PROC frage nach kurzauswertungsaenderung: + WINDOW VAR fenster :: window (38, 2, 41, 5); + show (fenster); + cursor (fenster, 1, 1); out (fenster, center (fenster, invers (anwendungstext (481)))); + cursor (fenster, 5, 3); out (fenster, anwendungstext (482)); + cursor (fenster, 5, 4); + IF yes (fenster, anwendungstext (483)) + THEN mit kurzprotokoll := NOT mit kurzprotokoll + FI. +END PROC frage nach kurzauswertungsaenderung; +END PACKET ls mp bap 2; + diff --git a/mp-bap/ls-MP BAP-gen b/mp-bap/ls-MP BAP-gen index 26a84c3..40df0b4 100644 --- a/mp-bap/ls-MP BAP-gen +++ b/mp-bap/ls-MP BAP-gen @@ -22,9 +22,79 @@ END PROC stelle existenz des mm sicher; PROC vom archiv (TEXT CONST datei): cursor (1,5); out (""4""); - out (" """); out (datei); putline (""" wird geholt.");{} fetch (datei, archive){}END PROC vom archiv;{}PROC hole (TEXT CONST datei):{} IF NOT exists (datei) THEN vom archiv (datei) FI{}END PROC hole;{}PROC in (TEXT CONST datei):{} hole (datei);{} cursor (1, 5); out (""4"");{} out (" """); out (datei); out (""" wird übersetzt: ");{} insert (datei);{} forget (datei, quiet);{}END PROC in;{}PROC schicke (TEXT CONST datei):{} cursor (1, 5); out (""4"");{} out (" """); out(datei);{} out (""" wird zum MENUKARTEN-MANAGER geschickt!");{} - command dialogue (FALSE);{} save (datei, task (mm taskname));{} command dialogue (TRUE);{} forget (datei, quiet){}END PROC schicke;{}INT VAR size, used;{}BOOL VAR einzeln;{}storage (size, used);{}einzeln := size - used < 500;{}forget (eigener name, quiet);{}wirf kopfzeile aus;{}stelle existenz des mm sicher;{}hole die dateien;{}insertiere die dateien;{}mache global manager aus der task.{}wirf kopfzeile aus:{} page;{} putline (" "15"ls-MP BAP - Automatische Generierung "14"").{} -hole die dateien:{} IF NOT exists (datei 1){} COR NOT exists (datei 2){} COR NOT exists (menukarte){} THEN hole dateien vom archiv; LEAVE hole die dateien{} FI.{}hole dateien vom archiv:{} cursor (1,3); out (""4"");{} IF yes ("Ist das Archiv angemeldet und die Diskette eingelegt"){} THEN lese ein{} ELSE line (2);{} errorstop ("Ohne die Diskette kann ich das System nicht generieren!"){} FI.{}lese ein:{} cursor (1, 3); out (""4"");{} out (" "15"Bitte die Diskette eingelegt lassen! "14"");{} - IF NOT einzeln{} THEN hole (datei 1);{} hole (datei 2);{} hole (menukarte);{} cursor (1, 3); out(""4"");{} out (" "15"Die Diskette wird nicht mehr benötigt! "14"");{} release (archive){} FI.{}insertiere die dateien:{} check off;{} cursor (1, 3); out(""4"");{} out (" "15"Die Diskette wird nicht mehr benötigt! "14"");{} in (datei 1);{} in (datei 2);{} schicke (menukarte);{} IF einzeln THEN release (archive) FI;{} - check on.{}mache global manager aus der task:{} global manager.{} + out (" """); out (datei); putline (""" wird geholt."); + fetch (datei, archive) +END PROC vom archiv; +PROC hole (TEXT CONST datei): + IF NOT exists (datei) THEN vom archiv (datei) FI +END PROC hole; +PROC in (TEXT CONST datei): + hole (datei); + cursor (1, 5); out (""4""); + out (" """); out (datei); out (""" wird übersetzt: "); + insert (datei); + forget (datei, quiet); +END PROC in; +PROC schicke (TEXT CONST datei): + cursor (1, 5); out (""4""); + out (" """); out(datei); + out (""" wird zum MENUKARTEN-MANAGER geschickt!"); + + command dialogue (FALSE); + save (datei, task (mm taskname)); + command dialogue (TRUE); + forget (datei, quiet) +END PROC schicke; +INT VAR size, used; +BOOL VAR einzeln; +storage (size, used); +einzeln := size - used < 500; +forget (eigener name, quiet); +wirf kopfzeile aus; +stelle existenz des mm sicher; +hole die dateien; +insertiere die dateien; +mache global manager aus der task. +wirf kopfzeile aus: + page; + putline (" "15"ls-MP BAP - Automatische Generierung "14""). + +hole die dateien: + IF NOT exists (datei 1) + COR NOT exists (datei 2) + COR NOT exists (menukarte) + THEN hole dateien vom archiv; LEAVE hole die dateien + FI. +hole dateien vom archiv: + cursor (1,3); out (""4""); + IF yes ("Ist das Archiv angemeldet und die Diskette eingelegt") + THEN lese ein + ELSE line (2); + errorstop ("Ohne die Diskette kann ich das System nicht generieren!") + FI. +lese ein: + cursor (1, 3); out (""4""); + out (" "15"Bitte die Diskette eingelegt lassen! "14""); + + IF NOT einzeln + THEN hole (datei 1); + hole (datei 2); + hole (menukarte); + cursor (1, 3); out(""4""); + out (" "15"Die Diskette wird nicht mehr benötigt! "14""); + release (archive) + FI. +insertiere die dateien: + check off; + cursor (1, 3); out(""4""); + out (" "15"Die Diskette wird nicht mehr benötigt! "14""); + in (datei 1); + in (datei 2); + schicke (menukarte); + IF einzeln THEN release (archive) FI; + + check on. +mache global manager aus der task: + global manager. + -- cgit v1.2.3