From 04e68443040c7abad84d66477e98f93bed701760 Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Mon, 4 Feb 2019 13:09:03 +0100 Subject: Initial import --- app/flint/0.4/doc/Zusammenstellung | 62 ++ app/flint/0.4/doc/flint.kurzanleitung | 141 +++++ app/flint/0.4/source-disk | 1 + app/flint/0.4/src/MENUE.gen | 93 +++ app/flint/0.4/src/OPMENUE.gen | 42 ++ app/flint/0.4/src/boxzeichen | 3 + app/flint/0.4/src/dummy.configurate | 6 + app/flint/0.4/src/editormenue | 1008 +++++++++++++++++++++++++++++++++ app/flint/0.4/src/eudas.manager | 216 +++++++ app/flint/0.4/src/flint | 808 ++++++++++++++++++++++++++ app/flint/0.4/src/flint.init | 603 ++++++++++++++++++++ app/flint/0.4/src/flint.manager | 16 + app/flint/0.4/src/isub.replace | 19 + app/flint/0.4/src/klartextbelegung | 304 ++++++++++ app/flint/0.4/src/offline.1 | 5 + app/flint/0.4/src/offline.manager | 383 +++++++++++++ app/flint/0.4/src/operator | 381 +++++++++++++ app/flint/0.4/src/operator.1 | 39 ++ app/flint/0.4/src/operator.init | 390 +++++++++++++ app/flint/0.4/src/operator.manager | 34 ++ app/flint/0.4/src/operator.spoolcmd | 113 ++++ 21 files changed, 4667 insertions(+) create mode 100644 app/flint/0.4/doc/Zusammenstellung create mode 100644 app/flint/0.4/doc/flint.kurzanleitung create mode 100644 app/flint/0.4/source-disk create mode 100644 app/flint/0.4/src/MENUE.gen create mode 100644 app/flint/0.4/src/OPMENUE.gen create mode 100644 app/flint/0.4/src/boxzeichen create mode 100644 app/flint/0.4/src/dummy.configurate create mode 100644 app/flint/0.4/src/editormenue create mode 100644 app/flint/0.4/src/eudas.manager create mode 100644 app/flint/0.4/src/flint create mode 100644 app/flint/0.4/src/flint.init create mode 100644 app/flint/0.4/src/flint.manager create mode 100644 app/flint/0.4/src/isub.replace create mode 100644 app/flint/0.4/src/klartextbelegung create mode 100644 app/flint/0.4/src/offline.1 create mode 100644 app/flint/0.4/src/offline.manager create mode 100644 app/flint/0.4/src/operator create mode 100644 app/flint/0.4/src/operator.1 create mode 100644 app/flint/0.4/src/operator.init create mode 100644 app/flint/0.4/src/operator.manager create mode 100644 app/flint/0.4/src/operator.spoolcmd (limited to 'app/flint') diff --git a/app/flint/0.4/doc/Zusammenstellung b/app/flint/0.4/doc/Zusammenstellung new file mode 100644 index 0000000..cad83c0 --- /dev/null +++ b/app/flint/0.4/doc/Zusammenstellung @@ -0,0 +1,62 @@ +Task "MENUE" unter "UR" +----------------------- + +"menues.1" = "eudas.satzzugriffe" + "eudas.fenster" + "eudas.menues" +"offline.1" = "offline.manager" +IF ibm grafik THEN run ("boxzeichen") END IF +global manager + + +Task "OPMENUE" unter "SYSUR" +---------------------------- + +"menues.1" +"offline.1" +"operator.1" = "operator.spoolcmd" + "operator.manager" + "operator" +menuedaten einlesen ("operator.init") +IF ibm grafik THEN run ("boxzeichen") END IF +global manager + + +Task "OP" unter "OPMENUE" +------------------------- + + +Task "EUDAS" unter "MENUE" (oder auch in "FLINT") +------------------------------------------------- + +"eudas.1" = "eudas.dateistruktur" + "eudas.datenverwaltung" +"eudas.2" = "eudas.verarbeitung" + "eudas.drucken" +"eudas.3" = "eudas.satzanzeige" + "eudas.uebersicht" +"eudas.4" = "eudas.dialoghilfen" + "eudas.steuerung" +menuedaten einlesen ("eudas.init") +global manager + + +Task "FLINT" unter "EUDAS" +-------------------------- + +"flint.1" = "klartextbelegung" + "editormenue" + "eudas.manager" + "flint.manager" + "flint" +menuedaten einlesen ("flint.init") +global manager + + + +Hinweise für L3: + +- Vor "menues.1" muß jeweils "isub.replace" insertiert werden. +- In "offline.1" ist das Vorkommen von "PROCA" zu entfernen. +- Vor "operator.1" muß eine Dummy-Prozedur 'configurate' insertiert werden. + diff --git a/app/flint/0.4/doc/flint.kurzanleitung b/app/flint/0.4/doc/flint.kurzanleitung new file mode 100644 index 0000000..25608c3 --- /dev/null +++ b/app/flint/0.4/doc/flint.kurzanleitung @@ -0,0 +1,141 @@ +Hinweise zur FLINT-Testversion 0.4 +---------------------------------- + +1. Installation + +Die Installation läuft in folgenden Schritten ab: + +- Task "OPMENUE" als Sohn von "SYSUR" einrichten. + Dort "OPMENUE.gen" vom Archiv holen und starten. + Warten bis zur Tapete. + +- Task "MENUE" als Sohn von "UR" einrichten. + Dort "MENUE.gen" vom Archiv holen und starten. + Warten bis zur Tapete. + + +2. Kurzanleitung + +Arbeitstasks unter "FLINT" einrichten. Beim Einrichten vom Supervisor aus +koppelt sich die neue Task sofort ab und muß mit 'continue' wieder ange­ +koppelt werden. Es erscheint das FLINT-Hauptmenue. + +Zur Bedienung der Menüs s. EUDAS-Handbuch. Hilfestellungen zu jeder +Funktion mit ESC '?'. + +Die Punkte im ersten Menü führen jeweils in Unterapplikationen. Der Punkt +'Systemsteuerung' koppelt automatisch die Task "OP" an und zeigt dort das +Operatormenü. Bei ESC 'q' erfolgt Rückkehr in die eigene Task. + +Wechsel in eine andere Task (mit Einrichten bei Bedarf) geschieht mit dem +Menüpunkt 'Wechsel' im dritten Menü. Dies funktioniert aber nur mit Nach­ +fahren von FLINT. Falls niltext als Name angegeben wird, kann man die Task +abkoppeln. + +Im Operatormenü führt 'Beenden' zu einem Shutup mit anschließender Rückkehr +in die aufrufende Task. Einige Funktionen sind derzeit noch nicht implemen­ +tiert. + + +3. Textverarbeitung + +Unter dem Hauptmenüpunkt 'Textverarbeitung' wird ein Menü aufgerufen, das +die Kommandos der EUMEL-Textverarbeitung als Menüpunkte aufführt. Welche +Kommandos jeweils gemeint sind, ist durch ESC '?' zu erfragen bzw. auszu­ +probieren (eine genauere Beschreibung liegt aus Zeitmangel noch nicht vor). + + +4. Menüs im Editor + +Zur Unterstützung der Arbeit im Editor kann man auch dort Menüs aufrufen, +und zwar über ESC 'm' (Edit-Menü) und ESC 't' (Text-Menü). Bei den Menüs +handelt es sich um Zeilenmenüs, die am unteren Bildrand autauchen, um die +Sicht auf die Datei möglichst wenig einzuengen. Eine Funktion kann mit den +Cursortasten ausgewählt und mit Leertaste (oder RETURN) ausgeführt werden. +Alternativ Aufruf über Anfangsbuchstaben. Das Menü kann mit ESC 'q' ohne +Wirkung verlassen werden. + + +5. Edit-Menü + +Hier stehen Funktionen zur Verfügung, die normalerweise nach ESC ESC als +Kommandos formuliert werden. Die Funktionen zum Suchen und Ersetzen werden +nach Ausführung auf 'f' gelegt, so daß sie mit ESC 'f' wiederholt werden +können. + +Als Zusatz steht eine Funktion zur Verfügung, mit der Lernsequenzen im +Klartext editiert werden können. Die Funktionstasten werden dabei durch +Namen in spitzen Klammern geschrieben (erlaubt sind u.a. + ). +Leerzeichen werden beachtet, aber Zeilenübergänge ignoriert. + +Ebenfalls neu sind Funktionen zum Markieren von Wörten und Sätzen (von Wort +bis Satzende), die für die folgende Einstellung von Modifikationen verwen­ +det werden können. + +'Kopiere' ruft entweder PUT oder GET auf, je nachdem, ob ein Block markiert +ist oder nicht. Die Funktion kann mit ESC 'h' abgebrochen werden. + +Mit 'Fenster' kann ein zweites Editorfenster in der unteren Hälfte eröffnet +werden (geplant ist später, daß die Unterteilung des Schirms sowohl hori­ +zontal als auch vertikal erfolgen kann). + + +6. Text-Menü + +Dieses Menü hilft bei der Formulierung von Textkosmetik-Anweisungen. Die +entsprechenden Anweisungen werden an der Cursorposition oder, falls notwen­ +dig, am Zeilenanfang eingefügt. + +Die Funktion zum Einstellen von Modifikationen hat zwei verschiedene Mög­ +lichkeiten: Falls kein Text markiert ist, werden die angekreuzten Modifi­ +kationen ein- oder ausgeschaltet (je nachdem, ob "Aus" angekreuzt ist). +Falls ein Text markiert ist, werden alle Modifikationsanweisungen am Anfang +und Ende des Bereichs entfernt und die angekreuzten Modifikationen für +diesen Bereich eingestellt, wenn nicht "Aus" angekreuzt ist. + +Die globalen Einstellungen für eine Datei werden an den Anfang geschrieben, +wobei die vorherigen Einstellungen ggf. entfernt werden können. + +Der markierte Ausschnitt einer Datei kann mit 'lineform' bearbeitet und +auch mit vorheriger Formatierung gedruckt werden. + + +7. Literatur + +Kann als Zusatzmodul insertiert werden. Dazu "litmenue" insertieren und +anschließend 'menuedaten einlesen ("litmenue.init")' aufrufen. Das Menü +steht dann durch Aufruf von 'literatur' im Editor zur Verfügung (kann und +sollte auf eine Funktionstaste gelegt werden). + +Die zu verwendenden Literaturdateien müssen vorher in EUDAS eingerichtet und +gewartet werden. Einzige Bedingung zur Verwendung ist, daß das erste Feld +als Signatur für einen bestimmten Titel verwendet werden kann. Der Inhalt +dieses Feldes sollte zur Zeit aus technischen Gründen keine +Suchmuster-Steuerzeichen (,;*--++..) enthalten. Diese Einschränkung wird +später aufgehoben. + +Die Funktion 'Literatur' dient dazu, eine bestimmte EUDAS-Datei als +Literaturdatei einzustellen. Geänderte EUDAS-Dateien beliebiger Art müssen +vor Aufruf des Literaturmenüs gesichert werden! + +Durch 'Zeigen' wird in der unteren Bildschirmhälfte eine Übersicht +angeboten, in der geblättert werden kann. Durch 'Direkt' kann ein bestimmter +Satz nach Signatur angesteuert werden. + +Die Funktion 'Referenzen' dient dazu, die in der editierten Datei +vorkommenden Literaturreferenzen in der Literaturdatei zu markieren. Dazu +müssen die Referenzen als Macro \#lit ("Signatur")\# in der Datei angegeben +werden. Als Option beim Sammeln der Referenzen können diese durch ein +anderes Macro und den Inhalt eines beliebigen Feldes der EUDAS-Datei ersetzt +werden. Diese beiden Angaben werden erfragt. Referenzen, die in der +Literaturdatei nicht vorkommen, werden als Dummy-Einträge an das Ende der +Literaturdatei geschrieben, so daß sie später in EUDAS ausgefüllt werden +können. + +Mit der Funktion 'Verzeichnis' können dann die markierten Sätze +(zwischendurch keine neue Datei öffnen!) als Literaturverzeichnis an das +Ende der Datei gebracht werden. Dazu muß ein vorher erstelltes Druckmuster +angegeben werden, das die Form der Literatureinträge angibt. + + diff --git a/app/flint/0.4/source-disk b/app/flint/0.4/source-disk new file mode 100644 index 0000000..3c86110 --- /dev/null +++ b/app/flint/0.4/source-disk @@ -0,0 +1 @@ +eudas/flint-0.4.img diff --git a/app/flint/0.4/src/MENUE.gen b/app/flint/0.4/src/MENUE.gen new file mode 100644 index 0000000..327438c --- /dev/null +++ b/app/flint/0.4/src/MENUE.gen @@ -0,0 +1,93 @@ +page; +putline ("Generierung MENUE 0.5"); +BOOL CONST box := yes ("Mit IBM Grafikzeichen"); +BOOL CONST l3 := maxint DIV 2 > 17000; +TASK VAR dummy, ar; +IF l3 THEN ar := /"EUMEL" ELSE ar := archive END IF; +INT VAR kanal := channel; +fetch ("eudas.satzzugriffe", ar); +fetch ("eudas.fenster", ar); +fetch ("eudas.menues", ar); +fetch ("offline.1", ar); +fetch ("eudas.1", ar); +fetch ("eudas.2", ar); +fetch ("eudas.3", ar); +fetch ("eudas.dialoghilfen", ar); +fetch ("flint.init", ar); +IF yes ("Ggf zweites Archiv eingelegt") THEN END IF; +fetch ("eudas.steuerung", ar); +fetch ("eudas.init", ar); +fetch ("klartextbelegung", ar); +fetch ("editormenue", ar); +fetch ("eudas.manager", ar); +fetch ("flint.manager", ar); +fetch ("flint", ar); +IF l3 THEN fetch ("isub.replace", ar) END IF; +IF box THEN fetch ("boxzeichen", ar) END IF; +release (ar); +check off; +IF l3 THEN do (PROC (TEXT CONST) reorganize, all) END IF; +IF l3 THEN insert ("isub.replace"); forget ("isub.replace", quiet) END IF; +insert ("eudas.satzzugriffe"); forget ("eudas.satzzugriffe", quiet); +insert ("eudas.fenster"); forget ("eudas.fenster", quiet); +insert ("eudas.menues"); forget ("eudas.menues", quiet); +IF l3 THEN + TEXT VAR zeile; FILE VAR f; + f := sequential file (modify, "offline.1"); + to line (f, 1); + read record (f, zeile); + INT CONST pp := pos (zeile, ",PROCA"); + change (zeile, pp, pp + 7, ""); + write record (f, zeile) +END IF; +insert ("offline.1"); forget ("offline.1", quiet); +IF box THEN run ("boxzeichen"); forget ("boxzeichen", quiet) END IF; +do ("ausfuehrtaste (""""13"""")"); +begin ("FLINT", PROC flint init, dummy); +do ("global manager"); + +PROC flint init : + + disable stop; + fetch ("eudas.init"); + fetch ("flint.init"); + continue (kanal); + command dialogue (FALSE); + page; + i ("eudas.1"); + i ("eudas.2"); + i ("eudas.3"); + i ("eudas.dialoghilfen"); + i ("eudas.steuerung"); + i ("klartextbelegung"); + i ("editormenue"); + i ("eudas.manager"); + i ("flint.manager"); + i ("flint"); + do ("menue loeschen (FALSE)"); + do ("menuedaten einlesen (""eudas.init"")"); + forget ("eudas.init", quiet); + erase ("eudas.init"); + do ("menuedaten einlesen (""flint.init"")"); + forget ("flint.init", quiet); + erase ("flint.init"); + erase ("MENUE.gen"); + command dialogue (TRUE); + check on; + do ("begin (""OP"", ""OPMENUE"")"); + do ("global manager") + +END PROC flint init; + +PROC i (TEXT CONST name) : + + fetch (name); + insert (name); + IF is error THEN + put error; clear error; pause (1000); do ("global manager") + END IF; + forget (name); + erase (name) + +END PROC i; + diff --git a/app/flint/0.4/src/OPMENUE.gen b/app/flint/0.4/src/OPMENUE.gen new file mode 100644 index 0000000..28304a6 --- /dev/null +++ b/app/flint/0.4/src/OPMENUE.gen @@ -0,0 +1,42 @@ +page; +putline ("Generierung OPMENUE 0.5"); +BOOL CONST box := yes ("Mit IBM-Grafikzeichen"); +BOOL CONST l3 := maxint DIV 2 > 17000; +TASK VAR ar; +IF l3 THEN ar := /"EUMEL" ELSE ar := archive END IF; +IF l3 THEN fetch ("isub.replace", ar) END IF; +fetch ("eudas.satzzugriffe", ar); +fetch ("eudas.fenster", ar); +fetch ("eudas.menues", ar); +fetch ("offline.1", ar); +IF l3 THEN fetch ("dummy.configurate", ar) END IF; +fetch ("operator.1", ar); +fetch ("operator.init", ar); +IF box THEN fetch ("boxzeichen", ar) END IF; +release (ar); +IF l3 THEN do (PROC (TEXT CONST) reorganize, all) END IF; +IF l3 THEN insert ("isub.replace"); forget ("isub.replace", quiet) END IF; +insert ("eudas.satzzugriffe"); forget ("eudas.satzzugriffe", quiet); +insert ("eudas.fenster"); forget ("eudas.fenster", quiet); +insert ("eudas.menues"); forget ("eudas.menues", quiet); +do ("ausfuehrtaste (""""13"""")"); +IF l3 THEN + TEXT VAR zeile; FILE VAR f; + f := sequential file (modify, "offline.1"); + to line (f, 1); + read record (f, zeile); + INT CONST pp := pos (zeile, ",PROCA"); + change (zeile, pp, pp + 7, ""); + write record (f, zeile) +END IF; +insert ("offline.1"); forget ("offline.1", quiet); +IF l3 THEN + insert ("dummy.configurate"); forget ("dummy.configurate", quiet) +END IF; +insert ("operator.1"); forget ("operator.1", quiet); +do ("menuedaten einlesen (""operator.init"")"); +forget ("operator.init", quiet); +IF box THEN run ("boxzeichen"); forget ("boxzeichen", quiet) END IF; +forget ("OPMENUE.gen", quiet); +do ("global manager"); + diff --git a/app/flint/0.4/src/boxzeichen b/app/flint/0.4/src/boxzeichen new file mode 100644 index 0000000..12c3bb8 --- /dev/null +++ b/app/flint/0.4/src/boxzeichen @@ -0,0 +1,3 @@ +box zeichen (""205""186""201""187""200""188""199""182""196"", + ""15""14"", ""178" ") + diff --git a/app/flint/0.4/src/dummy.configurate b/app/flint/0.4/src/dummy.configurate new file mode 100644 index 0000000..2834684 --- /dev/null +++ b/app/flint/0.4/src/dummy.configurate @@ -0,0 +1,6 @@ +PACKET dummy configurate DEFINES configurate : +PROC configurate : + errorstop ("Für L3 nicht implementiert") +END PROC configurate; +END PACKET dummy configurate; + diff --git a/app/flint/0.4/src/editormenue b/app/flint/0.4/src/editormenue new file mode 100644 index 0000000..5ab94f1 --- /dev/null +++ b/app/flint/0.4/src/editormenue @@ -0,0 +1,1008 @@ +PACKET edit menue (* Autor: Thomas Berlage *) + (* Stand: 16.10.88 *) + DEFINES + + edit, + edit status anzeigen, + zeilenmenue anbieten, + editfile setzen, + edit menue, + element markieren, + text menue, + ausschnitt drucken, + gewaehlte schriftarten einstellen : + + +(************************* Zeilenmenue *************************************) + +LET + menue status = +"MENUE: Wählen: <-,-> Ausführen: LEER,RET Abbruch: ESC h Hilfe: ESC ?"; + + +PROC zeilenmenue anbieten (TEXT CONST menuename, + PROC (INT CONST) kommandos) : + + bild vorbereiten; + zeilenmenue anbieten (menuename, TRUE, PROC (INT CONST) kommandos); + bild nachbereiten . + +bild vorbereiten : + INT VAR x, y; + get cursor (x, y); + cursor (1, y size); out (""5""); + status anzeigen (menue status); + cursor (x, y); + IF aktueller editor > 0 THEN + get editcursor (x, y); + y := line no (editfile) + y size - y; + abschnitt neu (y - 1, y) + END IF . + +bild nachbereiten : + IF aktueller editor > 0 THEN + IF mark (editfile) THEN + bild neu + ELSE + abschnitt neu (y - 1, y) + END IF + END IF; + cursor (1, y size - 1); out (""4"") . + +END PROC zeilenmenue anbieten; + +PROC eget (TEXT CONST prompt, TEXT VAR inhalt) : + + editget (prompt, inhalt, "", "GET/Allgemein") + +END PROC eget; + +BOOL PROC eja (TEXT CONST frage) : + + ja (frage, "JA/Allgemein", TRUE) + +END PROC eja; + + +(* EDIT MENUE *) + +TEXT VAR + param, + fensterdatei := ""; + +FENSTER VAR zweitfenster; +fenster initialisieren (zweitfenster); + +PROC edit menue : + + zeilenmenue anbieten ("EDIT MENUE:", + PROC (INT CONST) edit menue kommandos) + +END PROC edit menue; + +PROC edit menue kommandos (INT CONST wahl) : + + SELECT wahl OF + CASE 1 : springen auf zeile + CASE 2 : suchen nach text + CASE 3 : suchen und ersetzen + CASE 4, 5 : markieren + CASE 6 : kopieren oder lesen + CASE 7 : fenster editieren + CASE 8 : limit einstellen + CASE 9 : tastenbelegung + END SELECT . + +springen auf zeile : + TEXT VAR z := ""; + eget ("Zeilennummer:", z); + IF z <> "" THEN + INT CONST auf zeile := int (z); + IF last conversion ok THEN + edit file setzen; T auf zeile + ELSE + errorstop ("Zeilennummer ist keine Zahl") + END IF + END IF . + +suchen nach text : + param := ""; + eget ("Text:", param); + IF param = "" THEN + ELIF eja ("Vorwärts") THEN + ek ("D" + textdarstellung (param)) + ELSE + ek ("U" + textdarstellung (param)) + END IF . + +suchen und ersetzen : + param := ""; + eget ("Suchtext:", param); + IF param <> "" THEN + z := ""; eget ("Ersetzen durch:", z); + IF z <> "" THEN + IF eja ("Nur einmal") THEN + ek (textdarstellung (param) + "C" + textdarstellung (z)) + ELSE + editfile setzen; + param CA z + END IF + END IF + END IF . + +markieren : + element markieren (wahl = 5) . + +kopieren oder lesen : + param := ""; + editfile setzen; + IF mark THEN + eget ("Zieldatei (RET = Speicher):", param); + PUT param + ELSE + eget ("Quelldatei (RET = Speicher):", param); + GET param + END IF . + +fenster editieren : + INT VAR xa, ya, xl, yl; + get window (xa, ya, xl, yl); + IF groesster editor >= 2 THEN + errorstop ("Nur zwei Fenster") + ELSE + fenstergroesse setzen (zweitfenster, + xa, ya + yl DIV 2, xl, yl - yl DIV 2); + eget ("Name der Datei:", fensterdatei); + IF NOT exists (fensterdatei) CAND + NOT eja ("""" + fensterdatei + """ neu einrichten") THEN + errorstop ("") + END IF; + FILE VAR eff := sequential file (modify, fensterdatei); + edit (eff, zweitfenster, "EDIT/Allgemein") + END IF . + +limit einstellen : + z := text (limit); + REP + eget ("Zeilenbreite bis Umbruch (limit) in Zeichen:", z); + INT CONST l := int (z); + UNTIL last conversion ok OR z = "" PER; + IF z <> "" THEN limit (l) END IF . + +tastenbelegung : + TEXT VAR taste; + status anzeigen (""); + cursor (1, 24); + put ("Gewünschte Taste drücken (ESC = Abbruch):"5""); + getchar (taste); + IF taste <> ""27"" THEN + put (""13"Sequenz ggf editieren, dann ESC q"5""); + lernsequenz editieren (taste) + END IF . + +END PROC edit menue kommandos; + +PROC ek (TEXT CONST kom) : + + kommando auf taste legen ("f", kom); + std kommando interpreter ("f") + +END PROC ek; + +PROC editfile setzen : + + kommando auf taste legen (""27"", ""); + std kommando interpreter (""27"") + +END PROC editfile setzen; + +DATASPACE VAR ds; + +PROC lernsequenz editieren (TEXT CONST taste) : + + disable stop; + ds := nilspace; + editieren (taste); + forget (ds) + +END PROC lernsequenz editieren; + +PROC element markieren (BOOL CONST bis satzende) : + + FILE VAR edfile := editfile; + INT VAR spalte := col (edfile); + IF NOT mark (edfile) THEN + zeile lesen; + cursor zuruecksetzen; + mark (edfile, line no (edfile), spalte) + ELSE + zeile lesen + END IF; + IF bis satzende THEN + position auf satzende + ELSE + position auf wortende + END IF . + +zeile lesen : + read record (edfile, param) . + +cursor zuruecksetzen : + WHILE spalte > 1 CAND (param SUB spalte - 1) <> " " REP + spalte DECR 1 + END REP . + +position auf satzende : + WHILE pos (param, ".", spalte) = 0 CAND kein absatz REP + down (edfile); + zeile lesen; + spalte := 1 + END REP; + spalte := pos (param, ".", spalte); + IF spalte = 0 THEN spalte := length (param) ELSE spalte INCR 1 END IF; + col (edfile, spalte) . + +kein absatz : + (spalte = LENGTH param OR (param SUB LENGTH param) <> " ") + AND NOT eof (edfile) . + +position auf wortende : + spalte DECR 1; + REP + spalte INCR 1; + spalte := pos (param, ""33"", ""255"", spalte); + IF spalte = 0 THEN + IF eof (edfile) THEN + spalte := length (param) + ELSE + down (edfile); + zeile lesen + END IF + END IF + UNTIL spalte > 0 END REP; + spalte := pos (param, " ", spalte); + IF spalte = 0 THEN spalte := length (param) END IF; + col (edfile, spalte) . + +END PROC element markieren; + +TEXT VAR sequenz, aenderung; + +PROC editieren (TEXT CONST taste) : + + enable stop; + FILE VAR f := sequential file (output, ds); + maxlinelength (f, 37); + sequenz := lernsequenz auf taste (taste); + klartext in file (f, sequenz); + alles neu; + abgrenzung zeichnen; + editstatus anzeigen; + edit (f, 42, 2, x size - 42, y size - 3); + klartext aus file (f, aenderung); + IF aenderung <> sequenz CAND wirklich aendern THEN + lernsequenz auf taste legen (taste, aenderung) + END IF . + +abgrenzung zeichnen : + cursor (40, 1); + y size - 3 TIMESOUT ""10""15""14""8""8"" . + +wirklich aendern : + eja ("Lernsequenz aendern") . + +END PROC editieren; + + +(* TEXT MENUE *) + +PROC text menue : + + zeilenmenue anbieten ("TEXT MENUE:", + PROC (INT CONST) text menue kommandos) + +END PROC text menue; + +FENSTER VAR fontfenster, modfenster; +fenster initialisieren (fontfenster); +fenster initialisieren (modfenster); +fenstergroesse setzen (fontfenster, 40, 2, 40, 21); +fenstergroesse setzen (modfenster, 55, 13, 25, 10); + +TEXT VAR + ezeile, + format macro := ""; + + +PROC text menue kommandos (INT CONST mwahl) : + + SELECT mwahl OF + CASE 1 : schrifttyp einstellen + CASE 2 : schriftart einstellen + CASE 3 : neue seite beginnen + CASE 4 : zwischenraum freilassen + CASE 5 : globaleinstellung + CASE 6 : zeilenweise formatieren + CASE 7 : ausschnitt drucken + END SELECT . + +schrifttyp einstellen : + TEXT VAR typname; + schrifttyp auswaehlen (typname); + IF typname <> "" THEN + textanweisung einfuegen ("type", schriftname, FALSE) + END IF . + +schriftname : + textdarstellung (typname) . + +schriftart einstellen : + schriftart auswaehlen; + gewaehlte schriftarten einstellen (gewaehlte modifikationen) . + +schriftart auswaehlen : + alles neu; + auswahl anbieten ("TEXT.Modwahl", modfenster, -10, "AUSWAHL/Allgemein", + PROC (TEXT VAR, INT CONST) modname) . + +neue seite beginnen : + param := ""; + eget ("Nummer der nächsten Seite (RET = +1):", param); + IF param = "" THEN + textanweisung einfuegen ("page", "", TRUE) + ELSE + INT CONST seitennr := int (param); + IF last conversion ok THEN + textanweisung einfuegen ("page", text (seitennr), TRUE) + ELSE + errorstop ("Seitennummer keine Zahl") + END IF + END IF . + +zwischenraum freilassen : + param := ""; + eget ("Zwischenraum in cm:", param); + IF param <> "" THEN + change all (param, ",", "."); + REAL CONST wert := real (param); + IF last conversion ok THEN + textanweisung einfuegen ("free", text (wert), TRUE) + ELSE + errorstop ("kein Zahlenwert") + END IF + END IF . + +zeilenweise formatieren : + editfile setzen; + lineform; ueberschrift neu . + +globaleinstellung : + einstellung erfragen; + einstellung eintragen . + +END PROC text menue kommandos; + +LET zwischendatei = "&&Druckabschnitt"; + +PROC ausschnitt drucken : + + LET ende der seite = "Ende der Seite "; + FILE VAR ef := editfile; + INT VAR pageform anfang; + auf pageform datei testen; + IF pageform anfang > 0 THEN + editfile setzen; + IF mark (ef) THEN + markierten pageform abschnitt drucken + ELSE + nach seiten fragen und drucken + END IF; + print (zwischendatei); + forget (zwischendatei, quiet) + ELIF mark (ef) THEN + abschnitt formatieren und drucken + ELSE + errorstop ("kein Abschnitt markiert") + END IF; + alte position einnehmen . + +auf pageform datei testen : + INT VAR + zeile := line no (ef), + spalte := col (ef); + to line (ef, 1); col (ef, 1); + pageform anfang := 0; + WHILE NOT eof (ef) CAND kommando in zeile REP + IF pos (ef, ende der seite, 8) > 0 THEN + pageform anfang := line no (ef); + END IF; + down (ef) + UNTIL pageform anfang > 0 END REP; + to line (ef, zeile); col (ef, spalte) . + +kommando in zeile : + pos (ef, "#", 1) = 1 . + +markierten pageform abschnitt drucken : + markierten abschnitt kopieren; + pageform anfang kopieren (ef, pageform anfang) . + +nach seiten fragen und drucken : + anfang erfragen; + ende erfragen; + markierten abschnitt kopieren; + pageform anfang kopieren (ef, pageform anfang); + mark (ef, 0, 0) . + +anfang erfragen : + TEXT VAR seitennr := ""; + eget ("Erste Seite:", seitennr); + IF seitennr = "" THEN + mark (ef, pageform anfang + 1, 1) + ELSE + to line (ef, 1); + down (ef, ende der seite + text (int (seitennr) - 1)); + IF eof (ef) THEN + mark (ef, pageform anfang + 1, 1) + ELSE + down (ef); + mark (ef, line no (ef), 1) + END IF + END IF . + +ende erfragen : + eget ("Letzte Seite:", seitennr); + IF seitennr <> "" THEN + to line (ef, mark line no (ef)); + down (ef, ende der seite + seitennr); + IF NOT eof (ef) THEN down (ef) END IF + ELSE + to eof (ef) + END IF; + col (ef, 1) . + +abschnitt formatieren und drucken : + macro einfuegen; + editfile setzen; + ueberschrift neu; + IF eja ("Zeilenweise formatieren") THEN + lineform; page; ueberschrift zeigen; bild zeigen; + markierte schlusszeile + END IF; + markierten abschnitt kopieren; + IF eja ("Seitenweise formatieren") THEN + pageform (zwischendatei); + alles neu; + print (zwischendatei + ".p"); + forget (zwischendatei + ".p", quiet) + ELSE + print (zwischendatei) + END IF; + forget (zwischendatei, quiet); + macro entfernen . + +markierte schlusszeile : + cursor (1, y size - 1); + out (""15""); x size - 5 TIMESOUT " "; out (""14""4"") . + +macro einfuegen : + eget ("Format-Makro:", format macro); + IF format macro <> "" THEN + to line (ef, mark line no (ef)); + read record (ef, ezeile); + change (ezeile, mark col (ef), mark col (ef) - 1, + "#" + format macro + "#"); + write record (ef, ezeile); + to line (ef, zeile); col (ef, spalte) + END IF . + +macro entfernen : + IF format macro <> "" THEN + zeile := line no (ef); spalte := col (ef); + to line (ef, mark line no (ef)); + read record (ef, ezeile); + change (ezeile, mark col (ef), mark col (ef) + length (format macro) + 1, + ""); + write record (ef, ezeile) + END IF; + alte position einnehmen . + +alte position einnehmen : + to line (ef, zeile); col (ef, spalte) . + +END PROC ausschnitt drucken; + +PROC markierten abschnitt kopieren : + + IF exists (zwischendatei) THEN + IF eja ("""" + zwischendatei + """ löschen") THEN + forget (zwischendatei, quiet) + ELSE + errorstop ("") + END IF + END IF; + bitte warten; + PUT zwischendatei + +END PROC markierten abschnitt kopieren; + +PROC pageform anfang kopieren (FILE VAR ef, INT CONST zeilen) : + + FILE VAR zwischen := sequential file (modify, zwischendatei); + INT VAR i; + to line (zwischen, 1); + to line (ef, 1); + FOR i FROM 1 UPTO zeilen REP + read record (ef, ezeile); + insert record (zwischen); + write record (zwischen, ezeile); + down (ef); down (zwischen) + END REP + +END PROC pageform anfang kopieren; + +PROC schrifttyp auswaehlen (TEXT VAR typname) : + + alles neu; + auswahl anbieten ("TEXT.Fontwahl", fontfenster, 1, "AUSWAHL/Allgemein", + PROC (TEXT VAR, INT CONST) aus fonttab); + IF wahl (1) <> 0 THEN + typname := font (wahl (1)) + ELSE + typname := "" + END IF + +END PROC schrifttyp auswaehlen; + +PROC aus fonttab (TEXT VAR name, INT CONST stelle) : + + IF stelle > 49 THEN + name := "" + ELSE + name := font (stelle) + END IF + +END PROC aus fonttab; + +PROC gewaehlte schriftarten einstellen (TEXT CONST mod) : + + INT VAR + zeile := line no (editfile), + spalte := col (editfile); + FILE VAR edfile := editfile; + read record (edfile, ezeile); + IF mark (edfile) THEN + modifikationen nachher behandeln; + modifikationen vorher behandeln + ELSE + gewaehlte modifikationen einstellen + END IF . + +modifikationen nachher behandeln : + BOOL VAR geloescht; + ueber blanks zuruecksetzen; + ueber zeilenanfang zuruecksetzen; + modifikationen am ende beseitigen; + modifikationen am ende einfuegen . + +ueber blanks zuruecksetzen : + WHILE spalte > 1 CAND (ezeile SUB (spalte - 1)) = " " REP + spalte DECR 1 + END REP . + +ueber zeilenanfang zuruecksetzen : + INT VAR stelle; + IF spalte = 1 CAND zeile > 1 THEN + up (edfile); + read record (edfile, ezeile); + stelle := length (ezeile); + IF (ezeile SUB stelle) = " " THEN stelle DECR 1 END IF + ELSE + stelle := max (spalte - 1, 1) + END IF . + +modifikationen am ende beseitigen : + WHILE (ezeile SUB stelle) = "#" REP + ggf anweisung entfernen + END REP . + +ggf anweisung entfernen : + INT VAR anw anf := stelle - 1; + WHILE anw anf > 1 CAND (ezeile SUB anw anf) <> "#" REP + anw anf DECR 1 + END REP; + anweisung entfernen ("off", anw anf, stelle, geloescht); + IF geloescht THEN + spalte DECR (stelle - anw anf + 1) + END IF; + stelle := anw anf - 1 . + +modifikationen am ende einfuegen : + IF pos (mod, "a") = 0 THEN + neue modifikationen nachher + END IF; + write record (edfile, ezeile) . + +neue modifikationen nachher : + FOR i FROM length (mod) DOWNTO 1 REP + change (ezeile, spalte, spalte - 1, mod param off); + spalte INCR mod param laenge + END REP . + +modifikationen vorher behandeln : + to line (edfile, mark line no (edfile)); + col (edfile, mark col (edfile)); + read record (edfile, ezeile); + stelle := col (edfile); + WHILE (ezeile SUB stelle) = "#" REP + ggf anfangsanweisung entfernen + END REP; + neue modifikationen am anfang einfuegen; + write record (edfile, ezeile); + to line (edfile, zeile); + col (edfile, spalte); + abschnitt neu (mark line no (edfile), zeile); + mark (edfile, 0, 0) . + +ggf anfangsanweisung entfernen : + INT VAR anw ende := pos (ezeile, "#", stelle + 1); + anweisung entfernen ("on", stelle, anw ende, geloescht); + IF geloescht THEN + IF line no (edfile) = zeile THEN + spalte DECR (anw ende - stelle + 1) + END IF + ELSE + stelle := anw ende + 1 + END IF . + +neue modifikationen am anfang einfuegen : + IF pos (mod, "a") = 0 THEN + neue modifikationen vorher + END IF . + +neue modifikationen vorher : + FOR i FROM length (mod) DOWNTO 1 REP + change (ezeile, stelle, stelle - 1, mod param on); + IF line no (edfile) = zeile THEN + spalte INCR mod param laenge + END IF + END REP . + +gewaehlte modifikationen einstellen : + INT VAR i; + BOOL VAR mod aus; + mod aus := pos (mod, "a") > 0; + FOR i FROM length (mod) DOWNTO 1 REP + IF (mod SUB i) = "a" THEN + ELIF mod aus THEN + change (ezeile, spalte, spalte - 1, mod param off) + ELSE + change (ezeile, spalte, spalte - 1, mod param on) + END IF + END REP; + write record (edfile, ezeile); + abschnitt neu (zeile, zeile) . + +mod param on : + TEXT VAR + mod zeichen := mod SUB i, + mod text; + IF mod zeichen = "h" THEN + mod text := "#u#" + ELIF mod zeichen = "t" THEN + mod text := "#d#" + ELSE + mod text := "#on(""" + mod zeichen + """)#" + END IF; + mod text . + +mod param off : + mod zeichen := mod SUB i; + IF mod zeichen = "h" OR mod zeichen = "t" THEN + mod text := "#e#" + ELSE + mod text := "#off(""" + mod zeichen + """)#" + END IF; + mod text . + +mod param laenge : + length (mod text) . + +END PROC gewaehlte schriftarten einstellen; + +PROC modname (TEXT VAR name, INT CONST stelle) : + + SELECT stelle OF + CASE 1 : name := "Fett" + CASE 2 : name := "Kursiv" + CASE 3 : name := "Unterstrichen" + CASE 4 : name := "Hoch" + CASE 5 : name := "Tief" + CASE 6 : name := "Aus" + OTHERWISE name := "" + END SELECT + +END PROC modname; + +TEXT PROC gewaehlte modifikationen : + + TEXT VAR ergebnis := ""; + INT VAR stelle := 1; + WHILE wahl (stelle) > 0 REP + wahl merken; + stelle INCR 1 + END REP; + ergebnis . + +wahl merken : + SELECT wahl (stelle) OF + CASE 1 : ergebnis CAT "b" + CASE 2 : ergebnis CAT "i" + CASE 3 : ergebnis CAT "u" + CASE 4 : ergebnis CAT "h" + CASE 5 : ergebnis CAT "t" + CASE 6 : ergebnis CAT "a" + END SELECT . + +END PROC gewaehlte modifikationen; + +PROC anweisung entfernen (TEXT CONST anw name, INT CONST beginn, ende, + BOOL VAR geloescht) : + + geloescht := FALSE; + IF beginn > 0 AND ende > 0 + CAND (ezeile SUB beginn) = "#" CAND (ezeile SUB ende) = "#" THEN + INT CONST vorkommen := pos (ezeile, anw name, beginn, ende); + IF vorkommen > 0 AND vorkommen < beginn + 4 + OR up down anweisung THEN + change (ezeile, beginn, ende, ""); + geloescht := TRUE + END IF + END IF . + +up down anweisung : + IF ende = beginn + 2 THEN + TEXT CONST alte anweisung := ezeile SUB beginn + 1; + IF anw name = "on" THEN + alte anweisung = "u" OR alte anweisung = "d" + ELSE + alte anweisung = "e" + END IF + ELSE + FALSE + END IF . + +END PROC anweisung entfernen; + +PROC textanweisung einfuegen (TEXT CONST anweisung, param, + BOOL CONST ab anfang) : + + FILE VAR edfile := editfile; + IF ab anfang THEN col (edfile, 1) END IF; + INT CONST ce := col (edfile); + read record (edfile, ezeile); + IF (ezeile SUB ce) = "#" CAND gleiche anweisung THEN + anweisung ersetzen + ELIF ce = 1 THEN + neue zeile einfuegen + ELSE + an stelle einfuegen + END IF . + +gleiche anweisung : + INT CONST apos := pos (ezeile, anweisung, ce); + apos > 0 AND pos (ezeile, "#", ce + 1) > a pos AND + (param = "" OR pos (ezeile, "(", ce) > a pos) . + +anweisung ersetzen : + IF param <> "" THEN + INT CONST anf := pos (ezeile, "(", ce), + end := pos (ezeile, ")", anf); + IF anf > 0 AND end > 0 AND anf < end THEN + change (ezeile, anf + 1, end - 1, param); + write record (edfile, ezeile); + abschnitt neu (line no (edfile), line no(edfile)) + END IF + END IF . + +neue zeile einfuegen : + insert record (edfile); + IF param <> "" THEN + write record (edfile, "#" + anweisung + "(" + param + ")# ") + ELSE + write record (edfile, "#" + anweisung + "# ") + END IF; + abschnitt neu (line no (edfile), 9999) . + +an stelle einfuegen : + IF param <> "" THEN + change (ezeile, ce, ce - 1, "#" + anweisung + "(" + param + ")#") + ELSE + change (ezeile, ce, ce - 1, "#" + anweisung + "#") + END IF; + write record (edfile, ezeile); + abschnitt neu (line no (edfile), line no (edfile)) . + +END PROC textanweisung einfuegen; + +LET + global anfang = + "#- Globale Einstellungen, nicht verschieben -# ", + global ende = + "#- Ende der globalen Einstellungen ----------# "; + +TEXT VAR + e type := "", + e limit := "16.0", + e x start := "2.5", + e y start := "2.25", + e pagelength := "25.0", + e linefeed := "1.0"; + +PROC einstellung erfragen : + + REP + schrifttyp auswaehlen (e type); + IF e type = "" CAND + eja ("Typ muß gewaehlt werden, Funktion abbrechen") THEN + errorstop ("") + END IF + UNTIL e type <> "" END REP; + eget ("Breite des Schreibfelds in cm:", e limit); + eget ("Länge des Schreibfelds in cm:", e pagelength); + eget ("Oberer Rand in cm:", e y start); + eget ("Linker Rand in cm:", e x start); + eget ("Zeilenabstand als relativer Faktor:", e linefeed) + +END PROC einstellung erfragen; + +PROC einstellung eintragen : + + FILE VAR edfile := editfile; + INT VAR + zeile := line no (edfile), + spalte := col (edfile); + col (edfile, 1); + to line (edfile, 1); + read record (edfile, ezeile); + IF pos (ezeile, "type") > 0 THEN + down (edfile); + read record (edfile, ezeile); + alte einstellung suchen + END IF; + ab hier einfuegen; + an alte stelle . + +alte einstellung suchen : + IF ezeile = global anfang THEN + down (edfile, global ende); + IF eof (edfile) THEN + to line (edfile, 2) + ELSE + down (edfile) + END IF + END IF . + +ab hier einfuegen : + IF line no (edfile) > 1 CAND eja ("Alte Einstellung loeschen") THEN + INT CONST zu loeschen := line no (edfile) - 1; + to line (edfile, 1); + INT VAR i; + FOR i FROM 1 UPTO zu loeschen REP + delete record (edfile) + END REP; + zeile DECR zu loeschen + END IF; + typ und limit einfuegen; + global anfang einfuegen; + seitenlaenge einfuegen; + start einfuegen; + linefeed einfuegen; + global ende einfuegen . + +typ und limit einfuegen : + insert record (edfile); + write record (edfile, + "#type (""" + etype + """)##limit (" + e limit + ")# "); + down (edfile) . + +global anfang einfuegen : + insert record (edfile); + write record (edfile, global anfang); + down (edfile) . + +seitenlaenge einfuegen : + insert record (edfile); + write record (edfile, "#pagelength (" + e pagelength + ")# "); + down (edfile) . + +start einfuegen : + insert record (edfile); + write record (edfile, + "#start (" + e x start + ", " + e y start + ")# "); + down (edfile) . + +linefeed einfuegen : + insert record (edfile); + write record (edfile, "#linefeed (" + e linefeed + ")# "); + down (edfile) . + +global ende einfuegen : + insert record (edfile); + write record (edfile, global ende); + zeile INCR 6 . + +an alte stelle : + to line (edfile, zeile); + col (edfile, spalte) . + +END PROC einstellung eintragen; + + +(* Editor im EUDAS-Fenster *) + +INT VAR return code; + +LET + edit status = #1003# +"EDIT: Menü: ESC m, ESC t Abbruch: ESC h Verlassen: ESC q Hilfe: ESC ?"; + +BOOL VAR status frei; + + +PROC edit status anzeigen : + status anzeigen (edit status) +END PROC edit status anzeigen; + +PROC edit (FILE VAR f, FENSTER CONST fenster, TEXT CONST hilfe) : + + INT VAR x, y, x l, y l; + fenstergroesse (fenster, x, y, x l, y l); + fenster veraendert (fenster); + enable stop; + fenster datei := ""; + IF groesster editor = 0 THEN status frei := y > 1 END IF; + REP + IF status frei THEN status anzeigen (edit status) END IF; + open editor (groesster editor + 1, f, TRUE, x, y, x l, y l); + edit (groesster editor, "eqvw19dpgn"9"?hFmt", PROC (TEXT CONST) kdo); + return code behandeln + END REP . + +return code behandeln : + SELECT return code OF + CASE 0 : LEAVE edit + CASE 1 : hilfe anbieten (hilfe, fenster) + CASE 2 : errorstop ("") + END SELECT . + +END PROC edit; + +PROC kdo (TEXT CONST zeichen) : + + return code := pos ("q?h", zeichen); + IF return code > 0 THEN + return code DECR 1; + quit + ELIF zeichen = "m" THEN + edit menue; + IF status frei THEN status anzeigen (edit status) END IF; + ELIF zeichen = "t" THEN + text menue; + IF status frei THEN status anzeigen (edit status) END IF; + ELSE + std kommando interpreter (zeichen); + IF status frei THEN status anzeigen (edit status) END IF; + END IF + +END PROC kdo; + + +END PACKET edit menue; +(* +FENSTER VAR fe; fenster initialisieren (fe); +fenstergroesse setzen (fe, 1, 2, 79, 23); +FILE VAR f := sequential file (modify, "testdatei"); +edit (f, fe, "EDIT/Allgemein") +*) + diff --git a/app/flint/0.4/src/eudas.manager b/app/flint/0.4/src/eudas.manager new file mode 100644 index 0000000..802a507 --- /dev/null +++ b/app/flint/0.4/src/eudas.manager @@ -0,0 +1,216 @@ +PACKET eudas manager (* Autor: Thomas Berlage *) + (* Stand: 20.01.88 *) + DEFINES + + eudas manager, + setze partner, + abhaengige task, + end partner : + + +LET + code dateien = 190, + code felder = 191, + code positioniere = 192, + code satz = 193, + end myself code = 197, + set controlled code = 198, + ask partner code = 200; + +LET + ack = 0; + +LET + COM = STRUCT (INT int info, + BOOL bool info, + TEXT text info, + SATZ satz info); + +BOUND COM VAR p; + +ROW 4 TEXT VAR partner vater; + partner vater (1) := ""; + partner vater (2) := ""; + partner vater (3) := ""; + partner vater (4) := ""; + +TEXT VAR puffer; + +LET + kein partner = + "Kein Partner"; + + +PROC setze partner (INT CONST nr, TEXT CONST name des vaters) : + + partner vater (nr) := name des vaters + +END PROC setze partner; + +PROC eudas manager (DATASPACE VAR ds, INT CONST order, phase, + TASK CONST order task) : + + enable stop; + SELECT order OF + CASE code dateien : code dateien ausfuehren + CASE code felder : code felder ausfuehren + CASE code positioniere : code positioniere ausfuehren + CASE code satz : code satz ausfuehren + OTHERWISE andere codes + END SELECT . + +andere codes : + IF order > ask partner code AND order < ask partner code + 4 THEN + ask partner code ausfuehren + ELSE + menue manager (ds, order, phase, order task) + END IF . + +code dateien ausfuehren : + p := ds; + p. int info := dateiversion; + dateinamen anlegen; + send (order task, ack, ds) . + +dateinamen anlegen : + satz initialisieren (p. satz info); + FOR i FROM 1 UPTO anzahl dateien REP + feld aendern (p. satz info, i, eudas dateiname (i)) + END REP . + +code felder ausfuehren : + p := ds; + feldinfo anlegen; + feldnamen anlegen; + send (order task, ack, ds) . + +feldinfo anlegen : + INT VAR i; + TEXT VAR rep := " "; + p. text info := ""; + FOR i FROM 1 UPTO anzahl felder REP + replace (rep, 1, feldinfo (i)); + p. text info CAT rep + END REP . + +feldnamen anlegen : + satz initialisieren (p. satz info, anzahl felder); + FOR i FROM 1 UPTO anzahl felder REP + feldnamen lesen (i, puffer); + feld aendern (p. satz info, i, puffer) + END REP . + +code positioniere ausfuehren : + p := ds; + positionieren; + ergebnis ablegen; + send (order task, ack, ds) . + +positionieren : + IF p. bool info THEN + relativ positionieren + ELSE + auf satz (p. int info) + END IF . + +relativ positionieren : + IF p. int info > 0 THEN + weiter (p. int info) + ELIF p. int info < 0 THEN + zurueck (- p. int info) + END IF . + +ergebnis ablegen : + p. int info := satznummer; + p. bool info := dateiende . + +code satz ausfuehren : + p := ds; + p. int info := satzkombination; + p. bool info := satz ausgewaehlt; + satz aufbauen; + send (order task, ack, ds) . + +satz aufbauen : + satz initialisieren (p. satz info, anzahl felder); + FOR i FROM 1 UPTO anzahl felder REP + feld lesen (i, puffer); + feld aendern (p. satz info, i, puffer) + END REP . + +ask partner code ausfuehren : + INT VAR p nr := order - ask partner code; + forget (ds); ds := nilspace; + BOUND TASK VAR c task := ds; + CONCR (c task) := partner mit einrichten (p nr, task index); + send (order task, ack, ds) . + +task index : + FOR i FROM 2 UPTO 4 REP + IF partner task (i) = order task THEN + LEAVE task index WITH i + END IF + END REP; + errorstop (kein partner); + 1 . + +END PROC eudas manager; + +TASK PROC abhaengige task (INT CONST p nr) : + + partner mit einrichten (p nr, 1) + +END PROC abhaengige task; + +TASK PROC partner mit einrichten (INT CONST p nr, p von) : + + enable stop; + IF NOT exists (partner task (p nr)) THEN + partner einrichten + END IF; + partner task (p nr) . + +partner einrichten : + TEXT CONST neuer name := name (myself) + "-p" + text (p nr - 1); + begin (neuer name, partner vater (p nr)); + partner task (p nr, task (neuer name)); + abhaengig setzen . + +abhaengig setzen : + DATASPACE VAR send ds := nilspace; + BOUND STRUCT (INT von, TASK pt) VAR m := send ds; + m. von := p von; + m. pt := partner task (p von); + INT VAR i, reply; + FOR i FROM 1 UPTO 5 REP + pingpong (partner task (p nr), set controlled code, send ds, reply); + IF reply = -2 THEN pause (5) END IF + UNTIL reply <> -2 END REP; + forget (send ds) . + +END PROC partner mit einrichten; + +PROC end partner (INT CONST p nr) : + + IF exists (partner task (p nr)) THEN + end code senden + END IF . + +end code senden : + DATASPACE VAR send ds := nilspace; + INT VAR i, reply; + FOR i FROM 1 UPTO 10 REP + send (partner task (p nr), end myself code, send ds, reply); + IF reply = ack THEN + LEAVE end code senden + END IF; + pause (3) + END REP; + forget (send ds); + errorstop ("END nicht angenommen") . + +END PROC end partner; + + +END PACKET eudas manager; + diff --git a/app/flint/0.4/src/flint b/app/flint/0.4/src/flint new file mode 100644 index 0000000..14e0fe1 --- /dev/null +++ b/app/flint/0.4/src/flint @@ -0,0 +1,808 @@ +PACKET flint + +(*************************************************************************) +(* *) +(* EUMEL Menue-Monitor *) +(* *) +(* Version 05 *) +(* *) +(* Autor: Thomas Berlage *) +(* Stand: 16.10.88 *) +(* *) +(*************************************************************************) + + DEFINES + + flint : + + +TEXT CONST flint vater := name (myself); + +setze partner (2, "KAKTUS"); +setze partner (3, "CHART"); + + +PROC flint : + + page; + fenstergroessen bestimmen; + disable stop; + REP + menue anbieten (ROW 6 TEXT : + ("FLINT.Standard", "FLINT.Eigene", "FLINT.System", + "EUDAS.Dateien", "EUDAS.Archiv", ""), + fenster links, TRUE, + PROC (INT CONST, INT CONST) flint inter); + bereich wechseln + END REP + +END PROC flint; + +PROC fusszeile aktualisieren : + + arbeitsbereich bestimmen; + fussteil (2, "", "") + +END PROC fusszeile aktualisieren; + + +(*************************** FLINT Interpreter *****************************) + +LET + t datum = #1300# + ""15"Datum "14"", + kb von = #1301# + " KB von ", + sind belegt = #1302# + " KB sind belegt.", + p taskname = #1303# + "Name des Arbeitsbereichs:", + existiert nicht als task = #1304# + " ist kein Name eines Bereiches", + t loeschen = #1305# + " verlassen und löschen", + t speicher = #1306# + "Speicher:", + t cpu zeit = #1307# + " KB CPU-Zeit : ", + t zustand = #1308# + "Zustand : ", + t prio = #1309# + " Priorität: ", + t kanal = #1310# + " Kanal: ", + t busy = #1311# + "Arbeit", + t io = #1312# + "EinAus", + t wait = #1313# + "Warten", + t busy blocked = #1314# + "B(Arb)", + t io blocked = #1315# + "B(E/A)", + t wait blocked = #1316# + "B(Wrt)", + t dead = #1317# + ">>TOT<", + bereich neu einrichten = #1318# + "Bereich existiert nicht. Neu einrichten", + p name vater = #1319# + "Unter welchem Vaterbereich (RET -> FLINT):", + weitermachen in = #1320# + "Weitermachen in Bereich:", + task ganz abkoppeln = #1321# + "Eigenen Bereich ganz abkoppeln"; + +TEXT VAR + wechsel taskname := ""; + +SATZ VAR sammel; + + +PROC flint inter (INT CONST menuenr, f nr) : + + SELECT menuenr OF + CASE 0: sperren setzen + CASE 1: standard interpreter + CASE 2: eigene interpreter + CASE 3: system interpreter + CASE 4: dateiverwaltung (f nr) + CASE 5: archivverwaltung (menuenr, f nr) + END SELECT . + +sperren setzen : + fusszeile ("", "", 35, t datum, 64); + fussteil (3, date) . + +standard interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : textverarbeitung + CASE 2 : eudas + CASE 3 : kaktus + CASE 4 : dgs superchart + CASE 5 : programme + CASE 6 : systemsteuerung + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +kaktus : + continue (abhaengige task (2)); + page; bildschirm neu . + +dgs superchart : + continue (abhaengige task (3)); + page; bildschirm neu . + +systemsteuerung : + continue (task ("OP")); + page; bildschirm neu . + +ggf dialogfenster loeschen : + IF f nr = -1 THEN dialogfenster loeschen END IF . + +eigene interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +system interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : bereich wechseln + CASE 2 : bereichsuebersicht + CASE 3 : speicherbelegung + CASE 4 : eigener status + CASE 5 : fremder taskstatus + CASE 6 : task info (3); bildschirm neu; dialogfenster loeschen + CASE 7 : task loeschen + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +bereichsuebersicht : + disable stop; + bitte warten; + DATASPACE VAR list ds := nilspace; + FILE VAR f := sequential file (output, list ds); + task info (1, f); + IF NOT is error THEN + edit (f, fenster rechts, "SHOW/Taskinfo", FALSE) + END IF; + forget (list ds); + enable stop . + +speicherbelegung : + INT VAR size, used; + storage (size, used); + size := int (real (size + 24) * 64.0 / 63.0); + IF l3 THEN + size := size DIV 1024; + used := used DIV 1024 + END IF; + dialog (text (used) + kb von + text (size) + sind belegt) . + +eigener status : + task zustand (myself) . + +fremder taskstatus : + TEXT VAR taskname := ""; + editget (p taskname, taskname, "GET/Taskname", ""); + TASK VAR status task := task (task name); + IF exists (status task) THEN + task zustand (status task) + ELSE + errorstop (textdarstellung (taskname) + existiert nicht als task) + END IF . + +task loeschen : + IF ja (textdarstellung (name (myself)) + t loeschen, + "JA/Task loeschen", FALSE) THEN + end partner (2); end partner (3); + deferred end; + bereich wechseln + END IF . + +END PROC flint inter; + +PROC bereich wechseln : + + enable stop; + editget (weitermachen in, wechsel taskname, "z", "GET/wtaskname"); + IF subtext (wechsel taskname, 1, 2) = ""27"z" THEN + bereich auswaehlen + ELIF wechsel taskname <> "" THEN + ggf task einrichten + ELIF ganz abkoppeln THEN + continue (niltask) + END IF; + fenstergroessen bestimmen; + page; + bildschirm neu . + +bereich auswaehlen : + bitte warten; + alle tasknamen sammeln; + auswahl anbieten ("FLINT.Taskauswahl", fenster rechts, 1, + "AUSWAHL/Tasks", PROC (TEXT VAR, INT CONST) aus sammel); + IF wahl (1) <> 0 THEN + feld lesen (sammel, wahl (1), wechsel taskname); + continue (task (wechsel taskname)) + END IF . + +alle tasknamen sammeln : + access catalogue; + satz initialisieren (sammel); + wechsel taskname := subtext (wechsel taskname, 3); + pattern feststellen; + IF exists task (flint vater) THEN + sammel tasks (task (flint vater), pattern) + ELSE + sammel tasks (father, pattern) + END IF . + +pattern feststellen : + TEXT VAR pattern; + IF pos (wechsel taskname, "*") = 0 THEN + pattern := "" + ELSE + pattern := wechsel taskname + END IF . + +ggf task einrichten : + IF NOT exists task (wechsel taskname) THEN + IF ja (bereich neu einrichten, "JA/task einrichten") THEN + vater erfragen; + begin (wechsel taskname, name vater); + continue (task (wechsel taskname)) + END IF + ELSE + continue (task (wechsel taskname)) + END IF . + +vater erfragen : + TEXT VAR name vater := ""; + editget (p name vater, name vater, "", "GET/Vatertask"); + IF name vater = "" THEN + name vater := flint vater + END IF . + +ganz abkoppeln : + ja (task ganz abkoppeln, "JA/abkoppeln") . + +END PROC bereich wechseln; + +PROC aus sammel (TEXT VAR inhalt, INT CONST pos) : + + IF pos > 200 THEN + inhalt := "" + ELSE + feld lesen (sammel, pos, inhalt) + END IF + +END PROC aus sammel; + +PROC sammel tasks (TASK CONST vater, TEXT CONST pattern) : + + TASK VAR naechste := son (vater); + WHILE NOT is niltask (naechste) REP + ggf task sammeln; + sammel tasks (naechste, pattern); + naechste := brother (naechste) + END REP . + +ggf task sammeln : + IF naechste = myself THEN + ELIF pattern = "" COR (name (naechste) LIKE pattern) THEN + feld aendern (sammel, felderzahl (sammel) + 1, name (naechste)) + END IF . + +END PROC sammel tasks; + +PROC task zustand (TASK CONST status task) : + + dialog (t speicher + speicher + t cpu zeit + cpu zeit); + out (t zustand); out status; out (t prio); out prio; + out (t kanal); out kanal . + +speicher : + text (storage (status task), 5) . + +cpu zeit : + disable stop; + TEXT VAR result := subtext (time (clock (status task), 12), 1, 10); + IF is error THEN + clear error; result := "**********" + END IF; + result . + +out status : + SELECT status (status task) OF + CASE 0 : out (t busy) + CASE 1 : out (t io) + CASE 2 : out (t wait) + CASE 4 : out (t busy blocked) + CASE 5 : out (t io blocked) + CASE 6 : out (t wait blocked) + OTHERWISE out (t dead) + END SELECT . + +out prio : + out (text (pcb (status task, 6))) . + +out kanal : + IF channel (status task) = 0 THEN + out (" -") + ELSE + out (text (channel (status task), 2)) + END IF . + +END PROC task zustand; + + +(**************************** Textverarbeitung ****************************) + +LET + t ausnahmen = #1400# + "Ausnahmen", + t druckertask = #1401# + "Name Druckertask: ", + task existiert nicht = #1402# + "Task existiert nicht", + t stationsnummer = #1403# + "Stationsnummer der Druckertask: ", + falsche stationsnummer = #1404# + "Falsche Stationsnummer", + t trennfaktor = #1405# + "Trennfaktor (4 bis 20): ", + t ersten kopf unterdruecken = #1406# + "Ersten Kopfteil unterdrücken", + t letzten fuss unterdruecken = #1407# + "Letzten Fußteil unterdrücken", + t fussabstand = #1408# + "Anzahl Leerzeilen vor Fußnoten (0 bis 9): ", + lineform manuell = #1409# + "Trennungen manuell bestimmen", + pageform manuell = #1410# + "Seitenaufteilung manuell bestimmen", + falscher trennfaktor = #1411# + "Falscher Trennfaktor (nur 4 bis 20)", + name fonttabelle = #1412# + "Name der Fonttabelle: ", + t neu einrichten = #1413# + " neu einrichten", + name der datei = #1414# + "Name der Datei: "; + +LET + font file typ = 3009; + +INT VAR + file typ := 1003; + +IF l3 THEN file typ := 1004 END IF . + +l3 : maxint DIV 2 > 17000 . +; + +BOOL VAR + zeilen manuell := TRUE, + seiten manuell := TRUE; + +TEXT VAR + druckertask := "PRINTER"; + +INT VAR + druckerstation := station (myself); + + +PROC textverarbeitung : + + page; bildschirm neu; + BOOL CONST alter umbruch := word wrap; + word wrap (TRUE); + menue anbieten (ROW 6 TEXT : + ("TEXTE.Erstellen", "TEXTE.Bearbeiten", "TEXTE.Einstellungen", + "EUDAS.Dateien", "EUDAS.Archiv", ""), + fenster links, TRUE, + PROC (INT CONST, INT CONST) text inter); + word wrap (alter umbruch); + page; bildschirm neu + +END PROC textverarbeitung; + +PROC text inter (INT CONST menuenr, f nr) : + + SELECT menuenr OF + CASE 0: sperren setzen + CASE 1: erstellen interpreter + CASE 2: bearbeiten interpreter + CASE 3: einstellungen interpreter + CASE 4: dateiverwaltung (f nr) + CASE 5: archivverwaltung (menuenr, f nr) + END SELECT . + +sperren setzen : + fusszeile ("", "", 35, t datum, 64); + fussteil (3, date) . + +erstellen interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : editieren + CASE 2 : drucken + CASE 3 : zeilen formatieren + CASE 4 : seiten formatieren + CASE 5 : automatik + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +editieren : + ausfuehrung (PROC (TEXT CONST) editiere); + dialogfenster loeschen . + +drucken : + ausfuehrung (PROC (TEXT CONST) drucke) . + +zeilen formatieren : + bildschirm neu; + IF zeilen manuell THEN + ausfuehrung (PROC (TEXT CONST) lineform) + ELSE + ausfuehrung (PROC (TEXT CONST) autoform) + END IF; + dialogfenster loeschen . + +seiten formatieren : + bildschirm neu; + IF seiten manuell THEN + ausfuehrung (PROC (TEXT CONST) pageform) + ELSE + ausfuehrung (PROC (TEXT CONST) autopageform) + END IF; + dialogfenster loeschen . + +automatik : + zeilen manuell := ja (lineform manuell, + "JA/lineform manuell", zeilen manuell); + seiten manuell := ja (pageform manuell, + "JA/pageform manuell", seiten manuell) . + +ggf dialogfenster loeschen : + IF f nr = -1 THEN dialogfenster loeschen END IF . + +bearbeiten interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : index anlegen + CASE 2 : outline anlegen + CASE 3 : file sortieren + CASE 4 : macros laden + CASE 5 : macros anzeigen + CASE 6 : ausnahmen erweitern + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +index anlegen : + ausfuehrung (PROC (TEXT CONST) index); + bildschirm neu; dialogfenster loeschen . + +outline anlegen : + ausfuehrung (PROC (TEXT CONST) outline); + bildschirm neu; dialogfenster loeschen . + +file sortieren : + bitte warten; + ausfuehrung (PROC (TEXT CONST) sort) . + +macros laden : + page; + einzelausfuehrung (PROC (TEXT CONST) load macros); + bildschirm neu; dialogfenster loeschen . + +macros anzeigen : + bitte warten; + list macros; + bildschirm neu; dialogfenster loeschen . + +ausnahmen erweitern : + TEXT VAR zwischendatei := t ausnahmen; + WHILE exists (zwischendatei) REP zwischendatei CAT " " END REP; + create (zwischendatei); + bitte warten; + entlade ausnahmen (zwischendatei); + edit (zwischendatei); + bitte warten; + lade ausnahmen (zwischendatei); + forget (zwischendatei, quiet) . + +einstellungen interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : fonttabelle laden + CASE 2 : fonts anzeigen + CASE 3 : druckertask verstellen + CASE 4 : trennfaktor einstellen + CASE 5 : briefmodus einstellen + CASE 6 : abstand fussnoten einstellen + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +fonttabelle laden : + TASK VAR fonttask; + IF exists task ("configurator") THEN + fonttask := task ("configurator") + ELSE + fonttask := niltask + END IF; + ausfuehrung (name fonttabelle, TRUE, font file typ, fonttask, + PROC (TEXT CONST) font table) . + +fonts anzeigen : + bitte warten; + list fonts; + bildschirm neu; dialogfenster loeschen . + +druckertask verstellen : + editget (t druckertask, druckertask, "GET/Druckertask", ""); + IF NOT exists task (druckertask) THEN + errorstop (task existiert nicht) + ELIF station (myself) <> 0 THEN + erfrage station + ELSE + druckerstation := station (myself) + END IF . + +erfrage station : + TEXT VAR st := text (druckerstation); + editget (t stationsnummer, st, "GET/Druckstation", ""); + IF int (st) >= 0 AND last conversion ok THEN + druckerstation := int (st) + ELSE + errorstop (falsche stationsnummer) + END IF . + +trennfaktor einstellen : + TEXT VAR faktor := ""; + editget (t trennfaktor, faktor, "GET/Trennfaktor", ""); + IF faktor <> "" THEN + INT CONST fa := int (faktor); + IF fa < 4 OR fa > 20 THEN + errorstop (falscher trennfaktor); + ELSE + hyphenation width (fa) + END IF + END IF . + +briefmodus einstellen : + first head (NOT ja (t ersten kopf unterdruecken, "JA/firsthead", FALSE)); + last bottom (NOT ja (t letzten fuss unterdruecken, "JA/lastbottom", FALSE)) . + +abstand fussnoten einstellen : + TEXT VAR anzahl := ""; + editget (t fussabstand, anzahl, "GET/Fussabstand", ""); + IF anzahl <> "" THEN + number empty lines before foot (int (anzahl)) + END IF . + +END PROC text inter; + +PROC drucke (TEXT CONST dateiname) : + + save (dateiname, druckerstation / druckertask) + +END PROC drucke; + +PROC editiere (TEXT CONST dateiname) : + + IF exists (dateiname) COR neu einrichten THEN + IF NOT exists (dateiname) THEN vorher einrichten END IF; + FILE VAR f := sequential file (modify, dateiname); + edit (f, fenster ganz, "EDIT/Text") + END IF . + +neu einrichten : + ja (textdarstellung (dateiname) + t neu einrichten, + "JA/einrichten") . + +vorher einrichten : + FILE VAR dummy := sequential file (modify, dateiname) . + +END PROC editiere; + +PROC ausfuehrung (PROC (TEXT CONST) operation) : + + ausfuehrung (name der datei, FALSE, file typ, PROC (TEXT CONST) operation) + +END PROC ausfuehrung; + +PROC einzelausfuehrung (PROC (TEXT CONST) operation) : + + ausfuehrung (name der datei, TRUE, file typ, PROC (TEXT CONST) operation) + +END PROC einzelausfuehrung; + + +(*************************** Programme ***********************************) + +LET + p name prozedur = #1500# + "Name der Prozedur:", + p name paket = #1501# + "Name des Pakets:", + t weiter mit taste = #1502# + "*** Weiter mit Taste ***"; + + +PROC programme : + + page; bildschirm neu; + BOOL CONST alter umbruch := word wrap; + word wrap (FALSE); + menue anbieten (ROW 6 TEXT : ("ELAN.Erstellen", "ELAN.Permanent", + "EUDAS.Dateien", "EUDAS.Archiv", "", ""), + fenster links, TRUE, + PROC (INT CONST, INT CONST) prog interpreter); + word wrap (alter umbruch); + page; bildschirm neu + +END PROC programme; + +PROC prog interpreter (INT CONST menuenr, f nr) : + + SELECT menuenr OF + CASE 0 : sperren setzen + CASE 1 : erstellen interpreter + CASE 2 : permanent interpreter + CASE 3 : dateiverwaltung (f nr) + CASE 4 : archivverwaltung (menuenr, f nr) + END SELECT . + +sperren setzen : + fusszeile ("", "", 35, t datum, 64); + fussteil (3, date) . + +erstellen interpreter : + enable stop; + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : editieren + CASE 2 : ausfuehren + CASE 3 : wiederholen + CASE 4 : drucken + CASE 5 : testinstallation + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +ggf dialogfenster loeschen : + IF f nr = -1 THEN dialogfenster loeschen END IF . + +editieren : + ausfuehrung (PROC (TEXT CONST) editiere); + dialogfenster loeschen . + +drucken : + ausfuehrung (PROC (TEXT CONST) drucke) . + +ausfuehren : + ausfuehrung (PROC (TEXT CONST) page and run); + dialogfenster loeschen . + +wiederholen : + page; + bildschirm neu; + runagain; + warten auf antwort; + dialogfenster loeschen . + +testinstallation : + ausfuehrung (PROC (TEXT CONST) page check on insert); + dialogfenster loeschen . + +permanent interpreter : + SELECT f nr OF + CASE 0 : fusszeile aktualisieren + CASE 1 : installieren + CASE 2 : prozedurhilfe + CASE 3 : pakethilfe + CASE 4 : alle pakete + OTHERWISE ggf dialogfenster loeschen + END SELECT . + +installieren : + ausfuehrung (PROC (TEXT CONST) page check off insert); + dialogfenster loeschen . + +prozedurhilfe : + TEXT VAR prozedurname := ""; + editget (p name prozedur, prozedurname, "", "GET/prozedurname"); + IF prozedurname <> "" THEN + bildschirm neu; + bitte warten; + help (prozedurname); + dialogfenster loeschen + END IF . + +pakethilfe : + prozedurname := ""; + editget (p name paket, prozedurname, "", "GET/paketname"); + IF prozedurname <> "" THEN + bildschirm neu; + bitte warten; + bulletin (prozedurname); + dialogfenster loeschen + END IF . + +alle pakete : + bildschirm neu; + bitte warten; + packets; + dialogfenster loeschen . + +END PROC prog interpreter; + +PROC warten auf antwort : + + TEXT VAR taste; + line; put (t weiter mit taste); + inchar (taste); + line + +END PROC warten auf antwort; + +PROC page and run (TEXT CONST dateiname) : + + bildschirm neu; + page; bitte warten; + check on; + run (dateiname); + warten auf antwort + +END PROC page and run; + +PROC page check on insert (TEXT CONST dateiname) : + + bildschirm neu; + page; bitte warten; + check on; + insert (dateiname); + warten auf antwort + +END PROC page check on insert; + +PROC page check off insert (TEXT CONST dateiname) : + + bildschirm neu; + page; bitte warten; + check off; + insert (dateiname); + warten auf antwort + +END PROC page check off insert; + + +END PACKET flint; + +PACKET flint monitor DEFINES + + monitor : + + +PROC monitor : + + disable stop; + partner task (1, myself); + continue (niltask); + flint + +END PROC monitor; + +END PACKET flint monitor; + diff --git a/app/flint/0.4/src/flint.init b/app/flint/0.4/src/flint.init new file mode 100644 index 0000000..a743f52 --- /dev/null +++ b/app/flint/0.4/src/flint.init @@ -0,0 +1,603 @@ +% MENUE "FLINT.Standard" +% BILD +Untermenüs +Version 0.5 +- +  Textverarb. +- +  Datenbank +- +  Kalkulation +- +  Grafiken +- +  ELAN +- +  Steuerung +% FELD 1 "FLINT/1T" "tT" +% FELD 2 "FLINT/1D" "dD" +% FELD 3 "FLINT/1K" "kK" +% FELD 4 "FLINT/1G" "gG" +% FELD 5 "FLINT/1P" "eE" +% FELD 6 "FLINT/1S" "sS" +% ENDE +% MENUE "FLINT.Eigene" +% BILD +Eigene Fkt. +   + +   + +   + +   + +% FELD 1 "" "aA" +% FELD 2 "" "bB" +% FELD 3 "" "cC" +% FELD 4 "" "dD" +% ENDE +% MENUE "FLINT.System" +% BILD +Arbeitsbereich +  Wechseln +- +Übersicht +  Bereiche +  Speicher +- +Taskzustand +  Eigene +  Fremde +  Alle +- +Eigene Task +  Löschen +% FELD 1 "FLINT/3W" "wW" +% FELD 2 "FLINT/3B" "bB" +% FELD 3 "FLINT/3S" "sS" +% FELD 4 "FLINT/3E" "eE" +% FELD 5 "FLINT/3F" "fF" +% FELD 6 "FLINT/3A" "aA" +% FELD 7 "FLINT/3L" "lL" +% ENDE +% MENUE "TEXTE.Erstellen" +% BILD +Textdatei +  Eingeben +  Drucken +- +Formatieren +  Zeilenweise +  Seitenweise +  Automatik +% FELD 1 "TEXTE/1E" "eE" +% FELD 2 "TEXTE/1D" "dD" +% FELD 3 "TEXTE/1Z" "zZ" +% FELD 4 "TEXTE/1S" "sS" +% FELD 5 "TEXTE/1A" "aA" +% ENDE +% MENUE "TEXTE.Bearbeiten" +% BILD +Extrahieren +  Index +  Gliederung +- +Textdatei +  Sortieren +- +Makros +  Laden +  Anzeigen +- +Ausnahmen +  Erweitern +% FELD 1 "TEXTE/2I" "iI" +% FELD 2 "TEXTE/2G" "gG" +% FELD 3 "TEXTE/2S" "sS" +% FELD 4 "TEXTE/2L" "lL" +% FELD 5 "TEXTE/2A" "aA" +% FELD 6 "TEXTE/2E" "eE" +% ENDE +% MENUE "TEXTE.Einstellungen" +% BILD +Schrifttypen +  Typtabelle +  Zeige Typen +- +  Drucker +- +Silbentrennung +  Faktor +- +Kopf/Fuß +  Briefmodus +- +Fußnoten +  Abstand +% FELD 1 "TEXTE/3T" "tT" +% FELD 2 "TEXTE/3Z" "zZ" +% FELD 3 "TEXTE/3D" "dD" +% FELD 4 "TEXTE/3F" "fF" +% FELD 5 "TEXTE/3B" "bB" +% FELD 6 "TEXTE/3A" "aA" +% ENDE +% MENUE "ELAN.Erstellen" +% BILD +ELAN-Programm +  Editieren +  Ausführen +  Wiederholen +  Drucken +  Installiern + testweise +% FELD 1 "PROG/1E" "eE" +% FELD 2 "PROG/1A" "aA" +% FELD 3 "PROG/1W" "wW" +% FELD 4 "PROG/1D" "dD" +% FELD 5 "PROG/1T" "iI" +% ENDE +% MENUE "ELAN.Permanent" +% BILD +Programm +  Installiern +- +Auskunft +  Einzelproz. +  GanzesPaket +  Paketnamen +% FELD 1 "PROG/2I" "iI" +% FELD 2 "PROG/2P" "eE" +% FELD 3 "PROG/2A" "gG" +% FELD 4 "PROG/2N" "pP" +% ENDE +% MENUE "EDIT MENUE:" +% BILD +Zeile Springen auf Zeile nach Nummer +Such Suchen nach Text +Ersetze Text suchen und ersetzen +WortMark Aktuelles Wort markieren +MarkSatz Aktuellen Satz bis Ende markieren +Kopiere Block kopieren oder einfügen (PUT, GET) +Fenster Datei in Teilfenster eröffnen +Breite Maximale Zeilenbreite (limit) einstellen +Taste Tastenbelegung abfragen und ändern +% FELD 1 "" "zZ" +% FELD 2 "" "sS" +% FELD 3 "" "eE" +% FELD 4 "" "wW" +% FELD 5 "" "mM" +% FELD 6 "" "kK" +% FELD 7 "" "fF" +% FELD 8 "" "bB" +% FELD 9 "" "tT" +% ENDE +% MENUE "TEXT MENUE:" +% BILD +Typ Schrifttyp einstellen (type) +Modifikation Schriftart für markierten Bereich festlegen (on, off) +Seite Neue Seite beginnen (page) +Raum Zwischenraum freilassen (free) +Einstellung Format für diese Datei einstellen +Formatiere Markierten Abschnitt zeilenweise formatieren +Drucke Markierten Abschnitt formatieren und drucken +% FELD 1 "" "tT" +% FELD 2 "" "mM" +% FELD 3 "" "sS" +% FELD 4 "" "rR" +% FELD 5 "" "eE" +% FELD 6 "" "fF" +% FELD 7 "" "dD" +% ENDE +% AUSWAHL "FLINT.Taskauswahl" +Bitte kreuzen Sie den gewünschten Bereich an. +% ENDE +% AUSWAHL "TEXT.Fontwahl" +Bitte Typ auswählen und ankreuzen: +% ENDE +% AUSWAHL "TEXT.Modwahl" +Art(en) ankreuzen: +% ENDE +% HILFE "FLINT/Allgemein" +% SEITE 1 "EUDAS/Allgemein" +% ENDE +% HILFE "FLINT1/T" +% SEITE 1 +Textverarbeitung +- +Aufruf der EUMEL-Textverarbeitung mit Menü. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/1D" +% SEITE 1 +EUDAS +- +Aufruf des Datenverwaltungssystems EUDAS. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/1K" +% SEITE 1 +KAKTUS +- +Aufruf der Tabellenkalkulation KAKTUS. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/1G" +% SEITE 1 +dgs-CHART +- +Aufruf des Geschäftsgrafikprogramms dgs-Superchart. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/1P" +% SEITE 1 +Programmerstellung +- +Aufruf eines Menüs zur Programmierung in ELAN. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/1S" +% SEITE 1 +Systemsteuerung +- +Aufruf eines Menüs zur Systemsteuerung (Abschalten, +Druckersteuerung, Konfiguration usw.). +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/3B" +% SEITE 1 +Übersicht Arbeitsbereiche +- +Verlassen der Übersicht mit ESC 'q'. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/3S" +% SEITE 1 +Speicherbelegung +- +Anzeige des belegten Hintergrundspeichers. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/3E" +% SEITE 1 +Eigener Taskzustand +- +Ausgabe des Zustands des eigenen Arbeitsbereichs. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/3F" +% SEITE 1 +Fremder Taskzustand +- +Ausgabe des Zustandes eines anderen Arbeitsbereichs. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "FLINT/3A" +% SEITE 1 +Taskzustand aller Bereiche +- +Verlassen mit ESC 'q'. +% SEITE 1 "FLINT/Allgemein" +% ENDE +% HILFE "TEXTE/Allgemein" +% SEITE 1 "EUDAS/Allgemein" +% ENDE +% HILFE "TEXTE/1E" +% SEITE 1 +Textdatei eingeben +- +Aufruf des Editors. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/1D" +% SEITE 1 +Textdatei drucken +- +Erstellte Datei ausdrucken lassen. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/1Z" +% SEITE 1 +Zeilenweise formatieren +- +Aufruf von 'lineform' oder 'autoform', je nach Einstellung. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/1S" +% SEITE 1 +Seitenweise formatieren +- +Aufruf von 'pageform' oder 'autopageform', je nach +Einstellung. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/1A" +% SEITE 1 +Einstellen automatische Formatierung +- +Abfrage, ob Zeilen- bzw. Seitenformatierung automatisch oder +interaktiv erfolgen sollen. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/2I" +% SEITE 1 +Index extrahieren +- +Aufruf von 'index' +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/2G" +% SEITE 1 +Gliederung extrahieren +- +Aufruf von 'outline' +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/2S" +% SEITE 1 +Textdatei sortieren +- +Aufruf von 'sort' bzw. 'lexsort'. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/2L" +% SEITE 1 +Makros laden +- +Aufruf von 'load macros'. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/2A" +% SEITE 1 +Makros anzeigen +- +Aufruf von 'list macros' +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/2E" +% SEITE 1 +Ausnahmen erweitern +- +Anzeigen des Ausnahmelexikons für die Silbentrennung und +Erfassung neuer Ausnahmen +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/3T" +% SEITE 1 +Schrifttypentabelle einstellen +- +Einstellen der Schrifttyptabelle für den Drucker, mit dem +der Text ausgedruckt werden soll. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/3Z" +% SEITE 1 +Schrifttypen zeigen +- +Anzeige der zur Verfügung stehenden Schriften. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/3D" +% SEITE 1 +Drucker einstellen +- +Einstellen der Druckertask, auf der ausgedruckt werden soll. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/3F" +% SEITE 1 +Trennfaktor Silbentrennung +- +Setzt 'hyphenation width'. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/3B" +% SEITE 1 +Briefmodus Kopf/Fußzeilen +- +Erfragt ob der erste Kopf und der letzte Fuß wie in einem +Brief unterdrückt werden sollen. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "TEXTE/3A" +% SEITE 1 +Abstand Fußnoten +- +Setzt Anzahl Zeilen zwischen Text und Fußnoten. +% SEITE 1 "TEXTE/Allgemein" +% ENDE +% HILFE "PROG/Allgemein" +% SEITE 1 "EUDAS/Allgemein" +% ENDE +% HILFE "PROG/1E" +% SEITE 1 +Programm editieren +- +Erstellen und Ändern im Editor. +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/1A" +% SEITE 1 +Programm ausführen +- +'run' +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/1W" +% SEITE 1 +Programmausführeung wiederholen +- +'runagain' +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/1D" +% SEITE 1 +Programm drucken +- +'print' +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/1T" +% SEITE 1 +Testinstallation +- +'insert' mit check on. +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/2I" +% SEITE 1 +Programm installieren +- +'insert' mit check off +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/2P" +% SEITE 1 +Übersicht Prozeduren +- +'help (TEXT)' +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/2A" +% SEITE 1 +Übersicht Paket +- +'bulletin (TEXT)' +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "PROG/2N" +% SEITE 1 +Übersicht Paketnamen +- +packets +% SEITE 1 "PROG/Allgemein" +% ENDE +% HILFE "AUSWAHL/Tasks" +% SEITE 1 +Auswahl der Arbeitsbereiche +- +Den Bereich ankreuzen, in dem forgefahren werden soll. +% SEITE 1 "AUSWAHL/Allgemein" +% ENDE +% HILFE "GET/Taskname" +% SEITE 1 +Name des Bereichs: +- +Namen des Bereichs eingeben, dessen Status abgefragt werden +soll. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/wtaskname" +% SEITE 1 +Name des Bereichs, in dem weitergemacht werden soll: +- +Existiert der Bereich noch nicht, wird er nach Anfrage +eingerichtet. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/Vatertask" +% SEITE 1 +Name des Vaterbereichs: +- +Jeder Bereich muß einen Vaterbereich haben, der angibt, +welche Programme zur Verfügung stehen. Geben Sie keinen +Namen an, wird FLINT als der allgemeine Vater genommen. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/Druckertask" +% SEITE 1 +Name der Druckertask: +- +Ist normalerweise PRINTER. Die Station bei Netzbetrieb kann +später eingegeben werden. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/Druckstation" +% SEITE 1 +Stationsnummer der Druckertask: +- +Bei Netzbetrieb zum Drucken auf einem anderen Rechner. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/Trennfaktor" +% SEITE 1 +Trennfaktor: +- +s. 'hyphenation width' +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/Fussabstand" +% SEITE 1 +Leerzeilen vor Fuß: +- +s. 'no empty lines before foot' +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/prozedurname" +% SEITE 1 +Name der Prozedur: +- +kann auch '*' enthalten. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/paketname" +% SEITE 1 +Name des Paketes: +- +Angabe des Namens eines insertierten Pakets. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "JA/Task loeschen" +% SEITE 1 +Bereich verlassen und löschen ? +- +Bei Bejahen wird ein neuer Bereich erfragt und der jetzige +Bereich nach dem Verlassen mit allen Dateien und Söhnen +gelöscht. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/task einrichten" +% SEITE 1 +Bereich neu einrichten ? +- +Bei Tippfehler oder Irrtum verneinen. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/abkoppeln" +% SEITE 1 +Ganz abkoppeln ? +- +Bei Tippfehler oder Irrtum verneinen. Ansonsten weiter mit +SV. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/lineform manuell" +% SEITE 1 +Zeilen manuell formatieren ? +- +Bei Bejahen muß jede Trennung von Hand bestätigt werden. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/pageform manuell" +% SEITE 1 +Seiten manuell formatieren ? +- +Bei Bejahen muß jede Seitentrennung von Hand bestätigt +werden. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/firsthead" +% SEITE 1 +Ersten Kopf unterdrücken ? +- +s. 'firsthead' +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/lastbottom" +% SEITE 1 +Letzten Fuß unterdrücken ? +- +s. 'last bottom' +% SEITE 1 "JA/Allgemein" +% ENDE + diff --git a/app/flint/0.4/src/flint.manager b/app/flint/0.4/src/flint.manager new file mode 100644 index 0000000..610d70f --- /dev/null +++ b/app/flint/0.4/src/flint.manager @@ -0,0 +1,16 @@ +PACKET flint manager (* Autor: Thomas Berlage *) + (* Stand: 15.01.88 *) + DEFINES + + continue : + + +PROC continue (TASK CONST t) : + + continue (t, + PROC (DATASPACE VAR, INT CONST, INT CONST, TASK CONST) eudas manager) + +END PROC continue; + +END PACKET flint manager; + diff --git a/app/flint/0.4/src/isub.replace b/app/flint/0.4/src/isub.replace new file mode 100644 index 0000000..3c48009 --- /dev/null +++ b/app/flint/0.4/src/isub.replace @@ -0,0 +1,19 @@ +PACKET isub replace DEFINES ISUB, replace : + +INT OP ISUB (TEXT CONST t, INT CONST i) : + + INT CONST ii := i + i; + code (t SUB ii - 1) + 256 * code (t SUB ii) + +END OP ISUB; + +PROC replace (TEXT VAR t, INT CONST i, wert) : + + INT CONST ii := i + i; + replace (t, ii - 1, code (wert MOD 256)); + replace (t, ii, code (wert DIV 256 MOD 256)) + +END PROC replace + +END PACKET isub replace; + diff --git a/app/flint/0.4/src/klartextbelegung b/app/flint/0.4/src/klartextbelegung new file mode 100644 index 0000000..efe4b08 --- /dev/null +++ b/app/flint/0.4/src/klartextbelegung @@ -0,0 +1,304 @@ +(*************************************************************************) +(* *) +(* K L A R T E X T *) +(* =============== *) +(* *) +(* Tastenbelegungen im Klartext fuer Steuertasten *) +(* *) +(* Autor: Thomas Berlage *) +(* Stand: 27.04.88 *) +(* Version 1.0 *) +(* *) +(* Zweck: Lernsequenzen koennen editiert werden, wobei fuer *) +(* die Steuertasten symbolische Namen in spitzen *) +(* Klammern verwendet werden. Folgende Namen sind *) +(* zulaessig: *) +(* *) +(* *) +(* *) +(* *) +(* Aufruf: *) +(* PROC lernsequenz editieren (TEXT CONST taste) *) +(* *) +(**************************************************************************) +PACKET case conversion (* Stand: 07.02.88 *) + + DEFINES + + to lowercase, + to uppercase : + + +PROC to uppercase (TEXT VAR line) : + + INT VAR p := 0; + REP + p := pos (line, "a", "z", p + 1); + IF p = 0 THEN LEAVE to uppercase END IF; + replace (line, p, code (code (line SUB p) - 32)) + END REP + +END PROC to uppercase; + +PROC to lowercase (TEXT VAR line) : + + INT VAR p := 0; + REP + p := pos (line, "A", "Z", p + 1); + IF p = 0 THEN LEAVE to lowercase END IF; + replace (line, p, code (code (line SUB p) + 32)) + END REP + +END PROC to lowercase; + +END PACKET case conversion; + +PACKET klartextbelegung + + DEFINES + + sieben bit modus, + klartext, + kodierung : + + +BOOL VAR sieben bit := TRUE; + +ROW 33 TEXT CONST tasten := ROW 33 TEXT : ( + "nul", "hop", "rechts", "oben", "-(4)", "fkt1", "fkt2", "-(7)", "links", + "tab", "unten", "rubin", "rubout", "return", "fkt3", "fkt4", "mark", + "-(17)", "-(18)", "-(19)", "-(20)", "fkt5", "fkt6", "-(23)", "fkt7", + "fkt8", "fkt9", "esc", "fkt10", "fkt11", "fkt12", "fkt13", "blank"); + +LET + separator anfang = "<", + separator ende = ">"; + +TEXT VAR ergebnis; + + +BOOL PROC sieben bit modus : + + sieben bit + +END PROC sieben bit modus; + +PROC sieben bit modus (BOOL CONST modus) : + + sieben bit := modus + +END PROC sieben bit modus; + +TEXT PROC klartext (TEXT CONST t) : + + INT VAR i; + ergebnis := ""; + FOR i FROM 1 UPTO length (t) REP + klartext eines zeichens bestimmen + END REP; + ergebnis . + +klartext eines zeichens bestimmen : + INT CONST c := code (t SUB i); + IF c < 33 THEN + ergebnis CAT separator anfang + tasten (c + 1) + separator ende + ELIF c >= 127 CAND sieben bit CAND kein umlaut THEN + ergebnis CAT separator anfang + text (c) + separator ende + ELSE + ergebnis CAT code (c) + END IF . + +kein umlaut : + pos (eumel sonderzeichen, code (c)) = 0 . + +eumel sonderzeichen : + ""214""215""216""217""218""219""220""221""222""223""251""252"" . + +END PROC klartext; + +TEXT PROC kodierung (TEXT CONST t) : + + INT VAR + sep pos := pos (t, separator anfang), + sep ende := 0; + + enable stop; + ergebnis := ""; + WHILE sep pos > 0 REP + text vor separator uebernehmen; + separiertes zeichen behandeln; + sep pos := pos (t, separator anfang, sep ende) + END REP; + restliche zeichen uebernehmen; + ergebnis . + +text vor separator uebernehmen : + ergebnis CAT subtext (t, sep ende + 1, sep pos - 1) . + +separiertes zeichen behandeln : + sep ende := pos (t, separator ende, sep pos); + IF sep ende = 0 THEN + errorstop ("""" + separator ende + """ fehlt.") + ELSE + separiertes zeichen kodieren + END IF . + +separiertes zeichen kodieren : + TEXT VAR bezeichnung := subtext (t, sep pos + 1, sep ende - 1); + change all (bezeichnung, " ", ""); + to lowercase (bezeichnung); + INT VAR c := int (bezeichnung); + IF keine zahl THEN + mit tabelle vergleichen + END IF; + ergebnis CAT code (c) . + +keine zahl : + NOT last conversion ok . + +mit tabelle vergleichen : + INT VAR i; + FOR i FROM 1 UPTO 33 REP + IF bezeichnung = tasten (i) THEN + c := i - 1; + LEAVE mit tabelle vergleichen + END IF + END REP; + errorstop ("unbekannte Tastenbezeichnung: """ + bezeichnung + """") . + +restliche zeichen uebernehmen : + ergebnis CAT subtext (t, sep ende + 1) . + +END PROC kodierung; + +END PACKET klartextbelegung; + +PACKET klartext anwendung + + DEFINES + + klartext auf taste, + klartext auf taste legen, + klartext aus file, + klartext in file, + lernsequenz editieren : + + +LET + separator anfang = "<", + separator ende = ">"; + +TEXT VAR + zeile, + sequenz, + aenderung; + +DATASPACE VAR + ds; + + +TEXT PROC klartext auf taste (TEXT CONST taste) : + + klartext (lernsequenz auf taste (kodierung (taste))) + +END PROC klartext auf taste; + +PROC klartext auf taste legen (TEXT CONST taste, belegung) : + + lernsequenz auf taste legen (kodierung (taste), kodierung (belegung)) + +END PROC klartext auf taste legen; + +PROC klartext in file (FILE VAR f, TEXT CONST belegung) : + + INT VAR + ende, + anfang := 1; + + output (f); + zeile := klartext (belegung); + REP + ende der zeile bestimmen; + putline (f, subtext (zeile, anfang, ende - 1)); + anfang := ende + UNTIL anfang > length (zeile) END REP . + +ende der zeile bestimmen : + TEXT CONST zeichen := subtext (zeile, anfang, anfang + 4); + IF zeichen = "" OR zeichen = "" THEN + ende := pos (zeile, separator anfang, anfang + 6) + ELSE + ende := pos (zeile, separator anfang, anfang + 1) + END IF; + IF ende = 0 THEN ende := length (zeile) + 1 END IF; + ende := min (anfang + maxlinelength (f), ende) . +(* + IF (ende - anfang) > maxlinelength (f) THEN + ende := anfang + maxlinelength (f) + ELIF ende > 5 THEN + letzten separator bestimmen + END IF . + +letzten separator bestimmen : + TEXT CONST zeichen := subtext (zeile, ende - 4, ende - 2); + IF zeichen = "esc" OR zeichen = "hop" THEN + ende verschieben + ELSE + ende := pos (zeile, separator ende, ende) + END IF . + +ende verschieben : + IF (zeile SUB ende + 5) = separator anfang THEN + ende := pos (zeile, separator ende, ende + 5); + IF ende = 0 THEN ende := length (zeile) END IF + ELSE + ende := ende + 5 + END IF . + *) +END PROC klartext in file; + +PROC klartext aus file (FILE VAR f, TEXT VAR belegung) : + + input (f); + belegung := ""; + WHILE NOT eof (f) REP + getline (f, zeile); + IF (zeile SUB LENGTH zeile) = " " THEN + zeile := subtext (zeile, 1, length (zeile) - 1) + END IF; + belegung CAT kodierung (zeile) + END REP . + +END PROC klartext aus file; + +PROC lernsequenz editieren (TEXT CONST taste) : + + disable stop; + ds := nilspace; + editieren (taste); + forget (ds) + +END PROC lernsequenz editieren; + +PROC editieren (TEXT CONST taste) : + + enable stop; + FILE VAR f := sequential file (output, ds); + sequenz := lernsequenz auf taste (taste); + klartext in file (f, sequenz); + headline (f, "Tastenbelegung"); + edit (f); + klartext aus file (f, aenderung); + IF aenderung <> sequenz CAND wirklich aendern THEN + lernsequenz auf taste legen (taste, aenderung) + END IF . + +wirklich aendern : + yes ("Lernsequenz aendern") . + +END PROC editieren; + +END PACKET klartext anwendung; + + + diff --git a/app/flint/0.4/src/offline.1 b/app/flint/0.4/src/offline.1 new file mode 100644 index 0000000..0e3e097 --- /dev/null +++ b/app/flint/0.4/src/offline.1 @@ -0,0 +1,5 @@ +PACKETofflinemanagerDEFINESbegin,deferredend,owntaskpassword,continuedfrom,continue,partnertask:LETb0=0,c0=1,d0=2,e0=5,f0=6,g0=4,h0=9,i0=100,j0=199;LETk0="Taskname ungültig",l0="Vater antwortet nicht",m0="Zieltask kann nicht direkt angekoppelt werden",n0="Passwort:",o0="Falsches Passwort",p0="Ankoppeln nur für Partnertasks",q0="Nur Partner können angekoppelt werden";BOOL VARr0:=FALSE,s0:=FALSE;TEXT VARt0:="";DATASPACE VARu0:=nilspace;INT VARv0,w0,x0,y0,z0;BOUND TEXT VARa1;BOUND STRUCT(TEXTb1,c1,TASKtask,PROCAd1)VARe1;TASK VARf1,g1:=niltask;ROW4TASK VARh1;INITFLAG VARi1;PROCbegin(TEXT CONSTj1,k1):enablestop;l1;IFj1="-"THENerrorstop(k0)END IF;m1;IFv0=h0THENe1:=u0;n1;call(task(k1),g0,u0,v0)END IF;IFv0=b0THEN TASK CONSTo1:=task(j1);forget(u0);p1ELIFv0=d0THENa1:=u0;disablestop;errorstop(CONCR(a1));forget(u0)ELSEforget(u0)END IF.m1:INT VARq1;forget(u0);u0:=nilspace;e1:=u0;CONCR(e1).b1:=j1;CONCR(e1).c1:="";FORq1FROM1UPTO5REPpingpong(task(k1),g0,u0,v0);IFv0=-2THENpause(5)END IF UNTILv0<>-2END +REP;IFv0=-2THENerrorstop(l0)END IF.n1:dialog(n0);getsecretline(CONCR(e1).c1);covertracks.p1:WHILEstatus(o1)<>2REPpause(10)END REP.END PROCbegin;PROCdeferredend:s0:=TRUE END PROCdeferredend;PROCowntaskpassword(TEXT CONSTword):t0:=length(t0)*" ";t0:=word;covertracksEND PROCowntaskpassword;TASK PROCcontinuedfrom:g1END PROCcontinuedfrom;PROCr1(TASK CONSTs1,PROC(DATASPACE VAR,INT CONST,INT CONST,TASK CONST)t1):enablestop;IFisniltask(s1)THENbreak;disablestopELSEu1END IF;v1;WHILE NOTonlineREPw1;x1;y1END REP;z1.u1:INT CONSTa2:=channel;b2;break(quiet);c2.b2:INT VARq1;forget(u0);u0:=nilspace;FORq1FROM1UPTO5REPpingpong(s1,j0,u0,v0);IFv0=-2THENpause(5)END IF UNTILv0<>-2END REP;d2;IFv0=f0THENe2ELIFv0=b0THENf2ELSEerrorstop(m0)END IF.d2:forget(u0);u0:=nilspace;a1:=u0.e2:dialog(n0);getsecretline(CONCR(a1));covertracks.f2:CONCR(a1):="".c2:FORq1FROM1UPTO5REPpingpong(s1,i0+a2,u0,v0);IFv0=-2THENpause(5)END IF UNTILv0<>-2END REP;disablestop;forget(u0);IFv0<>b0THENcontinue(a2)END IF.v1:IFs0OR(r0CAND NOT +exists(h1(1)))THENend(myself)END IF.w1:TEXT VARg2;IFiserrorTHENg2:=errormessage;clearerrorELSEg2:=""END IF.x1:setautonom;commanddialogue(FALSE);INT VARh2:=heapsize;g1:=niltask.y1:DATASPACE VARi2:=nilspace;REPwait(i2,w0,f1);IFw0<>e0THENj2;k2ELIFf1=g1THENl2;t1(i2,w0,z0,f1)ELSEm2END IF;n2;o2END REP.j2:z0:=1;y0:=w0;g1:=f1.l2:z0INCR1;w0:=y0.m2:forget(i2);i2:=nilspace;send(f1,c0,i2).n2:IFiserrorTHENforget(i2);i2:=nilspace;a1:=i2;CONCR(a1):=errormessage;clearerror;send(f1,d0,i2)END IF.o2:IFheapsize>h2+8THENcollectheapgarbage;h2:=heapsizeEND IF.k2:IFw0=j0THENp2ELIFw0>i0ANDw0"".q2:s2;t2;call(supervisor,w0,i2,v0);IF NOT(f1=supervisor)THENsend(f1,v0,i2)END IF;IFv0=b0THENforget(i2);LEAVEy1END IF.s2:IFr0CAND NOTu2(f1)ORx0>0CANDw0-i0<>x0THENerrorstop(p0);LEAVEq2END IF.t2:IF NOT(f1=supervisor)THENa1:=i2;IF CONCR(a1)<>t0THENerrorstop(o0);LEAVEq2END IF END IF.z1:IFg2<>""THENerrorstop(g2)END IF;commanddialogue +(TRUE).END PROCr1;PROCcontinue(TASK CONSTs1,PROC(DATASPACE VAR,INT CONST,INT CONST,TASK CONST)t1):enablestop;l1;x0:=0;IFs1=myselfTHEN ELIFr0THEN IF NOTu2(s1)THENerrorstop(q0)END IF ELIFu2(s1)THENx0:=channelEND IF;r1(s1,PROC(DATASPACE VAR,INT CONST,INT CONST,TASK CONST)t1)END PROCcontinue;BOOL PROCu2(TASK CONSTs1):NOTisniltask(s1)CAND(s1=h1(1)ORs1=h1(2)ORs1=h1(3)ORs1=h1(4))END PROCu2;TASK PROCpartnertask(INT CONSTindex):l1;h1(index)END PROCpartnertask;PROCpartnertask(INT CONSTindex,TASK CONSTs1):l1;h1(index):=s1;IFindex=1CAND NOT(s1=myself)THENr0:=TRUE END IF END PROCpartnertask;PROCl1:IF NOTinitialized(i1)THENv2END IF.v2:h1(1):=niltask;h1(2):=niltask;h1(3):=niltask;h1(4):=niltask.END PROCl1;END PACKETofflinemanager; + diff --git a/app/flint/0.4/src/offline.manager b/app/flint/0.4/src/offline.manager new file mode 100644 index 0000000..7f97421 --- /dev/null +++ b/app/flint/0.4/src/offline.manager @@ -0,0 +1,383 @@ +PACKET offline manager (* Autor: Thomas Berlage *) + (* Stand: 20.01.88 *) + DEFINES + + begin, + deferred end, + own task password, + continued from, + continue, + partner task : + + +LET + ack = 0, + nak = 1, + error nak = 2, + second phase ack = 5, + password ack = 6, + + begin code = 4, + password code = 9, + + continue code = 100, + ask for password code = 199; + +LET + taskname invalid = + "Taskname ungültig", + task not ready = + "Vater antwortet nicht", + direct continue impossible = + "Zieltask kann nicht direkt angekoppelt werden", + t password = + "Passwort:", + t wrong password = + "Falsches Passwort", + order task no partner = + "Ankoppeln nur für Partnertasks", + continue not partner = + "Nur Partner können angekoppelt werden"; + + +BOOL VAR + controlled mode := FALSE, + end myself := FALSE; + +TEXT VAR + own password := ""; + +DATASPACE VAR ds := nilspace; + +INT VAR + reply, + order, + control channel, + last order, + phase number; + +BOUND TEXT VAR reply message; + +BOUND STRUCT (TEXT tname, tpass, TASK task, PROCA start proc) VAR sv msg; + +TASK VAR + order task, + last order task := niltask; + +ROW 4 TASK VAR pt; + +INITFLAG VAR pt init; + + + +PROC begin (TEXT CONST task name, father name) : + + enable stop; + init partner; + IF task name = "-" THEN + errorstop (taskname invalid) + END IF; + call begin code; + IF reply = password code THEN + sv msg := ds; + get password; + call (task (father name), begin code, ds, reply) + END IF; + IF reply = ack THEN + TASK CONST new task := task (task name); + forget (ds); + wait for init + ELIF reply = error nak THEN + reply message := ds; + disable stop; + errorstop (CONCR (reply message)); + forget (ds) + ELSE + forget (ds) + END IF . + +call begin code : + INT VAR i; + forget (ds); ds := nilspace; + sv msg := ds; + CONCR (sv msg). tname := task name; + CONCR (sv msg). tpass := ""; + FOR i FROM 1 UPTO 5 REP + pingpong (task (father name), begin code, ds, reply); + IF reply = -2 THEN pause (5) END IF + UNTIL reply <> -2 END REP; + IF reply = -2 THEN + errorstop (task not ready) + END IF . + +get password : + dialog (t password); + get secret line (CONCR (sv msg). tpass); + cover tracks . + +wait for init : + WHILE status (new task) <> 2 REP pause (10) END REP . + +END PROC begin; + +PROC deferred end : + + end myself := TRUE + +END PROC deferred end; + +PROC own task password (TEXT CONST word) : + + own password := length (own password) * " "; + own password := word; + cover tracks + +END PROC own task password; + +TASK PROC continued from : + + last order task + +END PROC continued from; + +PROC i continue (TASK CONST t, + PROC (DATASPACE VAR, INT CONST, INT CONST, TASK CONST) manager) : + + enable stop; + IF is niltask (t) THEN + break; + disable stop + ELSE + ask for continue + END IF; + end if required; + WHILE NOT online REP + remember error message; + prepare manager; + wait for order + END REP; + repeat error message . + +ask for continue : + INT CONST my channel := channel; + ask if password required; + break (quiet); + send continue request . + +ask if password required : + INT VAR i; + forget (ds); ds := nilspace; + FOR i FROM 1 UPTO 5 REP + pingpong (t, ask for password code, ds, reply); + IF reply = -2 THEN pause (5) END IF + UNTIL reply <> -2 END REP; + init password ds; + IF reply = password ack THEN + get password from user + ELIF reply = ack THEN + set password empty + ELSE + errorstop (direct continue impossible) + END IF . + +init password ds : + forget (ds); + ds := nilspace; + reply message := ds . + +get password from user : + dialog (t password); + get secret line (CONCR (reply message)); + cover tracks . + +set password empty : + CONCR (reply message) := "" . + +send continue request : + FOR i FROM 1 UPTO 5 REP + pingpong (t, continue code + my channel, ds, reply); + IF reply = -2 THEN pause (5) END IF + UNTIL reply <> -2 END REP; + disable stop; + forget (ds); + IF reply <> ack THEN + continue (my channel) + END IF . + +end if required : + IF end myself OR (controlled mode CAND NOT exists (pt (1))) THEN + end (myself) + END IF . + +remember error message : + TEXT VAR stored error; + IF is error THEN + stored error := error message; + clear error + ELSE + stored error := "" + END IF . + +prepare manager : + set autonom; + command dialogue (FALSE); + INT VAR old heap size := heap size; + last order task := niltask . + +wait for order : + DATASPACE VAR local ds := nilspace; + REP + wait (local ds, order, order task); + IF order <> second phase ack THEN + prepare first phase; + manager with end check + ELIF order task = last order task THEN + prepare second phase; + manager (local ds, order, phase number, order task) + ELSE + send nak + END IF; + send error if necessary; + collect heap garbage if necessary + END REP . + +prepare first phase : + phase number := 1; + last order := order; + last order task := order task . + +prepare second phase : + phase number INCR 1; + order := last order . + +send nak : + forget (local ds); + local ds := nilspace; + send (order task, nak, local ds) . + +send error if necessary : + IF is error THEN + forget (local ds); + local ds := nilspace; + reply message := local ds; + CONCR (reply message) := error message; + clear error; + send (order task, error nak, local ds) + END IF . + +collect heap garbage if necessary : + IF heap size > old heap size + 8 THEN + collect heap garbage; + old heap size := heap size + END IF . + +manager with end check : + IF order = ask for password code THEN + answer if password required + ELIF order > continue code AND order < continue code + 16 THEN + try continue channel + ELSE + manager (local ds, order, phase number, order task) + END IF . + +answer if password required : + IF password required THEN + send (order task, password ack, local ds) + ELSE + send (order task, ack, local ds) + END IF . + +password required : + own password <> "" . + +try continue channel : + check control; + check password; + call (supervisor, order, local ds, reply); + IF NOT (order task = supervisor) THEN + send (order task, reply, local ds) + END IF; + IF reply = ack THEN + forget (local ds); + LEAVE wait for order + END IF . + +check control : + IF controlled mode CAND NOT is partner (order task) OR + control channel > 0 CAND order - continue code <> control channel THEN + errorstop (order task no partner); + LEAVE try continue channel + END IF . + +check password : + IF NOT (order task = supervisor) THEN + reply message := local ds; + IF CONCR (reply message) <> own password THEN + errorstop (t wrong password); + LEAVE try continue channel + END IF + END IF . + +repeat error message : + IF stored error <> "" THEN errorstop (stored error) END IF; + command dialogue (TRUE) . + +END PROC i continue; + +PROC continue (TASK CONST t, + PROC (DATASPACE VAR, INT CONST, INT CONST, TASK CONST) manager) : + + enable stop; + init partner; + control channel := 0; + IF t = myself THEN + (* do nothing *) + ELIF controlled mode THEN + IF NOT is partner (t) THEN errorstop (continue not partner) END IF + ELIF is partner (t) THEN + control channel := channel + END IF; + i continue (t, + PROC (DATASPACE VAR, INT CONST, INT CONST, TASK CONST) manager) + +END PROC continue; + +BOOL PROC is partner (TASK CONST t) : + + NOT is niltask (t) CAND + (t = pt (1) OR t = pt (2) OR t = pt (3) OR t = pt (4)) + +END PROC is partner; + +TASK PROC partner task (INT CONST index) : + + init partner; + pt (index) + +END PROC partner task; + +PROC partner task (INT CONST index, TASK CONST t) : + + init partner; + pt (index) := t; + IF index = 1 CAND NOT (t = myself) THEN + controlled mode := TRUE + END IF + +END PROC partner task; + +PROC init partner : + + IF NOT initialized (pt init) THEN + do init + END IF . + +do init : + pt (1) := niltask; pt (2) := niltask; + pt (3) := niltask; pt (4) := niltask . + +END PROC init partner; + + +END PACKET offline manager; + diff --git a/app/flint/0.4/src/operator b/app/flint/0.4/src/operator new file mode 100644 index 0000000..029b32c --- /dev/null +++ b/app/flint/0.4/src/operator @@ -0,0 +1,381 @@ +PACKET operator DEFINES (* Autor: Thomas Berlage *) + (* Stand: 15.01.88 *) + operator : + + + +LET + p neuer taskname = #2001# + "Weitermachen in Bereich:", + p name vater = #2002# + "Unter welchem Vater:", + t bereich = #2003# + ""15"Bereich "14"", + t datum = #2004# + ""15"Datum "14"", + f ganz abkoppeln = #2005# + "Arbeitsbereich ganz abkoppeln", + f arbeitsbereich neu einrichten = #2006# + "Arbeitsbereich existiert nicht. Neu einrichten", + f trotzdem abschalten = #2007# + "Nicht auf Terminal 1. Trotzdem abschalten", + kb von = #2008# + " KB von ", + sind belegt = #2009# + " KB sind belegt.", + p taskname = #2010# + "Name des Arbeitsbereichs:", + existiert nicht als task = #2011# + " ist kein Name eines Bereiches", + t loeschen = #2012# + " löschen", + t speicher = #2013# + "Speicher:", + t cpu zeit = #2014# + " KB CPU-Zeit : ", + t zustand = #2015# + "Zustand : ", + t prio = #2016# + " Priorität: ", + t kanal = #2017# + " Kanal: ", + t busy = #2018# + "Arbeit", + t io = #2019# + "EinAus", + t wait = #2020# + "Warten", + t busy blocked = #2021# + "B(Arb)", + t io blocked = #2022# + "B(E/A)", + t wait blocked = #2023# + "B(Wrt)", + t dead = #2024# + ">>TOT<", + t gestoppt = #2025# + "Druckertreiber gestoppt.", + t gestartet = #2026# + "Druckertreiber gestartet.", + t angehalten = #2027# + "Druckertreiber angehalten.", + f auf anhalten warten = #2028# + "Auf Anhalten des Treibers warten", + t drucker = #2029# + ""15"Drucker "14"", + p neuer printer = #2030# + "Welche Druckertask soll eingestellt werden:", + t bitte warten = #2031# + "Bitte warten .. "; + + +FENSTER VAR links, rechts; +fenster initialisieren (links);; +fenstergroesse setzen (links, 1, 2, 16, 22); +fenster initialisieren (rechts); +fenstergroesse setzen (rechts, 17, 2, 63, 22); +dialogfenster (rechts); + +TEXT VAR + druckertask := "PRINTER"; + + +PROC operator : + + TASK VAR letzte task; + TEXT VAR neuer name := ""; + continue (niltask); + REP + letzte task := continued from; + page; bildschirm neu; + disable stop; + operatormenue; + umschalten auf letzte task + END REP . + +operatormenue : + menue anbieten (ROW 6 TEXT : + ("OPERATOR.Abschalten", "OPERATOR.Systemzustand", "OPERATOR.Drucker", + "OPERATOR.Netz", "OPERATOR.Konfiguration", ""), + links, TRUE, PROC (INT CONST, INT CONST) op interpreter) . + +umschalten auf letzte task : + BOOL VAR first try; + IF exists (letzte task) CAND NOT (letzte task = supervisor) THEN + first try := TRUE; + continue (letzte task) + ELSE + first try := FALSE + END IF; + IF is error OR NOT first try THEN + REP + IF is error THEN fehler ausgeben END IF; + nach neuer task fragen; + zurueck in task + UNTIL NOT is error END REP + END IF . + +nach neuer task fragen : + REP + editget (p neuer taskname, neuer name, "", "GET/neuer taskname"); + UNTIL taskname akzeptiert END REP . + +taskname akzeptiert : + IF neuer name = "" THEN + ganz abkoppeln + ELSE + exists task (neuer name) COR neu einrichten + END IF . + +zurueck in task : + IF neuer name = "" THEN + continue (niltask) + ELIF exists task (neuer name) THEN + continue (task (neuer name)) + ELSE + TEXT VAR vater := ""; + editget (p name vater, vater, "", "GET/name vatertask"); + begin (neuer name, vater); + continue (task (neuer name)) + END IF . + +ganz abkoppeln : + ja (f ganz abkoppeln, "JA/ganz") . + +neu einrichten : + ja (f arbeitsbereich neu einrichten, "JA/task einrichten") . + +END PROC operator; + +PROC op interpreter (INT CONST menue nr, f nr) : + + enable stop; + SELECT menuenr OF + CASE 0 : sperren setzen + CASE 1 : abschalten inter + CASE 2 : systemzustand inter + CASE 3 : drucker inter + CASE 4 : netz inter + CASE 5 : konfiguration inter + END SELECT; + IF f nr = -1 THEN dialogfenster loeschen END IF . + +sperren setzen : + fusszeile (t bereich, "", 35, t datum, 64); + fussteil (1, name (myself)); + fussteil (3, date) . + +abschalten inter : + SELECT f nr OF + CASE 1 : abschalten + CASE 2 : (* nach DOS *) ni + CASE 3 : page; bildschirm neu; set date; dialogfenster loeschen + CASE 4 : page; bildschirm neu; save system + END SELECT . + +abschalten : + IF channel = 1 COR trotzdem abschalten THEN + page; + cursor (20, 11); out (t bitte warten); + cursor (20, 13); + shutup; + fenster veraendert (links); + push (""27"q") + END IF . + +trotzdem abschalten : + ja (f trotzdem abschalten, "JA/trotz shutup") . + +systemzustand inter : + SELECT f nr OF + CASE 1 : bereichsuebersicht + CASE 2 : speicherbelegung + CASE 3 : fremder taskstatus + CASE 4 : zustandsuebersicht + CASE 5 : task loeschen + END SELECT . + +bereichsuebersicht : + bitte warten; + disable stop; + DATASPACE VAR list ds := nilspace; + FILE VAR f := sequential file (output, list ds); + task info (1, f); + IF NOT is error THEN + show (f); bildschirm neu + END IF; + forget (list ds); + enable stop; + dialogfenster loeschen . + +speicherbelegung : + INT VAR size, used; + storage (size, used); + size := int (real (size + 24) * 64.0 / 63.0); + dialog (text (used) + kb von + text (size) + sind belegt) . + +fremder taskstatus : + TEXT VAR taskname := ""; + editget (p taskname, taskname, "GET/Taskname", ""); + TASK VAR status task := task (task name); + IF exists (status task) THEN + task zustand (status task) + ELSE + errorstop ("""" + taskname + """" + existiert nicht als task) + END IF . + +zustandsuebersicht : + bitte warten; task info (3); bildschirm neu; dialogfenster loeschen . + +task loeschen : + taskname := ""; + editget (p taskname, taskname, "GET/Taskname", ""); + IF ja ("""" + taskname + """" + t loeschen, + "JA/Task loeschen", FALSE) THEN + end (task (taskname)) + END IF . + +drucker inter : + SELECT f nr OF + CASE 0 : druckertask in fuss + CASE 1 : start (task (druckertask)); dialog (t gestartet) + CASE 2 : stop (task (druckertask)); dialog (t gestoppt) + CASE 3 : halt kommando + CASE 4 : list (task (druckertask)); bildschirm neu; dialogfenster loeschen + CASE 5 : first (task (druckertask)) + CASE 6 : killer (task (druckertask)) + CASE 7 : druckertask setzen + OTHERWISE ggf druckertask aus fuss + END SELECT . + +druckertask in fuss : + fussteil (2, t drucker, druckertask) . + +halt kommando : + IF ja (f auf anhalten warten, "JA/halt warten", FALSE) THEN + wait for halt (task (druckertask)) + ELSE + halt (task (druckertask)) + END IF; + dialog (t angehalten) . + +druckertask setzen : + TEXT VAR neuer printer := druckertask; + editget (p neuer printer, neuer printer, "", "GET/neuer printer"); + TASK CONST dummy := task (neuer printer); + druckertask := neuer printer; + fussteil (2, druckertask) . + +ggf druckertask aus fuss : + IF f nr = -1 THEN + fussteil (2, "", "") + END IF . + +netz inter : + SELECT f nr OF + CASE 1 : (* start *) ni + CASE 2 : (* stop *) ni + CASE 3 : (* zustand *) ni + CASE 4 : (* list (net.io) *) ni + END SELECT . + +konfiguration inter : + SELECT f nr OF + CASE 1 : konfigurieren + CASE 2 : (* drucker installieren *) ni + CASE 3 : (* netz installieren *) ni + CASE 4 : (* anwendung installieren *) ni + CASE 5 : (* systemprogramm installieren *) ni + END SELECT . + +konfigurieren : + THESAURUS VAR conf := ALL /"configurator"; + page; bildschirm neu; + forget quiet (conf); + fetch (conf, /"configurator"); + configurate; + line; + save ("configuration", /"configurator"); + forget quiet (conf); + dialogfenster loeschen . + +END PROC op interpreter; + +PROC task zustand (TASK CONST status task) : + + dialog (t speicher + speicher + t cpu zeit + cpu zeit); + out (t zustand); out status; out (t prio); out prio; + out (t kanal); out kanal . + +speicher : + text (storage (status task), 5) . + +cpu zeit : + disable stop; + TEXT VAR result := subtext (time (clock (status task), 12), 1, 10); + IF is error THEN + clear error; result := "**********" + END IF; + result . + +out status : + SELECT status (status task) OF + CASE 0 : out (t busy) + CASE 1 : out (t io) + CASE 2 : out (t wait) + CASE 4 : out (t busy blocked) + CASE 5 : out (t io blocked) + CASE 6 : out (t wait blocked) + OTHERWISE out (t dead) + END SELECT . + +out prio : + out (text (pcb (status task, 6))) . + +out kanal : + IF channel (status task) = 0 THEN + out (" -") + ELSE + out (text (channel (status task), 2)) + END IF . + +END PROC task zustand; + +PROC forget quiet (TEXT CONST datei) : + forget (datei, quiet) +END PROC forget quiet; + +PROC forget quiet (THESAURUS CONST t) : + do (PROC (TEXT CONST) forget quiet, t) +END PROC forget quiet; + +PROC bitte warten : + + cursor (1, 1); + out (t bitte warten); + out (""5"") + +END PROC bitte warten; + +PROC ni : + + dialog ("Zur Zeit nicht implementiert.") + +END PROC ni; + +END PACKET operator; + +PACKET operator monitor + + DEFINES + + monitor : + + +PROC monitor : + disable stop; + operator +END PROC monitor; + +END PACKET operator monitor; + diff --git a/app/flint/0.4/src/operator.1 b/app/flint/0.4/src/operator.1 new file mode 100644 index 0000000..b2235b2 --- /dev/null +++ b/app/flint/0.4/src/operator.1 @@ -0,0 +1,39 @@ +PACKEToperatormanagerDEFINESoperatormanager,continue:LETb0="Nur für Systemtasks zugelassen";PROCoperatormanager(DATASPACE VARc0,INT CONSTd0,e0,TASK CONSTf0):enablestop;IFf0=supervisorORf00.w0:ja(l0.k0+s0,"JA/spool control",t0).x0:call(q0,r0,j0,n0);IFn0=b0THENm0:=j0;errorstop(m0);FI;IFt0THEN LEAVEp0FI;END PROCp0;PROCkiller(TASK CONSTq0):p0(q0,d0," loeschen",FALSE)END PROCkiller;PROCfirst(TASK CONSTq0):p0(q0,e0," als erstes",TRUE)END PROCfirst;PROCstart(TASK CONSTq0):call(g0,"",q0);call(f0,"",q0);END PROCstart;PROCstop(TASK CONSTq0):call(g0,"",q0);END PROCstop;PROChalt(TASK CONSTq0):call(h0,"",q0);END PROChalt;PROCwaitforhalt(TASK CONSTq0):call(i0,"",q0);END PROCwaitforhalt;END PACKETspoolcmd; +PACKEToperatorDEFINESoperator:LETb0= +#2001#"Weitermachen in Bereich:",c0= +#2002#"Unter welchem Vater:",d0= +#2003#""15"Bereich "14"",e0= +#2004#""15"Datum "14"",f0= +#2005#"Arbeitsbereich ganz abkoppeln",g0= +#2006#"Arbeitsbereich existiert nicht. Neu einrichten",h0= +#2007#"Nicht auf Terminal 1. Trotzdem abschalten",i0= +#2008#" KB von ",j0= +#2009#" KB sind belegt.",k0= +#2010#"Name des Arbeitsbereichs:",l0= +#2011#" ist kein Name eines Bereiches",m0= +#2012#" löschen",n0= +#2013#"Speicher:",o0= +#2014#" KB CPU-Zeit : ",p0= +#2015#"Zustand : ",q0= +#2016#" Priorität: ",r0= +#2017#" Kanal: ",s0= +#2018#"Arbeit",t0= +#2019#"EinAus",u0= +#2020#"Warten",v0= +#2021#"B(Arb)",w0= +#2022#"B(E/A)",x0= +#2023#"B(Wrt)",y0= +#2024#">>TOT<",z0= +#2025#"Druckertreiber gestoppt.",a1= +#2026#"Druckertreiber gestartet.",b1= +#2027#"Druckertreiber angehalten.",c1= +#2028#"Auf Anhalten des Treibers warten",d1= +#2029#""15"Drucker "14"",e1= +#2030#"Welche Druckertask soll eingestellt werden:",f1= +#2031#"Bitte warten .. "; +FENSTER VARg1,h1;fensterinitialisieren(g1);;fenstergroessesetzen(g1,1,2,16,22);fensterinitialisieren(h1);fenstergroessesetzen(h1,17,2,63,22);dialogfenster(h1);TEXT VARi1:="PRINTER";PROCoperator:TASK VARj1;TEXT VARk1:="";continue(niltask);REPj1:=continuedfrom;page;bildschirmneu;disablestop;l1;m1END REP.l1:menueanbieten(ROW6TEXT:("OPERATOR.Abschalten","OPERATOR.Systemzustand","OPERATOR.Drucker","OPERATOR.Netz","OPERATOR.Konfiguration",""),g1,TRUE,PROC(INT CONST,INT CONST)n1).m1:BOOL VARo1;IFexists(j1)CAND NOT(j1=supervisor)THENo1:=TRUE;continue(j1)ELSEo1:=FALSE END IF;IFiserrorOR NOTo1THEN REP IFiserrorTHENfehlerausgebenEND IF;p1;q1UNTIL NOTiserrorEND REP END IF.p1:REPeditget(b0,k1,"","GET/neuer taskname");UNTILr1END REP.r1:IFk1=""THENs1ELSEexiststask(k1)CORt1END IF.q1:IFk1=""THENcontinue(niltask)ELIFexiststask(k1)THENcontinue(task(k1))ELSE TEXT VARu1:="";editget(c0,u1,"","GET/name vatertask");begin(k1,u1);continue(task(k1))END IF.s1:ja(f0,"JA/ganz").t1:ja(g0,"JA/task einrichten").END +PROCoperator;PROCn1(INT CONSTv1,w1):enablestop;SELECTv1OF CASE0:x1CASE1:y1CASE2:z1CASE3:a2CASE4:b2CASE5:c2END SELECT;IFw1=-1THENdialogfensterloeschenEND IF.x1:fusszeile(d0,"",35,e0,64);fussteil(1,name(myself));fussteil(3,date).y1:SELECTw1OF CASE1:d2CASE2:e2CASE3:page;bildschirmneu;setdate;dialogfensterloeschenCASE4:page;bildschirmneu;savesystemEND SELECT.d2:IFchannel=1CORf2THENpage;cursor(20,11);out(f1);cursor(20,13);shutup;fensterveraendert(g1);push(""27"q")END IF.f2:ja(h0,"JA/trotz shutup").z1:SELECTw1OF CASE1:g2CASE2:h2CASE3:i2CASE4:j2CASE5:k2END SELECT.g2:bittewarten;disablestop;DATASPACE VARl2:=nilspace;FILE VARf:=sequentialfile(output,l2);taskinfo(1,f);IF NOTiserrorTHENshow(f);bildschirmneuEND IF;forget(l2);enablestop;dialogfensterloeschen.h2:INT VARm2,n2;storage(m2,n2);m2:=int(real(m2+24)*64.0/63.0);dialog(text(n2)+i0+text(m2)+j0).i2:TEXT VARo2:="";editget(k0,o2,"GET/Taskname","");TASK VARp2:=task(o2);IFexists(p2)THENq2(p2)ELSEerrorstop(""""+o2+""""+l0)END IF.j2:bittewarten; +taskinfo(3);bildschirmneu;dialogfensterloeschen.k2:o2:="";editget(k0,o2,"GET/Taskname","");IFja(""""+o2+""""+m0,"JA/Task loeschen",FALSE)THENend(task(o2))END IF.a2:SELECTw1OF CASE0:r2CASE1:start(task(i1));dialog(a1)CASE2:stop(task(i1));dialog(z0)CASE3:s2CASE4:list(task(i1));bildschirmneu;dialogfensterloeschenCASE5:first(task(i1))CASE6:killer(task(i1))CASE7:t2OTHERWISEu2END SELECT.r2:fussteil(2,d1,i1).s2:IFja(c1,"JA/halt warten",FALSE)THENwaitforhalt(task(i1))ELSEhalt(task(i1))END IF;dialog(b1).t2:TEXT VARv2:=i1;editget(e1,v2,"","GET/neuer printer");TASK CONSTdummy:=task(v2);i1:=v2;fussteil(2,i1).u2:IFw1=-1THENfussteil(2,"","")END IF.b2:SELECTw1OF CASE1:e2CASE2:e2CASE3:e2CASE4:e2END SELECT.c2:SELECTw1OF CASE1:w2CASE2:e2CASE3:e2CASE4:e2CASE5:e2END SELECT.w2:THESAURUS VARx2:=ALL/"configurator";page;bildschirmneu;y2(x2);fetch(x2,/"configurator");configurate;line;save("configuration",/"configurator");y2(x2);dialogfensterloeschen.END PROCn1;PROCq2(TASK CONSTp2):dialog(n0+z2+o0+a3);out(p0);b3 +;out(q0);c3;out(r0);d3.z2:text(storage(p2),5).a3:disablestop;TEXT VARe3:=subtext(time(clock(p2),12),1,10);IFiserrorTHENclearerror;e3:="**********"END IF;e3.b3:SELECTstatus(p2)OF CASE0:out(s0)CASE1:out(t0)CASE2:out(u0)CASE4:out(v0)CASE5:out(w0)CASE6:out(x0)OTHERWISEout(y0)END SELECT.c3:out(text(pcb(p2,6))).d3:IFchannel(p2)=0THENout(" -")ELSEout(text(channel(p2),2))END IF.END PROCq2;PROCy2(TEXT CONSTf3):forget(f3,quiet)END PROCy2;PROCy2(THESAURUS CONSTg3):do(PROC(TEXT CONST)y2,g3)END PROCy2;PROCbittewarten:cursor(1,1);out(f1);out(""5"")END PROCbittewarten;PROCe2:dialog("Zur Zeit nicht implementiert.")END PROCe2;END PACKEToperator;PACKEToperatormonitorDEFINESmonitor:PROCmonitor:disablestop;operatorEND PROCmonitor;END PACKEToperatormonitor; + diff --git a/app/flint/0.4/src/operator.init b/app/flint/0.4/src/operator.init new file mode 100644 index 0000000..99d7c08 --- /dev/null +++ b/app/flint/0.4/src/operator.init @@ -0,0 +1,390 @@ +% MENUE "OPERATOR.Abschalten" +% BILD +Arbeit +  Beenden +- +Umschalten +  Neustart +- +Zeit/Datum +  Einstellen +- +Systemzustand +  Sichern auf + Diskette +% FELD 1 "OP/1B" "bB" +% FELD 2 "OP/1D" "nN" +% FELD 3 "OP/1E" "eE" +% FELD 4 "OP/1S" "sS" +% ENDE +% MENUE "OPERATOR.Systemzustand" +% BILD +Übersicht +  Bereiche +  Speicher +- +Taskzustand +  Ein Bereich +  Alle Tasks +- +Arbeitsbereich +  Löschen +% FELD 1 "OP/2B" "bB" +% FELD 2 "OP/2S" "sS" +% FELD 3 "OP/2E" "eE" +% FELD 4 "OP/2A" "aA" +% FELD 5 "OP/2L" "lL" +% ENDE +% MENUE "OPERATOR.Drucker" +% BILD +Druckertreiber +  Starten +  Abbrechen +  Halten +- +Aufträge +  Übersicht +  Vorziehen +  Löschen +- +Zieltreiber +  Einstellen +% FELD 1 "OP/3S" "sS" +% FELD 2 "OP/3A" "aA" +% FELD 3 "OP/3H" "hH" +% FELD 4 "OP/3U" "uUüÜ" +% FELD 5 "OP/3V" "vV" +% FELD 6 "OP/3L" "lL" +% FELD 7 "OP/3E" "eE" +% ENDE +% MENUE "OPERATOR.Netz" +% BILD +Netztreiber +  Starten +  Abbrechen +  Zustand +- +Übertragungen +  Übersicht +% FELD 1 "OP/4S" "sS" +% FELD 2 "OP/4A" "aA" +% FELD 3 "OP/4Z" "zZ" +% FELD 4 "OP/4U" "uUüÜ" +% ENDE +% MENUE "OPERATOR.Konfiguration" +% BILD +Konfigurieren +  Kanäle +- +Installieren +  Drucker +  Netz +  Anwendung +  Systemprog +% FELD 1 "OP/5K" "kK" +% FELD 2 "OP/5D" "dD" +% FELD 3 "OP/5N" "nN" +% FELD 4 "OP/5A" "aA" +% FELD 5 "OP/5S" "sS" +% ENDE +% HILFE "OP/Allgemein" +% SEITE 1 +MENÜBEDIENUNG +- +Das Menü dient zur Auswahl von Funktionen. Die Funktionen +sind durch einen vorangestellten Buchstaben gekennzeichnet. +Mit den Pfeiltasten können Sie die Markierung zu einer be­ +liebigen Position auf und ab bewegen. Diese Funktion können +Sie dann durch Drücken der Leertaste ausführen. Durch ESC '?' +(nachein-ander gedrückt) erhalten Sie Informationen zur +gerade markierten Funktion. +Funktionen, die im momentanen Zustand nicht ausgeführt werden +können, sind durch ein Minuszeichen gekennzeichnet. +In der obersten Bildschirmzeile sind weitere Menüs aufge­ +führt, die Sie aufrufen können. Das aktuelle Menü ist invers +markiert. Ein anderes Menü wählen Sie durch Drücken der +Pfeiltasten RECHTS oder LINKS. Wollen Sie das Programm wieder +verlassen, drücken Sie die ESC-Taste und 'q' hintereinander. +% ENDE +% HILFE "GET/Allgemein" +% SEITE 1 +EINGABE: +- +Die Eingabe erwartet von Ihnen eine bestimmte Information, +die Sie eingeben sollen. Die Art der Information wird durch +den Anforderungstext angegeben. Wenn Sie sich beim Eintippen +verschrieben haben, können Sie mit den Pfeiltasten zurück­ +gehen und den Text korrigieren. Eine bereits dastehende +Information können Sie überschreiben. RUBOUT löscht ein +Zeichen, RUBIN schaltet in den Einfügemodus (Zeichen werden +nicht mehr überschrieben). Beenden Sie die Eingabe mit +RETURN. ESC 'h' bricht die Eingabe und die folgende Funktion +ab. Wenn in der Statuszeile angegeben, können Sie mit ESC 'z' +eine Auswahl verfügbarer Namen abrufen, die Sie dann Ankreu­ +zen können. +% ENDE +% HILFE "FEHLER/Allgemein" +% SEITE 1 +FEHLERMELDUNGEN: +- +Fehlermeldungen werden von einem Programm abgesetzt, wenn es +seine Funktion nicht durchführen kann. Der Text der Meldung +identifiziert die Ursache des Problems. Zur Zeit liegen noch +keine meldungsspezifischen Informationen vor, schauen Sie +ggf. in das Benutzerhandbuch. +% ENDE +% HILFE "JA/Allgemein" +% SEITE 1 +FRAGEN: +- +Das Programm stellt Ihnen eine Frage, die Sie bejahen oder +verneinen können. Sie bejahen die Frage, indem Sie 'j' drük­ +ken und verneinen Sie mit 'n' (beides groß oder klein). Mit +ESC 'h' können Sie die Funktion abbrechen. +% ENDE +% HILFE "OP/1B" +% SEITE 1 +Arbeit Beenden +- +Führt 'shutup' aus. Nach dem Neustart wird das Operatormenü +automatisch verlassen und die Arbeit im letzten Bereich +wieder aufgenommen. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/1D" +% SEITE 1 +Umschalten nach DOS +- +Macht 'shutup' mit gleichzeitigem Neustart einer +DOS-Partition. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/1E" +% SEITE 1 +Zeit/Datum einstellen +- +Aufruf von 'set date'. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/1S" +% SEITE 1 +Sichern auf Diskette +- +Aufruf von 'save system'. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/2B" +% SEITE 1 +Übersicht Bereiche +- +Aufruf von 'task info'. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/2S" +% SEITE 1 +Übersicht Speicher +- +wie 'storage info'. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/2E" +% SEITE 1 +Taskzustand einer Task +- +'task status' einer Task. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/2A" +% SEITE 1 +Taskzustand aller Tasks +- +'task info (3)'. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/2L" +% SEITE 1 +Arbeitsbereich löschen +- +'end' +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3S" +% SEITE 1 +Druckertreiber starten +- +'start' für die angezeigte Druckertask. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3A" +% SEITE 1 +Druckertreiber abbrechen +- +'stop' für die angezeigte Druckertask +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3H" +% SEITE 1 +Druckertreiber anhalten +- +'halt' bzw. 'wait for halt' für die angezeigte Druckertask. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3U" +% SEITE 1 +Aufträge Übersicht +- +Übersicht über die Warteschlange der angezeigten +Druckertask. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3V" +% SEITE 1 +Auftrag Vorziehen +- +'first' +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3L" +% SEITE 1 +Auftrag Löschen +- +'killer' +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/3E" +% SEITE 1 +Zieltreiber einstellen +- +Angabe der Spooltask, die mit den Kommandos dieses Menüs +gesteuert werden soll. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/4S" +% SEITE 1 +Netztreiber starten +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/4A" +% SEITE 1 +Netztreiber Abbrechen +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/4Z" +% SEITE 1 +Zustand des Netztreibers +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/4U" +% SEITE 1 +Übersicht der laufenden Übertragungen +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/5K" +% SEITE 1 +Kanäle Konfigurieren +- +'configurate', ohne "configurator" zu betreten. +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/5D" +% SEITE 1 +Drucker Installieren +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/5N" +% SEITE 1 +Netz Installieren +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/5A" +% SEITE 1 +Anwendungsprogramm Installieren +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "OP/5S" +% SEITE 1 +Systemprogramm Installieren +- +% SEITE 1 "OP/Allgemein" +% ENDE +% HILFE "GET/neuer taskname" +% SEITE 1 +Name des gewünschten Arbeitsbereichs +- +Geben Sie den Namen des Arbeitsbereichs an, in dem Sie +arbeiten wollen. Falls der Bereich noch nicht existiert, +kann er eingerichtet werden. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/name vatertask" +% SEITE 1 +Name des Vaterbereichs +- +Ein neuer Arbeitsbereich muß unterhalb eines existierenden +Bereichs eingerichtet werden, der die zur Verfügung +stehenden Programme festlegt. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/Taskname" +% SEITE 1 +Name des Arbeitsbereichs +- +Geben Sie den Namen des Arbeitsbereichs ein, dessen Status +Sie erfahren wollen. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "GET/neuer printer" +% SEITE 1 +Name der Druckertask +- +Geben Sie den Namen des Bereichs an, der durch die Befehle +dieses menüs gesteuert werden kann. +% SEITE 1 "GET/Allgemein" +% ENDE +% HILFE "JA/ganz" +% SEITE 1 +Ganz abkoppeln ? +- +Wenn Sie keinen neuen Arbeitsbereich wollen oder spezielle +Arbeitsbereiche betreten wollen, können Sie sich jetzt +abkoppeln. Sie müssen dann mit SV fortfahren. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/task einrichten" +% SEITE 1 +Arbeitsbereich existiert nicht. Neu einrichten ? +- +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/trotz shutup" +% SEITE 1 +Nicht auf Kanal 1. +- +Wenn Sie nicht auf Kanal 1 abschalten, meldet sich das +System später auch wieder auf dem jetzigen Kanal. Das kann +Sie dann irritieren. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/Task loeschen" +% SEITE 1 +Arbeitsbereich wirklich löschen +- +Zur Kontrolle. +% SEITE 1 "JA/Allgemein" +% ENDE +% HILFE "JA/halt warten" +% SEITE 1 +Auf Anhalten warten ? +- +Wenn Sie die Frage bejahen, wartet das Programm bis zur +Abarbeitung des aktuellen Druckauftrags. +% SEITE 1 "JA/Allgemein" +% ENDE + diff --git a/app/flint/0.4/src/operator.manager b/app/flint/0.4/src/operator.manager new file mode 100644 index 0000000..fc9c31a --- /dev/null +++ b/app/flint/0.4/src/operator.manager @@ -0,0 +1,34 @@ +PACKET operator manager (* Autor: Thomas Berlage *) + (* Stand: 14.01.88 *) + DEFINES + + operator manager, + continue : + + +LET + only privileged = + "Nur für Systemtasks zugelassen"; + + +PROC operator manager (DATASPACE VAR ds, INT CONST order, phase, + TASK CONST order task) : + + enable stop; + IF order task = supervisor OR order task < supervisor THEN + menue manager (ds, order, phase, order task) + ELSE + errorstop (only privileged) + END IF + +END PROC operator manager; + +PROC continue (TASK CONST t) : + + continue (t, + PROC (DATASPACE VAR, INT CONST, INT CONST, TASK CONST) operator manager) + +END PROC continue; + +END PACKET operator manager; + diff --git a/app/flint/0.4/src/operator.spoolcmd b/app/flint/0.4/src/operator.spoolcmd new file mode 100644 index 0000000..921f1e3 --- /dev/null +++ b/app/flint/0.4/src/operator.spoolcmd @@ -0,0 +1,113 @@ +PACKET spool cmd (* Autor: R. Ruland *) + (* Stand: 01.04.86 *) + DEFINES killer, (* Be 14.01.88 *) + first, (* Umstellung Menue *) + start, + stop, + halt, + wait for halt : + +LET error nak = 2 , + + entry line code = 23 , + killer code = 24 , + first code = 25 , + start code = 26 , + stop code = 27 , + halt code = 28 , + wait for halt code = 29 ; + +DATASPACE VAR ds; + +BOUND STRUCT (TEXT entry line, INT index) VAR control msg; +BOUND TEXT VAR error msg ; + +INT VAR reply; + +INITFLAG VAR in this task := FALSE; + + +PROC control spool (TASK CONST spool, INT CONST control code, + TEXT CONST question, BOOL CONST leave) : + + enable stop; + initialize control msg; + WHILE valid spool entry + REP IF control question THEN control spool entry FI PER; + + . initialize control msg : + IF NOT initialized (in this task) THEN ds := nilspace FI; + forget (ds); ds := nilspace; control msg := ds; + control msg. entry line := ""; + control msg. index := 0; + (* say (""13""10"");*) + + . valid spool entry : + call (spool, entry line code, ds, reply); + IF reply = error nak + THEN error msg := ds; + errorstop (error msg); + FI; + control msg. index <> 0 + + . control question : + (* say (control msg. entry line); + yes (question) *) + ja (control msg. entry line + question, "JA/spool control", leave) + + . control spool entry : + call (spool, control code, ds, reply); + IF reply = error nak + THEN error msg := ds; + errorstop (error msg); + FI; + IF leave THEN LEAVE control spool FI; + +END PROC control spool; + + +PROC killer (TASK CONST spool) : + + control spool (spool, killer code, " loeschen", FALSE) + +END PROC killer; + + +PROC first (TASK CONST spool) : + + control spool (spool, first code, " als erstes", TRUE) + +END PROC first; + + +PROC start (TASK CONST spool) : + + call (stop code, "", spool); + call (start code, "", spool); + +END PROC start; + + +PROC stop (TASK CONST spool) : + + call (stop code, "", spool); + +END PROC stop; + + +PROC halt (TASK CONST spool) : + + call (halt code, "", spool); + +END PROC halt; + + +PROC wait for halt (TASK CONST spool) : + + call (wait for halt code, "", spool); + +END PROC wait for halt; + + +END PACKET spool cmd; + -- cgit v1.2.3