path: root/app/schulis-mathematiksystem/1.0/src/mat.verwaltung

PACKET mathe verwaltung DEFINES mathe, 
                                installiere mathesystem: 
 
(**************************************************) 
(*   G l o b a l e    D e k l a r a t i o n e n   *) 
(**************************************************) 
 
(* L E T   -  D e n o t e r *) 
 
(* Ausgabetexte *) 
 
LET systemname        = "s c h u l i s - Mathematiksystem    Version 1.0", 
    titel 1           = "Systemverwaltung", 
    titel 2           = "Installation", 
    titel 3           = "Installation: Drucker", 
    meldung 1         = "Das Mathematiksystem ist noch nicht installiert.", 
    meldung 2         = "Kein Druckertreiber für Graphiken installiert.", 
    meldung 3         = "1 ... Mathematiksystem - Ebene 1", 
    meldung 4         = "2 ... Mathematiksystem - Ebene 2", 
    meldung 5         = "3 ... Zeichnungen drucken", 
    meldung 6         = "---------------------------------------", 
    meldung 7         = "4 ... Neuinstallation: Mathematiksystem", 
    meldung 8         = "5 ... Neuinstallation: Graphikdrucker", 
    meldung 9         = "q ... Mathematiksystem verlassen", 
    meldung 10        = "Gewünschte Funktion:", 
    meldung 11        = "Bitte wählen Sie unter folgenden Anpassungen eine", 
    meldung 12        = "für Ihr Terminal und die zugehörige Grafikkarte", 
    meldung 13        = "angemessene heraus:", 
    meldung 14        = "                 hercules-Anpassung", 
    meldung 15        = "                 cga-Anpassung", 
    meldung 16        = "                 ega-Anpassung", 
    meldung 17        = "                 vga-Anpassung", 
    meldung 18        = "Solange vorgeschlagene Anpassung verneinen <n/N>", 
    meldung 19        = "bis passende genannt wird.", 
    meldung 20        = "Diese bejahen <j/J/y/Y>.", 
    meldung 21        = "Installation korrekt beendet", 
    meldung 22        = "Installation wegen Systemfehler gestoppt", 
    meldung 23        = "Verfügt das Terminal über den IBM-Zeichensatz", 
    meldung 24        = "Soll das vorhandene Mathematiksystem gelöscht werden", 
    meldung 25        = "Soll der vorhandene Druckertreiber gelöscht werden", 
    meldung 26        = "Weiter mit beliebiger Taste", 
    meldung 27        = "Geladen wird Datei Nr. ", 
    meldung 28        = "Die benötigten Dateien sind vollständig geladen.", 
    meldung 29        = "Sie können die Diskette aus dem Laufwerk nehmen.", 
    meldung 30        = "Bitte warten - das Mathematiksystem wird installiert.", 
    meldung 31        = "Installiert wird Datei      von ", 
    meldung 32        = "Fehler bei der Übersetzung der Programme.", 
    meldung 33        = "   richtige Anpassung", 
    meldung 34        = "für Ihren Drucker geeigenete aus:", 
    meldung 35        = "  DRUCKER          PLOTTER", 
    meldung 36        = "  xerox 4045       hp 72xx", 
    meldung 37        = "  epson sq         hp 74xx", 
    meldung 38        = "  epson fx", 
    meldung 39        = "  binder 8600", 
    meldung 40        = "  kyocera", 
    meldung 41        = "  hp laserjet", 
    meldung 42        = "Bitte warten - der Druckertreiber wird installiert", 
    meldung 43        = "Bitte zunächst das Mathematiksystem installieren.", 
    meldung 44        = 
         "Zunächst müssen die erforderlichen Dateien geladen werden.", 
    meldung 45        = "Passwort: ", 
    meldung 46        = "Soll das System mit einem Passwort geschützt werden", 
    meldung 47        = 
         "Fehler: Die Diskette ist ungültig oder nicht korrekt eingelegt!", 
    meldung 49        = "Installation vorzeitig abgebrochen", 
    meldung 50        = "Bitte legen sie eine Diskette der Anwendung", 
    meldung 51        = "in das Laufwerk und schließen es.", 
    meldung 52        = "Installation fortsetzen: <w>", 
    meldung 53        = "Installation abbrechen : <ESC>", 
    meldung 54        = "Bitte legen Sie eine weitere Diskette der Anwendung", 
    menutasten        = "12345q", 
    zeilen menu 1     = 10, 
    zeilen menu 2     = 12, 
    zeilen menu 3     = 14, 
 
(* d o  - Kommandos *) 
 
    menu ankoppeln    = "install menu (""ls-MENUKARTE:Mathematik"", FALSE)", 
    ebene 1 handle    = "handle menu (""Ebene 1"")", 
    ebene 2 handle    = "handle menu (""Ebene 2"")", 
    druckmenu handle  = "handle menu (""Drucken"")", 
    ibmsatzzeichen    = "ibmgraphicchar", 
    stdsatzzeichen    = "stdgraphicchar", 
    ibmops ankoppeln  = "load ops (""ibmoperatoren"")", 
    stdops ankoppeln  = "load ops (""standardoperatoren"")", 
    fe manager        = "formelmanager", 
    plotter ein       = "plotter eingestellt (TRUE)", 
    plotter aus       = "plotter eingestellt (FALSE)", 
 
