path: root/mp-bap/ls-MP BAP 2

PACKET ls mp bap 2  DEFINES                (*******************************) 
                                           (*                             *) 
  materialpruefung, mp,                    (*         ls-MP BAP 2         *) 
  bildschirmarbeitsplatz, bap,             (*         Version 1.1         *) 
                                           (*                             *) 
  mp bap simulation ausfuehren,            (*   (c) 1987, 1988            *) 
  mp bap auswertung auf bildschirm,        (*       by Eva Latta-Weber    *) 
  mp bap drucken von auswertungen,         (*          Bielefeld          *) 
                                           (*                             *) 
  mp bap protokollumfang festlegen,        (*******************************) 
  mp bap kurzauswertung, 
 
  druckereinstellung fuer protokolldatei, 
  stddruckereinstellung fuer protokolldatei: 
 
 
 
LET maxeintraege             =                    800, 
    protokolldateipraefix    =       "ls-Protokoll: ", 
    menukarte                =  "ls-MENUKARTE:MP-BAP", 
    menubezeichnung          =                  "BAP", 
    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;