(* Tasknamen *) 
 
    depot taskname    = "mathe depot", 
    ls mk taskname    = "ls-MENUKARTEN", 
    ls taskname       = "ls-ANWENDUNG", 
    fe taskname       = "FORMELEDITOR", 
    mathe taskname    = "Mathematik", 
    printer taskname  = "MATHE-PRINTER", 
    pridepot taskname = "MATHE-PRINTERDEPOT", 
    umstell taskname  = "DRUCKERANPASSUNGEN", 
    archivname        = "mathe", 
 
(* Bezeichner für Menükarte, Maskendatenraum und Programmanzahl *) 
 
    menukarte         = "ls-MENUKARTE:Mathematik", 
    maskenname        = "mathe formulare", 
    mathe kuerzel     = "mat.", 
    plot kuerzel      = " plot", 
    ls kuerzel        = "ls-DIALOG ", 
    mathe extension   = ".mathe", 
    operatorendatei 1 = "ibmoperatoren", 
    operatorendatei 2 = "standardoperatoren", 
    anzahl gesamt     = 29, 
    anzahl feprocs    =  6, 
    anzahl ls procs   =  5, 
    anzahl matheprocs = 18, 
    anzahl pri procs  =  6, 
    anzahl drucker ds = 16, 
 
(* Codes für Task-Kommunikation *) 
 
    ok                = 1111, 
    fehler            = 9999, 
    insertieren       = 2525, 
    drucker erzeugen  = 3260, 
    drucker1 erzeugen = 3261, 
    drucker8 erzeugen = 3268, 
    system starten    = 4444, 
    ebene 1 behandeln = 4445, 
    ebene 2 behandeln = 4446, 
    arbeitskanal      = 1, (* Es wird ohnehin nur das Terminal 1 genutzt!*) 
 
(* Sonstiges *) 
 
    del               = ""5"", 
    delpage           = ""4"", 
    bell              = ""7"", 
    left              = ""8"", 
    beginmark         = ""15"", 
    endmark           = ""14"", 
    weiter            = "w", 
    abbruch           = ""27"", 
    niltext           = ""; 
 
(* G l o b a l e   V a r i a b l e n *) 
 
TASK      VAR depot task, ls mk task, fe task, mathe task, ls task, 
              pridepot task, printer task, order task, umstelltask; 
THESAURUS VAR archivinhalt; 
TEXT      VAR graphicart, 
              installationspassword := niltext; 
INT       VAR druckerindex; 
BOOL      VAR ibmsatz; 
INT       VAR installationszaehler, antwort, order code; 
DATASPACE VAR message ds; 
BOOL      VAR mathematiksystem installiert := FALSE, 
              graphikdrucker installiert   := FALSE; 
ROW anzahl druckerds TEXT CONST druckerdatei :: 
ROW anzahl druckerds TEXT : ("ZEICHEN 8*8", 
                             "ZEICHEN 6*10", 
                             "ZEICHEN 8*16", 
                             "spool cmd", 
                             "mat.xerox4045 plot", 
                             "mat.epson-sq plot", 
                             "mat.epson-fx plot", 
                             "mat.binder plot", 
                             "mat.kyocera plot", 
                             "mat.laserjet plot", 
                             "mat.hp72xx plot", 
                             "mat.hp74xx plot", 
                             "mat.basis plot", 
                             "mat.picture", 
                             "mat.ausgabe", 
                             "mat.druckermenu"); 
ROW zeilen menu 1 TEXT CONST menu 1 :: 
ROW zeilen menu 1 TEXT : (meldung 3, meldung 4, meldung 5, meldung 6, 
                          meldung 7, meldung 8, niltext, meldung 9, 
                          niltext, meldung 10); 
ROW zeilen menu 2 TEXT CONST menu 2 :: 
ROW zeilen menu 2 TEXT : (meldung 11, meldung 12, meldung 13, niltext, 
                          meldung 14, meldung 15, meldung 16, meldung 17, 
                          niltext, meldung 18, meldung 19, meldung 20); 
ROW zeilen menu 3 TEXT CONST menu 3 :: 
ROW zeilen menu 3 TEXT : (meldung 11, meldung 34, niltext, meldung 35, 
                          meldung 36, meldung 37, meldung 38, meldung 39, 
                          meldung 40, meldung 41, niltext, meldung 18, 
                          meldung 19, meldung 20); 
 
(**************************************************************************) 
(*                          H a u p t m e n ü                             *) 
(**************************************************************************) 
(* Die folgende Prozeduren realisieren ein Menü mit 6 Optionen:           *) 
(*    1, 2: Ausführung des Mathematiksystems - sofern es noch nicht ein-  *) 
(*          gerichtet ist erfolgt eine Meldung.                           *) 
(*          Die Ausführung erfolgt durch Übergabe des Bildschirms an die  *) 
(*          Task 'Mathematik'                                             *) 
(*    3   : Ausführung eines Menüs in der Druckertask. Die Option setzt   *) 
(*          voraus, daß eine entsprechende Task eingerichtet ist. Ist dies*) 
(*          nicht der Fall erfolgt eine Meldung                           *) 
(*    4   : Installation des Mathematiksystems. Sofern es schon eingerich-*) 
(*          tet ist, erfolgt die Installation nur bei der Bejahung einer  *) 
(*          Abfrage, ob das vorhandene System gelöscht werden soll.       *) 
(*    5   : Installation des Druckertreibers. Sofern er schon eingerichtet*) 
(*          ist, erfolgt die Installation nur bei der Bejahung einer Ab-  *) 
(*          frage, ob das vorhandene System gelöscht werden soll.         *) 
(*          Ferner gilt: Ohne Mathematiksystem kann kein Druckertreiber   *) 
(*                       eingerichtet werden. Ein Löschen des Mathematik- *) 
(*                       systems löscht automatisch auch den Druckertrei- *) 
(*                       ber                                              *) 
(*    q   : Verlassen des Menüs                                           *) 
(*                                                                        *) 
(*  Die exportierte Schnittstelle 'mathe' dient als Fängerebene für die   *) 
(*  eigentliche Menü-Prozedur 'start system'                              *) 
(**************************************************************************) 
  
PROC mathe: 
 
  disable stop; 
  zeige kopierhinweis; (* 5.2.1991 *) 
  start system; 
  WHILE is error REP 
    clear error; 
    command dialogue (FALSE); 
    forget (all); 
    commanddialogue (TRUE); 
    zeige titelzeile (titel 1); 
    gib meldung (errormessage); 
    start system 
  END REP 
 
END PROC mathe; 
 
PROC start system: 
 
  TEXT VAR ch; 
  INT  VAR rang, zeile, xpos, ypos; 
  grundeinstellungen; 
  REP 
    zeige verwaltungsmenu; 
    warte auf korrekte eingabe; 
    werte eingabe aus 
  END REP. 
 
  grundeinstellungen: 
    enable stop; 
    check off; 
    warnings off. 
 
  zeige verwaltungsmenu: 
    zeige titelzeile (titel 1); 
    FOR zeile FROM 7 UPTO 16 REP 
      cursor (24, zeile); out (menu 1 (zeile - 6)) 
    END REP; 
    clear buffer. 
 
  warte auf korrekte eingabe: 
    get cursor (xpos, ypos); 
    REP 
      inchar (ch); 
      rang := pos (menutasten, ch); 
      IF rang = 0 THEN 
        out (bell) 
      ELSE 
        cursor (xpos + 1, ypos); out (ch); 
      END IF 
    UNTIL rang <> 0 END REP. 
 
  werte eingabe aus: 
    SELECT rang OF 
      CASE 1, 2: fuehre mathesystem aus 
      CASE 3   : fuehre druckermenu aus 
      CASE 4   : installiere mathesystem 
      CASE 5   : installiere druckeranpassung 
      OTHERWISE  LEAVE start system (* = 6 *) 
    END SELECT. 
 
    fuehre mathesystem aus: 
      IF NOT mathematiksystem installiert THEN 
        out (bell); 
        gib meldung (meldung 1); 
        LEAVE fuehre mathesystem aus 
      END IF; 
      uebergib bildschirm (mathe task, system starten + rang). 
     
    fuehre druckermenu aus: 
      IF NOT graphikdrucker installiert THEN 
        out (bell); 
        gib meldung (meldung 2); 
        LEAVE fuehre druckermenu aus 
      END IF; 
      uebergib bildschirm (/printer taskname, system starten). 
      
    installiere druckeranpassung: 
      IF NOT mathematiksystem installiert THEN 
        out (bell); 
        gib meldung (meldung 43); 
        LEAVE installiere druckeranpassung 
      END IF; 
      IF graphikdrucker installiert CAND NOT ja (meldung 25) THEN 
        LEAVE installiere druckeranpassung 
      END IF; 
      start printer installation;  
      IF is error THEN 
        clear error; 
        gib meldung (errormessage); 
      ELSE 
        zeige installationsergebnis (titel 3, graphikdrucker installiert) 
      END IF 
 
END PROC start system; 
 
PROC zeige kopierhinweis: (* Eingefügt 5.2.1991 - R.Kraft *) 
 
LET z1 = "schulis - Mathematiksystem", 
    z2 = "Lizenzfreie Software der", 
    z3 = "Gesellschaft für Mathematik und Datenverarbeitung mbH", 
    z4 = "Die Nutzung der Software ist nur im Schul- und Hochschulbereich", 
    z5 = "für nichtkommerzielle Zwecke gestattet.", 
    z6 = "Gewährleistung und Haftung werden ausgeschlossen.", 
    z7 = "Weiter mit beliebiger Taste"; 
 
    page; 
    cursor (26, 3); out (z1); 
    cursor (27, 8); out (z2); 
    cursor (13,10); out (z3); 
    cursor ( 8,14); out (z4); 
    cursor (20,15); out (z5); 
    cursor (16,17); out (z6); 
    cursor (26,23); out (z7); 
    pause (50)
 
END PROC zeige kopierhinweis; 
 
(***********************************************************************) 
(* I n s t a l l a t i o n   d e s   M a t h e m a t i k s y s t e m s *) 
(***********************************************************************) 
(* Das folgende Programm installiert das Mathematiksystem.             *) 
(* Dabei werden ggf existierende Tasks eines alten Mathematiksystems   *) 
(* gelöscht. Es handelt sich dabei um die ls-Task als Vatertask für    *) 
(* Druckeranpassung, Formeleditor und Mathematiksystem sowie die       *) 
(* Depottask (= Zwischenspeicher für die benötigten Quelldateien).     *) 
(* Die erforderliche Graphik und Halbgraphikanpassung werden im Dialog *) 
(* bestimmt.                                                           *) 
(* Die Dateien werden vom Archiv gelesen und in die Zwischenspeicher   *) 
(* Tasks geschickt. Anschließend erfolgt die Installation folgender    *) 
(* Taskstruktur:  ls-ANWENDUNG                                         *) 
(*                     Mathematik                                      *) 
(*                     FORMELEDITOR                                    *) 
(*                ls-MENUKARTEN                                        *) 
(*                DRUCKERANPASSUNGEN                                   *) 
(* Die Zwischenspeichertask wird abschließend gelöscht.                *) 
(***********************************************************************) 
 
PROC installiere mathesystem: 
 
  IF NOT korrektes password THEN 
    LEAVE installiere mathesystem 
  END IF; 
  IF mathematiksystem installiert CAND NOT ja (meldung 24) THEN 
    LEAVE installiere mathesystem 
  END IF; 
  start mathe installation; 
  zeige installationsergebnis (titel 2, mathematiksystem installiert); 
  IF mathematiksystem installiert THEN 
    definiere password 
  END IF; 
  graphikdrucker installiert := FALSE. 
 
END PROC installiere mathesystem; 
 
PROC start mathe installation: 
 
  INT VAR i; 
  bestimme graphic und halbgraphic; 
  IF NOT erforderliche systemdateien eingelesen THEN 
    errorstop (meldung 49) 
  END IF; 
  loesche ggf vorhandene tasks; 
  richte ggf lsmenukarten ein; 
  richte sicherungstasks ein;  
  sichere dateien; 
  melde installationsbeginn; 
  richte ls task ein; 
  richte formeleditor ein; 
  richte mathetask ein; 
  loesche depottask. 
 
  bestimme graphic und halbgraphic: 
    graphicart := graphikkarte; 
    ibmsatz := ja (meldung 23). 
 
  loesche ggf vorhandene tasks: 
    IF exists task (depot taskname) THEN end (/depot taskname) END IF; 
    IF exists task (ls taskname) THEN end (/ls taskname) END IF. 
 
  richte ggf lsmenukarten ein: 
    IF NOT exists task (ls mk taskname) THEN 
      begin (ls mk taskname, PROC free global manager, ls mk task) 
    ELSE 
      ls mk task := /ls mk taskname 
    END IF. 
 
  richte sicherungstasks ein: 
    begin (depot taskname, PROC free global manager, depot task); 
    IF NOT exists task (umstell taskname) THEN 
      begin (umstell taskname, PROC free global manager, umstell task) 
    ELSE 
      umstell task := /umstell taskname 
    END IF. 
 
  sichere dateien: 
    commanddialogue (FALSE); 
    save (menukarte, ls mk task); 
    save (maskenname, ls mk task); 
    save (archivinhalt, depot task); 
    FOR i FROM 1 UPTO anzahl drucker ds REP 
      IF NOT exists (druckerdatei (i), umstelltask) THEN 
        save (druckerdatei (i), umstelltask) 
      END IF 
    END REP; 
    forget (archivinhalt). 
 
  melde installationsbeginn: 
    zeige titelzeile (titel 2); 
    cursor (15, 10); out (meldung 30); 
    cursor (15, 12); out (meldung 31 + text (anzahl gesamt) + " Dateien"); 
    installationszaehler := 0. 
 
  richte ls task ein: 
    begin (ls taskname, PROC install ls, ls task); 
    FOR i FROM 1 UPTO anzahl ls procs REP 
      insertiere programme (ls task) 
    END REP. 
 
  richte formeleditor ein: 
    REP UNTIL exists task (fe taskname) CAND 
              status (/fe taskname) = 2 END REP; 
    fe task := /fe taskname; 
    FOR i FROM 1 UPTO anzahl fe procs REP 
      insertiere programme (fe task) 
    END REP. 
 
  richte mathetask ein: 
    REP UNTIL exists task (mathe taskname) CAND 
              status (/mathe taskname) = 2 END REP; 
    mathe task := /mathe taskname; 
    FOR i FROM 1 UPTO anzahl mathe procs REP 
      insertiere programme (mathe task) 
    END REP. 
 
  loesche depottask: 
    end (depot task) 
 
END PROC start mathe installation; 
 
(* Einlesen der benötigten Dateien *) 
 
BOOL PROC erforderliche systemdateien eingelesen: 
 
  LET dateien       = 53, 
      nicht geladen = "0", 
      geladen       = "1"; 
  ROW dateien TEXT CONST systemdatei :: 
  ROW dateien TEXT : ("mat.ega plot", "mat.cga plot", 
                      "mat.hercules plot", "mat.vga plot", 
                      "ls-DIALOG 1.mathe", "ls-DIALOG 2.mathe", 
                      "ls-DIALOG 3.mathe", "ls-DIALOG 4.mathe", 
                      "ls-DIALOG 5.mathe", "PAC text row", 
                      "PAC element row",   "PAC op store-anpassung", 
                      "PAC formula analyzer", "PAC formula editor-anpassung", 
                      "mat.formeleditormanager", "mat.vector", 
                      "mat.referenzobjekte", "mat.funktionsbibliothek", 
                      "mat.abbildung", "mat.parser", 
                      "mat.basis plot", "mat.picture", 
                      "mat.specialgraphic", "mat.dialoghilfen", 
                      "mat.masken", "mat.menufunktionen", 
                      "mat.wertetabelle", "mat.graphicverfahren", 
                      "mat.integrationsverfahren", "mat.iterationsverfahren", 
                      "mat.nullstellen", "mat.umformung", 
                      "mat.xerox4045 plot", "mat.epson-sq plot", 
                      "mat.epson-fx plot", "mat.binder plot", 
                      "mat.kyocera plot", "mat.laserjet plot", 
                      "mat.hp72xx plot", "mat.hp74xx plot", 
                      "spool cmd", "mat.ausgabe", 
                      "mat.druckermenu", "ZEICHEN 8*8", 
                      "ZEICHEN 9*14", "ZEICHEN 8*19", 
                      "ZEICHEN 8*14", "ZEICHEN 6*10", 
                      "ZEICHEN 8*16", "mathe formulare", 
                      "ls-MENUKARTE:Mathematik", "ibmoperatoren", 
                      "standardoperatoren"); 
  TEXT      VAR   anweisung   := meldung 50, 
                  pruefleiste := dateien * nicht geladen; 
  TEXT      CONST ziel        := dateien * geladen, 
                  anpassung   := mathe kuerzel + graphicart + plot kuerzel; 
  INT       VAR   i, zaehler  := 1; 
  THESAURUS VAR   diskinhalt; 
  zeige titelzeile (titel 2); 
  archivinhalt := empty thesaurus; 
  FOR i FROM 1 UPTO 4 REP 
    IF systemdatei (i) <> anpassung THEN 
      replace (pruefleiste, i, geladen) 
    END IF 
  END REP; 
  REP 
    warte auf eingabe; 
    FOR i FROM 1 UPTO dateien REP 
      IF (pruefleiste SUB i) = nicht geladen CAND 
         (diskinhalt CONTAINS systemdatei (i)) THEN 
        lade die datei 
      END IF 
    END REP; 
    anweisung := meldung 54 
  UNTIL pruefleiste = ziel END REP; 
  abschlussaktivitaeten; 
  TRUE. 
 
  zeige texte: 
    cursor (8,  8); out (meldung 44); 
    cursor (8,  9); out (anweisung); 
    cursor (8, 10); out (meldung 51); 
    cursor (8, 12); out (meldung 52); 
    cursor (8, 13); out (meldung 53). 
 
  warte auf eingabe: 
    TEXT VAR ch; 
    REP 
      zeige texte; 
      inchar (ch); 
      IF ch = abbruch THEN 
        release (archive); 
        LEAVE erforderliche systemdateien eingelesen WITH FALSE 
      ELIF ch = weiter THEN 
        disable stop; 
        cursor (8, 9); out (del); 
        cursor (8,10); out (del); 
        cursor (8,12); out (del); 
        cursor (8,13); out (del); 
        cursor (8,15); out (del); 
        archive (archivname); 
        diskinhalt := ALL archive; 
        IF is error THEN 
          clear error; 
          cursor (8, 15); out (meldung 47); 
          enable stop; 
        ELSE 
          enable stop; 
          LEAVE warte auf eingabe 
        END IF 
      ELSE 
        out (bell) 
      END IF 
    END REP. 
 
  lade die datei: 
    cursor (8, 9); out (meldung 27 + text (zaehler) + " von 50 Dateien"); 
    fetch (systemdatei (i), archive); 
    replace (pruefleiste, i, geladen); 
    insert (archivinhalt, systemdatei (i)); 
    zaehler INCR 1. 
 
  abschlussaktivitaeten: 
    release (archive); 
    cursor (8, 8); out (meldung 28 + del); 
    cursor (8, 9); out (meldung 29 + del); 
    pause (50) 
 
END PROC erforderliche systemdateien eingelesen; 
 
(* Installation der ls task *) 
 
PROC install ls: 
 
  INT VAR i; 
  FOR i FROM 1 UPTO anzahl ls procs REP 
    insertiere (lskuerzel + text (i) + mathe extension, depot task) 
  END REP; 
  do (menu ankoppeln); 
  IF ibmsatz THEN 
    do (ibmsatzzeichen) 
  ELSE 
    do (stdsatzzeichen) 
  END IF; 
  begin (fe taskname, PROC install formeleditor, fe task); 
  begin (mathe taskname, PROC install mathe, mathe task); 
  disable stop; 
  REP 
    REP 
      warte auf auftrag 
    UNTIL order code >= drucker1 erzeugen CAND 
          order code <= drucker8 erzeugen END REP; 
    druckerindex := order code - drucker erzeugen; 
    begin (printer taskname, PROC install printer, printer task);    
    gib antwort (ok)    
  END REP 
 
END PROC install ls; 
 
(* Installation des Formeleditors *) 
 
PROC install formeleditor: 
 
  ROW anzahl feprocs TEXT CONST feproc :: 
  ROW anzahl feprocs TEXT : ("PAC text row", 
                             "PAC element row", 
                             "PAC op store-anpassung", 
                             "PAC formula analyzer", 
                             "PAC formula editor-anpassung", 
                             "mat.formeleditormanager"); 
  INT VAR i; 
  FOR i FROM 1 UPTO anzahl fe procs REP 
    insertiere (feproc (i), depot task) 
  END REP; 
  do (menu ankoppeln); 
  hole notfalls (operatorendatei 1, depot task); 
  hole notfalls (operatorendatei 2, depot task); 
  IF ibmsatz THEN 
    do (ibmops ankoppeln) 
  ELSE 
    do (std ops ankoppeln) 
  END IF; 
  do (fe manager) 
   
END PROC install formeleditor; 
 
(* Installation des eigentlichen Mathematiksystems *) 
 
PROC install mathe: 
 
  ROW anzahl matheprocs TEXT CONST dname := 
  ROW anzahl matheprocs TEXT : ("mat.vector", 
                                "mat.referenzobjekte", 
                                "mat.funktionsbibliothek", 
                                "mat.abbildung", 
                                "mat.parser", 
                                "mat.masken", 
                                mathekuerzel + graphicart + plotkuerzel, 
                                "mat.basis plot", 
                                "mat.picture", 
                                "mat.specialgraphic", 
                                "mat.dialoghilfen", 
                                "mat.menufunktionen", 
                                "mat.graphicverfahren", 
                                "mat.wertetabelle", 
                                "mat.nullstellen", 
                                "mat.umformung", 
                                "mat.integrationsverfahren", 
                                "mat.iterationsverfahren"); 
  INT VAR i; 
  TEXT CONST zugehoerende zeichen := passender zeichensatz; 
  insertiere mathesystem; 
  beende installation. 
 
  passenderzeichensatz: 
    IF graphicart   = "vga" THEN 
      "ZEICHEN 8*19" 
    ELIF graphicart = "ega" THEN 
      "ZEICHEN 8*14" 
    ELIF graphicart = "cga" THEN 
      "ZEICHEN 8*8" 
    ELSE  (* "hercules" *) 
      "ZEICHEN 9*14" 
    END IF. 
 
  insertiere mathesystem: 
    do (menu ankoppeln); 
    hole notfalls (zugehoerende zeichen, depot task); 
    FOR i FROM 1 UPTO anzahl matheprocs REP 
      insertiere (dname (i), depot task) 
    PER. 
 
  beende installation: 
    TEXT VAR arbeitsauftrag; 
    commanddialogue (FALSE); 
    forget (all - maskenname); 
    commanddialogue (TRUE); 
    disable stop; 
    REP 
      REP 
        warte auf auftrag 
      UNTIL order code = ebene 1 behandeln COR 
            order code = ebene 2 behandeln END REP; 
      continue (arbeitskanal); 
      IF order code = ebene 1 behandeln THEN 
        arbeitsauftrag := ebene 1 handle 
      ELSE 
        arbeitsauftrag := ebene 2 handle 
      END IF; 
      do (arbeitsauftrag); 
      gib bildschirm frei (ok) 
    END REP 
 
END PROC install mathe; 
 
(*********************************************************************) 
(*  I n s t a l l a t i o n   d e s   D r u c k e r t r e i b e r s  *) 
(*********************************************************************) 
 
PROC start printer installation: 
 
  loesche ggf vorhandene task; 
  bestimme druckeranpassung; 
  melde installationsbeginn; 
  richte druckertasks ein. 
 
  loesche ggf vorhandene task: 
    IF exists task (printer taskname) THEN end (/printer taskname) END IF. 
 
  bestimme druckeranpassung: 
    druckerindex := druckertreiber. 
 
  melde installationsbeginn: 
    INT VAR ende := anzahl pri procs; 
    IF druckerindex > 6 THEN 
      ende DECR 1 
    END IF; 
    zeige titelzeile (titel 2); 
    cursor (15, 10); out (meldung 42); 
    cursor (15, 12); out (meldung 31 + text (ende) + " Dateien"); 
    installationszaehler := 0. 
 
  richte druckertasks ein: 
    INT VAR i; 
    IF NOT exists task (pridepot taskname) THEN 
      begin (pridepot taskname, PROC free global manager, pridepot task) 
    END IF; 
    ls task := /ls taskname; 
    rufe (ls task, drucker erzeugen + druckerindex);   
    REP UNTIL exists task (printer taskname) CAND 
              status (/printer taskname) = 2 END REP; 
    printer task := /printer taskname; 
    FOR i FROM 1 UPTO ende REP 
      insertiere programme (printer task) 
    END REP   
 
END PROC start printer installation; 
 
(* Installation des Druckers *) 
 
PROC install printer: 
 
  LET anzahl zeichensaetze   = 3; 
  ROW anzahl priprocs TEXT CONST programm :: 
  ROW anzahl priprocs TEXT : (druckerdatei (4), 
                              druckerdatei (4 + druckerindex), 
                              druckerdatei (13), druckerdatei (14), 
                              druckerdatei (15), druckerdatei (16)); 
  INT VAR i; 
  BOOL VAR plotter wird installiert := druckerindex > 6; 
  do (menu ankoppeln); 
  IF NOT plotter wird installiert THEN 
    hole zeichensaetze 
  END IF; 
  insertiere die einzelnen programme;  
  abschlussaktivitaet. 
 
  hole zeichensaetze: 
    FOR i FROM 1 UPTO anzahl zeichensaetze REP 
      hole notfalls (druckerdatei (i), /umstell taskname) 
    PER. 
 
  insertiere die einzelnen programme: 
    INT VAR anfang := 1; 
    IF plotter wird installiert THEN 
      anfang := 2 
    END IF; 
    FOR i FROM anfang UPTO anzahl pri procs REP 
      insertiere (programm (i), /umstell taskname) 
    END REP. 
 
  abschlussaktivitaet: 
    IF NOT plotter wird installiert THEN 
      FOR i FROM 1 UPTO anzahl zeichensaetze REP 
        forget (druckerdatei (i), quiet) 
      END REP 
    END IF;  
    IF plotter wird installiert THEN 
      do (plotter ein) 
    ELSE 
      do (plotter aus) 
    END IF; 
    disable stop; 
    REP 
      REP 
        warte auf auftrag 
      UNTIL order code = system starten END REP; 
      continue (arbeitskanal); 
      do (druckmenu handle); 
      gib bildschirm frei (ok) 
    END REP 
 
END PROC install printer; 
 
(*********************************) 
(*  H i l f s p r o g r a m m e  *) 
(*********************************) 
 
(* Programme zur Ausführung des 'insert' *) 
 
PROC insertiere programme (TASK VAR zieltask): 
 
  installationszaehler INCR 1; 
  cursor (40, 12); out (text (installationszaehler)); 
  rufe (zieltask, insertieren); 
  IF antwort <> ok THEN 
    errorstop (meldung 32) 
  END IF 
 
END PROC insertiere programme; 
 
PROC insertiere (TEXT CONST name, TASK CONST herkunft): 
 
  REP 
    warte auf auftrag 
  UNTIL order code = insertieren END REP; 
  disable stop; 
  hole notfalls (name, herkunft); 
  insert (name); 
  IF is error THEN 
    clear error; 
    gib antwort (fehler) 
  ELSE 
    gib antwort (ok) 
  END IF; 
  forget (name, quiet); 
  enable stop 
 
END PROC insertiere; 
 
PROC hole notfalls (TEXT CONST name, TASK CONST herkunft): 
 
  IF NOT exists (name) THEN 
    fetch (name, herkunft) 
  END IF 
 
END PROC hole notfalls; 
 
(***********************************************) 
(*    Prozeduren zur Intertaskkommunikation    *) 
(***********************************************) 
 
(* Die folgenden Prozeduren werden immer da eingesetzt, wo bei 
   'call', 'send' und 'wait' der übergebene Datenraum ignoriert 
   werden kann *) 
 
PROC rufe (TASK CONST zieltask, INT CONST auftrag): 
 
  message ds := nilspace; 
  call (zieltask, auftrag, message ds, antwort); 
  forget (message ds)     
 
END PROC rufe; 
 
PROC warte auf auftrag: 
 
  wait (message ds, order code, order task); 
  forget (message ds)    
 
END PROC warte auf auftrag; 
 
PROC gib antwort (INT CONST antwortcode): 
 
  message ds := nilspace; 
  send (order task, antwortcode, message ds); 
(*forget (message ds) *) 
 
END PROC gib antwort; 
 
PROC uebergib bildschirm (TASK CONST t, INT CONST auftrag): 
 
   break (quiet); 
   rufe (t, auftrag); 
   continue (arbeitskanal) 
 
END PROC uebergib bildschirm; 
 
PROC gib bildschirm frei (INT CONST antwortcode): 
 
  break (quiet); 
  gib antwort (antwortcode) 
 
END PROC gib bildschirm frei; 
 
(********************************************************) 
(*         Auswahlmenüs für Endgeräteanpassungen        *) 
(********************************************************) 
 
TEXT PROC graphikkarte: 
 
  LET anzahl plotprocs = 4; 
  ROW anzahl plotprocs TEXT CONST plotname := 
  ROW anzahl plotprocs TEXT : ("hercules","cga","ega","vga"); 
  INT VAR i := 1, zeile; 
  commanddialogue (TRUE); 
  zeige titelzeile (titel 2); 
  FOR zeile FROM 6 UPTO 17 REP 
    cursor (16, zeile); out (menu 2 (zeile - 5)) 
  END REP; 
  REP 
    cursor (16, 20); out (invers (text (plotname (i), 11))); 
    IF yes (meldung 33) THEN 
      commanddialogue (FALSE); 
      LEAVE graphikkarte WITH plotname (i) 
    END IF; 
    i := i MOD anzahl plotprocs + 1 
  END REP; 
  plotname (i) 
 
END PROC graphikkarte; 
 
INT PROC druckertreiber: 
 
  LET anzahl plotterprocs = 8; 
  ROW anzahl plotterprocs TEXT CONST plotname := 
  ROW anzahl plotterprocs TEXT : ("xerox4045", "epson-sq", "epson-fx", 
                                  "binder", "kyocera", "laserjet", 
                                  "hp72xx", "hp74xx"); 
  INT VAR i, zeile; 
  commanddialogue (TRUE); 
  zeige titelzeile (titel 3); 
  FOR zeile FROM 3 UPTO 16 REP 
    cursor (16, zeile); out (menu 3 (zeile - 2)) 
  END REP; 
  i := 1; 
  REP 
    cursor (16, 20); out (invers (text (plotname (i), 11))); 
    IF yes (meldung 33) THEN 
      commanddialogue (FALSE); 
      LEAVE druckertreiber WITH i 
    END IF; 
    i := i MOD anzahl plotterprocs + 1 
  END REP; 
  i 
 
END PROC druckertreiber; 
 
(************************************************) 
(*            Bildschirmausgaben                *) 
(************************************************) 
 
PROC zeige titelzeile (TEXT CONST fktbezeichner): 
 
  TEXT CONST zeile := text (systemname, 78 - length (fktbezeichner)) + 
                            fktbezeichner; 
  page; 
  cursor (1,1); out (invers (text (zeile, 79))) 
   
END PROC zeige titelzeile; 
 
PROC zeige installationsergebnis (TEXT CONST ziel, BOOL VAR erfolg): 
 
  zeige titelzeile (ziel); 
  IF is error THEN 
    clear error; 
    gib meldung (meldung 22); 
    erfolg := FALSE 
  ELSE 
     gib meldung (meldung 21); 
     erfolg := TRUE 
   END IF 
 
END PROC zeige installationsergebnis; 
 
PROC gib meldung (TEXT CONST meldungstext): 
 
  cursor (1, 23); out (meldungstext); 
  cursor (1, 24); out (invers (text (meldung 26, 77))); 
  clear buffer; pause 
 
END PROC gib meldung; 
 
PROC clear buffer: 
 
  REP UNTIL incharety = niltext PER 
 
END PROC clear buffer; 
 
BOOL PROC ja (TEXT CONST frage): 
 
  BOOL VAR antwort; 
  commanddialogue (TRUE); 
  cursor (1, 22); antwort := yes (frage); 
  cursor (1, 22); out (del); 
  commanddialogue (FALSE); 
  antwort 
 
END PROC ja; 
 
TEXT PROC invers (TEXT CONST t): 
 
  beginmark + t + endmark 
 
END PROC invers; 
 
(*************************************************************************) 
(*                    P a s s w o r t s c h u t z                        *) 
(*************************************************************************) 
(* Zur Vermeidung einer irrtümlichen oder 'böswilligen' Neuinstallation  *) 
(* des Mathesystems kann nach erfolgter Installation ein Passwort verge- *) 
(* ben werden, das beim Versuch der Neuinstallation abgefragt wird.      *) 
(*************************************************************************) 
 
BOOL PROC korrektes password: 
  
  installationspassword = niltext COR password getroffen. 
 
  password getroffen: 
  TEXT VAR eingabe; 
  cursor (24, 18); out (meldung 45 + del);  
  get secret line (eingabe); 
  IF eingabe = installationspassword THEN 
    cursor (24, 18); out (del); 
    LEAVE password getroffen WITH TRUE 
  END IF; 
  out (bell); 
  FALSE 
 
END PROC korrektes password; 
 
PROC definiere password: 
 
  installationspassword := niltext; 
  cursor (1, 23); out (delpage); 
  IF ja (meldung 46) THEN 
    cursor (1, 23); out (meldung 45 + beginmark + left); 
    editget (installationspassword, 40, 20); 
    out (endmark) 
  END IF 
 
END PROC definiere password; 
 
END PACKET mathe verwaltung;