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 --- doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil8 | 1345 ++++++++++++++++++++++++ 1 file changed, 1345 insertions(+) create mode 100644 doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil8 (limited to 'doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil8') diff --git a/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil8 b/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil8 new file mode 100644 index 0000000..16e4d07 --- /dev/null +++ b/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil8 @@ -0,0 +1,1345 @@ + EUMEL-Benutzerhandbuch + + TEIL 8: Standardpakete + + +1. Übersicht + +Hier werden die im EUMEL-System verfügbaren Prozeduren und Operatoren aufge- +führt, die nicht bereits in anderen Teilen des Benutzerhandbuchs beschrieben +wurden. + +Die meisten der hier beschriebenen Objekte werden nicht vom ELAN-Compiler, +sondern von vorübersetzten Moduln (PACKETs) realisiert (vergl. dazu auch den +Quellcode). Die in diesem Teil beschriebenen Prozeduren und Operatoren +weisen einige wenige Modifikationen, aber beträchtliche Erweiterungen gegen- +über dem Standard auf, um sie für die Zwecke des EUMEL-Systems anzupassen. +Hier werden nur diejenigen Objekte aufgeführt, die bei einer System-Aus- +lieferung dem EUMEL-System beigefügt sind. Jeder Installation ist es frei- +gestellt, diesen "EUMEL-Standard" zu erweitern oder zu modifizieren. + +Die Operationen des EUMEL-Standards lassen sich in verschiedene Klassen - +je nach Aufgabenbereich - ordnen. + + + +Ein-/Ausgabe + +Die Ein-/Ausgabe erfolgt im EUMEL-System in der Regel auf dem Terminal des +Benutzers. Sie kann aber auch in einen File umgeleitet werden. + +Die Ein-/Ausgabe eines Programms erfolgt in der Regel auf dem Terminal des +Benutzers, welches einem Prozeß zugeordnet ist. Die Eingabe vom Bildschirm +kann man mit den Prozeduren + + get + +programmieren, welche INT, REAL und TEXT-Werte einlesen. Bei der Eingabe +kann der Eingabetext editiert werden (Zeichen löschen, einfügen, über- +schreiben oder Lernsequenzen abrufen). Die Ausgabe erfolgt mit den Proze- +duren + + put + +(für INT-, REAL- und TEXT-Werte). Von den 'put'-Prozeduren wird ein Leer- +zeichen an eine Ausgabe angefügt, um diese von der vorhergehenden zu trennen. +Zusätzlich existiert die + + write + +Prozedur, welche an die Ausgabe kein Leerzeichen anfügt. Mit + + line + +kann man eine Positionierung auf eine neue Zeile bei der Ein-/Ausgabe er- +wirken. Mit + + getline + putline + +kann eine ganze Zeile eingelesen bzw. ausgegeben werden. + +Wie bereits erwähnt, erfolgt die Ein-/Ausgabe in der Regel auf dem Terminal +des Benutzers. Es ist jedoch möglich, die Ein-/Ausgabe dieser Prozeduren +"umzuleiten". Diese Umleitung erfolgt in eine oder von einer Datei. Dazu +gibt es die Prozeduren + + online (* liefert TRUE, wenn die Task an ein Terminal + gekoppelt ist *) + sysout ("name") (* Ausgabe erfolgt in die Datei 'name'. 'sysout + ("")' schaltet auf das Terminal zurück *) + sysout (* Liefert den Namen der eingestellten 'sysout'- + Datei. Wird "" geliefert, ist man an ein + Terminal gekoppelt *) + sysin ("name") (* Umschaltung der Eingabe vom Terminal auf die + Datei 'name'. sysin ("")' schaltet auf das + Terminal zurück *) + sysin (* Liefert den Namen der eingestellten 'sysin'- + Datei. Wird "" geliefert, ist man an ein + Terminal gekoppelt *) + +Wie bereits erwähnt, ist die Umschaltung nur für die Prozeduren 'get' und +'put'/'write', sowie 'getline' und 'putline' und die Prozedur 'line' möglich. +(Die folgenden Prozeduren haben immer eine Wirkung auf das Benutzer- +Terminal). Die Prozedur + + out + +schreibt wie 'write' einen Text auf den Bildschirm (läßt sich aber nicht +"umleiten"). + + cout + +schreibt einen INT-Wert an die aktuelle Cursor-Position auf den Bildschirm +und positioniert anschließend auf diese Position wieder zurück. Diese +Prozedur wird vorwiegend für Kontroll-Ausgaben (z.B. Zeilennummern) benutzt. +Ist die Task nicht angekoppelt, geht die Ausgabe ins "Leere"; das Programm +der Task läuft also weiter (im Gegensatz zu 'put' auf den Bildschirm). Mit +der Prozedur + + cursor + +kann - neben der Möglichkeit des Arbeitens mit Steuerzeichen - auf eine +bestimmte Position des Bildschirms positioniert werden. Mit + + get cursor + +kann die aktuelle Position des Cursors auf dem Terminal des Benutzers er- +fragt werden. Mit Hilfe der Prozedur + + inchar + +kann ein Zeichen vom Bildschirm gelesen werden. Der Prozeß wartet solange, +bis ein Zeichen eingegeben wird. Dagegen wird bei + + incharety + +niltext geliefert, wenn kein Zeichen eingegeben wurde. Eine weitere 'inchare- +ty'-Prozedur wartet zusätzlich noch eine angebbare Zeitdauer, ob ein Zeichen +eingegeben wird. Der Operator + + TIMESOUT + +stellt einen TEXT mehrfach auf dem Bildschirm dar. Die Prozedur + + page + +positioniert auf einen "neuen Bildschirm": der Bildschirm wird gelöscht und +der Cursor befindet sich anschließend in der linken oberen Ecke des Bild- +schirms. + + + +Manipulation von Texten + +Ein Text kann im EUMEL-System bis zu 32 000 Zeichen haben. Für TEXTe +stehen neben der Zuweisung die Vergleichsoperatoren + + = , < , <= , > , >= , <> + +zur Verfügung. Dabei ist die lexikographische Reihenfolge der Zeichen (vergl. +EUMEL-Zeichensatz) zu beachten. Zur Verkettung zweier TEXTe ist der + + + + +Operator vorhanden. Der Operator + + * + +nimmt eine Vervielfachung eines TEXTes vor. Der Operator + + CAT + +konkateniert den linken mit dem rechten Operanden und weist das Resultat dem +linken Operanden zu. Die Prozeduren + + pos + +liefern die Position des ersten Auftretens eines TEXTes oder einer +Zeichenklasse in einem anderen TEXT. Die Prozeduren + + code + +konvertieren ein Zeichen in einen INT-Wert und umgekehrt (vergl. dazu den +EUMEL-Zeichensatz) und dienen z.B. zur Behandlung von Zeichen, die nicht +auf einer Tastatur zu finden sind. Die Prozedur + + compress + +schneidet führende und nachfolgende Leerzeichen eines TEXTs ab, während + + delete char (* ein Zeichen loeschen *) + insert char (* ein Zeichen einfuegen *) + +ein Zeichen einfügt bzw. löscht. Mit + + change + +kann bei dem erstmaligen Auftreten eines Teiltextes in einem TEXT dieser +ersetzt werden. Mit + + change all + +kann jedesmal, wenn ein Teiltext in einem TEXT auftritt, dieser durch einen +anderen Text ersetzt werden. + + LENGTH (* oder *) + length + +liefert die Länge (d.h. die Anzahl der Zeichen in einem TEXT einschließlich +der Leerzeichen) eines TEXTes. Mit + + replace + +kann eine Ersetzung eines Teiltextes erzielt werden. Im Gegensatz zu +'replace' kann sich bei 'change' die Länge des Textes ändern. Mit + + SUB + subtext + +kann ein Zeichen ('SUB') oder ein Teiltext ('subtext') aus einem Text geholt +werden. + +TEXTe werden im EUMEL-System über einen Heap realisiert, d.h. nicht wie +andere Objekte auf einem Stack. Das hat u.a. zur Folge, daß TEXT-"Leichen" +auf dem Heap nicht automatisch beseitigt werden. Darum kann der benötigte +Speicherplatz durch TEXT-Operationen anwachsen. Der Heap kann nun von +unnötigem Speicherplatz durch die Prozedur + + collect heap garbage + +bereinigt werden. Die Größe des Heaps (in KB) kann durch die Prozedur + + heap size + +erfragt werden. Übrigens überprüft der Standard-Monitor nach jedem Kommando +die Heap-Größe und veranlaßt eine Bereinigung des Heaps, wenn dieser um +mindestens 4 KB gewachsen ist. + + + +Mathematische Operationen + +Folgende mathematische Prozeduren bzw. Operatoren stehen im EUMEL zur Zeit +zur Verfügung (manche Prozeduren stehen in mehr als einer Version zur +Verfügung, z.B. die sin-Prozedur für Radiant und Winkelgrad): + + ** (* Exponentiation *) + abs (* Absolutbetrag *) + arctan (* Arcus Tangens-Funktion *) + cos (* Kosinus-Funktion *) + e (* Eulersche Zahl (2.718282) *) + pi (* Die Zahl pi (3.141593) *) + exp (* Exponential-Funktion *) + floor (* REAL mit abgeschnittenen Nachkommastellen *) + frac (* Nachkommastellen eines REALs *) + random, + initialize random (* Zufallszahlen *) + ln, log2, log10 (* Logarithmus-Funktionen *) + max, min (* Minimum bzw. Maximum zweier Werte *) + MOD (* Modulo-Funktion *) + round (* Rundung *) + sign (* Vorzeichen feststellen *) + sin (* Sinus-Funktion *) + sqrt (* Wurzel-Funktion *) + tan (* Tangens-Funktion *) + + + +Konvertierungs-Operationen + +Mit den Prozeduren + + text + +kann aus einem INT- bzw. REAL-Wert ein TEXT, während mit + + int + +aus einem REAL- bzw. TEXT-Wert ein INT und mit + + real + +aus einem INT- bzw. TEXT-Wert ein REAL gemacht werden kann. Mit + + last conversion ok + +kann abgefragt werden, ob die letzte Umwandlung ohne Fehler bzw. fehlerhaft +vorgenommen wurde. Mit + + decimal exponent + +kann der Exponent eines REAL-Wertes ausgeblendet werden. + + + +Kommando-Dialog + +Die Prozeduren für den Kommando-Dialog dienen zur bequemen Programmierung +von interaktiven Anfragen an einen Benutzer eines Programms. (Diese +Prozeduren werden u.a. auch vom Monitor verwendet). Der Kommando-Dialog +ist im Normalfall eingeschaltet. Mit der Prozedur + + command dialogue + +kann man den Kommando-Dialog ein- bzw. ausschalten. Mit der Prozedur + + say + +kann - sofern der Kommando-Dialog eingeschaltet ist - ein Text auf dem +Bildschirm ausgegeben werden. Sofern der Kommando-Dialog eingeschaltet ist, +schreibt die Prozedur + + yes + +einen Text auf den Bildschirm des Benutzers. An den Text wird '(j/n) ?' +angefügt. Die Prozedur 'yes' liefert den Wert TRUE, sofern der Benutzer auf +die Frage mit dem Zeichen "j" antwortet und den Wert FALSE, sofern die +Antwort "n" lautete. Die Prozedur + + no + +arbeitet wie 'NOT yes'. + + + +Verschiedenes + +Mit den Prozeduren + + stop + errorstop + +kann ein Abbruch (letztere mit Meldung; vergl. Fehlerbehandlung im System- +handbuch) erreicht werden. Die Prozedur + + clock + +liefert Zeitwerte als REAL-Wert, nämlich die verbrauchte CPU-Zeit einer Task +oder die aktuelle Uhrzeit (inklusive Datum). Die Prozedur + + time of day + +liefert die aktuelle Uhrzeit. Mit den Konvertierungsprozeduren + + date + time + +können die Werte der Prozedur 'clock' in eine lesbare Form gebracht werden. +Mit der Prozedur + + pause + +kann eine bestimmte Zeitdauer gewartet werden, ohne den Prozessor zu be- +lasten. Die Wartezeit wird abgebrochen, wenn die Zeitgrenze erreicht ist +oder sobald ein Zeichen am Terminal des Benutzers eingegeben wurde. Dieses +Zeichen wird nicht verarbeitet. + + + +2. Die EUMEL-Standardpakete + +Die elementaren Datentypen BOOL, INT, REAL, TEXT und die entsprechenden Zu- +weisungsoperatoren werden hier nicht angegeben. + += + BOOL OP = (INT CONST a, b) + Zweck: Vergleich. + + BOOL OP = (REAL CONST a, b) + Zweck: Vergleich. + + BOOL OP = (TEXT CONST left, right) + Zweck: Vergleich von zwei Texten auf Gleichheit (Texte mit ungleichen + Längen sind immer ungleich). + +< + BOOL OP < (INT CONST a, b) + Zweck: Vergleich auf kleiner. + + BOOL OP < (REAL CONST a, b) + Zweck: Vergleich auf kleiner. + + BOOL OP < (TEXT CONST left, right) + Zweck: Vergleich zweier Texte auf kleiner ('left' kommt lexikographisch + vor 'right'). + +> + BOOL OP > (INT CONST a, b) + Zweck: Vergleich auf größer. + + BOOL OP > (REAL CONST a, b) + Zweck: Vergleich auf größer. + + BOOL OP > (TEXT CONST left, right) + Zweck: Vergleich zweier Texte auf größer ('left' kommt lexikographisch + nach 'right'). + +<= + BOOL OP <= (INT CONST a, b) + Zweck: Vergleich auf kleiner gleich. + + BOOL OP <= (REAL CONST a, b) + Zweck: Vergleich auf kleiner gleich. + + BOOL OP <= (TEXT CONST left, right) + Zweck: Vergleich von zwei Texten auf kleiner gleich ('left' kommt + lexikographisch vor oder ist gleich 'right'). + +>= + BOOL OP >= (INT CONST a, b) + Zweck: Vergleich auf größer gleich. + + BOOL OP >= (REAL CONST a, b) + Zweck: Vergleich auf größer gleich. + + BOOL OP >= (TEXT CONST left, right) + Zweck: Vergleich zweier Texte auf größer gleich ('left' kommt lexiko- + graphisch nach oder ist gleich 'right'). + +<> + BOOL OP <> (INT CONST a, b) + Zweck: Vergleich auf Ungleichheit. + + BOOL OP <> (REAL CONST a, b) + Zweck: Vergleich auf Ungleichheit. + + BOOL OP <> (TEXT CONST left, right) + Zweck: Vergleich von zwei Texten auf Ungleichheit (Texte mit ungleichen + Längen sind stets ungleich). + ++ + INT OP + (INT CONST a) + Zweck: Monadischer Operator (Vorzeichen, ohne Wirkung). + + REAL OP + (REAL CONST a) + Zweck: Monadischer Operator (Vorzeichen, ohne Wirkung). + + INT OP + (INT CONST a, b) + Zweck: Addition. + + REAL OP + (REAL CONST a, b) + Zweck: Addition. + + TEXT OP + (TEXT CONST left, right) + Zweck: Verkettung der Texte 'left' und 'right' in dieser Reihenfolge. Die + Länge des Resultats ergibt sich aus der Addition der Längen der + Operanden. + +- + INT OP - (INT CONST a) + Zweck: Vorzeichen-Umkehrung. + + REAL OP - (REAL CONST a) + Zweck: Vorzeichen-Umkehrung. + + INT OP - (INT CONST a, b) + Zweck: Subtraktion. + + REAL OP - (REAL CONST a, b) + Zweck: Subtraktion. + +* + INT OP * (INT CONST a, b) + Zweck: Multiplikation. + + REAL OP * (REAL CONST a, b) + Zweck: Multiplikation. + + TEXT OP * (INT CONST times, TEXT CONST source) + Zweck: 'times' fache Erstellung von 'source' und Verkettung. Dabei muß + + times >= 0 + + sein, sonst wird 'niltext' geliefert. + +/ + REAL OP / (REAL CONST a, b) + Zweck: Division. + Fehlerfall: + * Division durch 0 + +** + INT OP ** (INT CONST arg, exp) + Zweck: Exponentiation mit 'exp' >= 0 + Fehlerfälle: + * INT OP ** : negative exponent + Ein negativer Exponent ist nicht zugelassen. + * 0 ** 0 is not defined + 'arg' und 'exp' dürfen nicht beide 0 sein. + + REAL OP ** (REAL CONST arg, exp) + Zweck: Exponentiation. + Fehlerfälle: + * hoch mit negativer basis + Der 'exp' muß >= 0.0 sein. + * 0**0 geht nicht + 'arg' und 'exp' dürfen nicht gleichzeitig 0.0 sein. + + REAL OP ** (REAL CONST arg, INT CONST exp) + Zweck: Exponentiation. + Fehlerfall: + * 0.0 ** 0 geht nicht + +abs + INT PROC abs (INT CONST argument) + Zweck: Absolutbetrag eines INT-Wertes. + + INT OP ABS (INT CONST argument) + Zweck: Absolutbetrag eines INT-Wertes. + + REAL PROC abs (REAL CONST value) + Zweck: Absolutbetrag eines REAL-Wertes. + + REAL OP ABS (REAL CONST value) + Zweck: Absolutbetrag eines REAL-Wertes. + +AND + BOOL OP AND (BOOL CONST a, b) + Zweck: Logisches und. + +arctan + REAL PROC arctan (REAL CONST x) + Zweck: Arcus Tangens-Funktion. Liefert einen Wert in Radiant. + +arctand + REAL PROC arctand (REAL CONST x) + Zweck: Arcus Tangens-Funktion. Liefert einen Wert in Grad. + +CAT + OP CAT (TEXT VAR left, TEXT CONST right) + Zweck: Hat die gleiche Wirkung wie + + left := left + right + + Hinweis: Der Operator 'CAT' hat eine geringere Heap-Belastung als + die Operation mit expliziter Zuweisung. + +change + PROC change (TEXT VAR destination, TEXT CONST old, new) + Zweck: Ersetzung des (Teil-) TEXTes 'old' in 'destination' durch 'new' bei + dem erstmaligen Auftreten. Ist 'old' nicht in 'source' vorhanden, + so wird keine Meldung abgesetzt (Abweichung vom Standard). Beachte, + daß sich dabei die Länge von 'destination' verändern kann. + Beispiel: + + TEXT VAR mein text :: "EUMEL-Benutzerhandbuch"; + change (mein text, "Ben", "N"); (* EUMEL-Nutzerhandbuch *) + +PROC change (TEXT VAR destination, INT CONST from, to, TEXT CONST new) + Zweck: Der TEXT 'new' wird in den TEXT 'destination' anstatt des TEXTes, + der zwischen 'from' und 'to' steht, eingesetzt. Beachte, daß sich + dabei die Länge von 'destination' ändern kann. Beispiel: + + TEXT VAR mein text :: "EUMEL-Benutzerhandbuch"; + change (mein text, 7, 9, "N"); (* wie oben *) + +change all + PROC change all (TEXT VAR destination, TEXT CONST old, new) + Zweck: Der Teiltext 'old' wird durch 'new' in 'destination' ersetzt. Im + Unterschied zur 'change'-Prozedur findet die Ersetzung nicht nur + bei dem erstmaligen Auftreten von 'old' statt, sondern so oft, wie + 'old' in 'destination' vorhanden ist. Beispiel: + + + TEXT VAR x :: "Das ist ein Satz"; + change all (x, " ", ""); (* DasisteinSatz *) + +clock + REAL PROC clock (INT CONST index) + Zweck: Datum und Uhrzeit werden vom EUMEL-System für alle Tasks geführt. + Neben einer Uhr ('Realzeituhr'), die das Datum und die aktuelle + Uhrzeit enthält, wird eine Uhr für die von der Task verbrauchte + CPU-Zeit geführt ('CPU-Zeituhr'). Beide Zeiten werden vom System + als REALs realisiert. Die Prozedur 'clock' liefert die aktuellen + Werte dieser Uhren. Bei 'index = 0' wird die akkumulierte CPU-Zeit + der Task, bei 'index = 1' der Wert der Realzeituhr geliefert. + + Mit den REAL-Werten der Uhren kann ohne weiteres gerechnet werden, + jedoch sind nur Werte > 0 definiert. Die REAL-Werte der Realzeit- + uhr beginnen beim 1.1.1900 um 0 Uhr. Es sind nur Werte für dieses + Jahrhundert zugelassen. Werte der Realzeituhr in lesbarer Form + kann man durch die Konvertierungsprozeduren 'date' (für den + aktuellen Tag) und 'time of day' (Uhrzeit) erhalten. + + Um die benötigte CPU-Zeit eines Programms zu berechnen, muß man + die CPU-Zeituhr zweimal abfragen. Um solche Zeiten in lesbarer + Form zu erhalten, kann man die Konvertierungsprozedur 'time' + verwenden. Beispiel: + + REAL CONST anfang :: clock (0); + berechnungen; + REAL CONST ende :: clock (0); + put ("benoetigte CPU-Zeit:"); + put (time (ende - anfang)) + +code + TEXT PROC code (INT CONST code) + Zweck: Wandelt einen INT-Wert 'code' in ein Zeichen um. 'code' muß + + 1 <= code <= 254 + + sein. + + INT PROC code (TEXT CONST text) + Zweck: Wandelt ein Zeichen 'text' in einen INT-Wert um. Ist + + LENGTH text <> 1 + + dann wird der Wert -1 geliefert (also bei mehr als ein Zeichen + oder niltext). + +collect heap garbage + PROC collect heap garbage + Zweck: Bereinigung des Heaps von nicht mehr benötigten TEXTen. + +command dialogue + PROC command dialogue (BOOL CONST status) + Zweck: Ein- bzw. Ausschalten des Kommando-Dialogs. Ist der Kommando- + dialog eingeschaltet, dann funktionieren z.B. die Prozeduren 'yes' + bzw. 'no' und ein Aufruf der Prozedur 'errorstop' liefert eine + Fehlermeldung auf dem Terminal. Ist der Kommandodialog ausge- + schaltet, wird z.B. durch die Prozedur 'yes' kein Text ausgegeben + (es wird TRUE geliefert) und errorstop erzeugt keine Fehler- + meldungen. + + BOOL PROC command dialogue + Zweck: Liefert den Wert TRUE, wenn der Kommando-Dialog eingeschaltet + ist, andernfalls FALSE. + +compress + TEXT PROC compress (TEXT CONST text) + Zweck: Liefert den TEXT 'text' ohne führende und nachfolgende Leerzeichen. + +cos + REAL PROC cos (REAL CONST x) + Zweck: Kosinus-Funktion. 'x' muß in Radiant angegeben werden. + +cosd + REAL PROC cosd (REAL CONST x) + Zweck: Cosinus-Funktion. 'x' muß in Winkelgrad angegeben werden. + +cout + PROC cout (INT CONST number) + Zweck: Schreibt 'number' an die aktuelle Cursor-Position auf den Bild- + schirm. Anschließend wird an diese Position wieder zurück positio- + niert. 'number' muß > 0 sein. Paßt 'number' nicht mehr auf die + Zeile, so ist die Wirkung von 'cout' nicht definiert. 'cout' gibt + den Wert von 'number' nur aus, wenn genügend freie Kanal-Kapazität + für diese Ausgabe vorhanden ist. Das hat zur Folge, daß Programme + nicht auf die Beendigung einer Ausgabe von 'number' warten müssen + und ggf. Ausgaben überschlagen werden. + +cursor + PROC cursor (INT CONST column, row) + Zweck: Positioniert den Cursor auf dem Bildschirm, wobei 'column' die + Spalte und 'row' die Zeile angibt. Die zulässigen Bereiche von + 'column' und 'row' sind geräteabhängig. Zur Zeit gilt auf allen + EUMEL-Geräten + + 1 <= column <= 80 + 1 <= row <= 24 + +date + TEXT PROC date (REAL CONST time) + Zweck: Konvertierungsprozedur für das Datum, welches sich aus dem Aufruf + der Prozedur 'clock (1)' ergibt. Das Datum wird in der Form + 'tt.mm.jj' geliefert. Beispiel: + + put (date (clock (1))) (* z.B.: 24.12.82 *) + + + REAL PROC date (TEXT CONST datum) + Zweck: Konvertierungsprozedur für ein Datum in der Form 'tt.mm.jj'. + Liefert einen REAL-Wert, wie ihn die Prozedur 'clock (1)' liefern + würde. Beispiel: + + put (date ("24.12.82")) (* 6.270670e10 *) + + TEXT PROC date + Zweck: Liefert das Tagesdatum. Wirkt wie 'date (clock (1))', ist jedoch + erheblich schneller. + +day + REAL CONST day + Zweck: Liefert die Anzahl der Sekunden eines Tages (86 400.0). + +decimal exponent + INT PROC decimal exponent (REAL CONST mantisse) + Zweck: Liefert aus einem REAL-Wert den dezimalen Exponenten als INT-Wert. + +DECR + OP DECR (INT VAR left, INT CONST right) + Zweck: Wirkt wie left := left - right + + OP DECR (REAL VAR left, REAL CONST right) + Zweck: Wirkt wie left := left - right + +delete char + PROC delete char (TEXT VAR string, INT CONST delete pos) + Zweck: Löscht ein Zeichen aus dem Text 'string' an der Position 'delete + pos'. Für + + delete pos <= 0 + + oder + + delete pos > LENGTH string + + wird keine Aktion vorgenommen. + +DIV + INT OP DIV (INT CONST a, b) + Zweck: INT-Division. + Fehlerfall: + * DIV by 0 + Division durch Null. + +e + REAL CONST e + Zweck: Eulersche Zahl (2.718282). + +errorstop + PROC errorstop (TEXT CONST error message) + Zweck: Abbruch unter Ausgabe einer Fehlermeldung (vergl. Fehlerbehand- + lung). + +exp + REAL PROC exp (REAL CONST z) + Zweck: Exponentialfunktion. + +floor + REAL PROC floor (REAL CONST real) + Zweck: Schneidet die Nachkommastellen des REAL-Wertes 'real' ab. + +frac + REAL PROC frac (REAL CONST z) + Zweck: Liefert die Stellen eines REAL-Wertes hinter dem Dezimalpunkt. + +get + PROC get (INT VAR number) + Zweck: Einlesen eines INT-Wertes vom Bildschirm. Der einzulesende INT- + Wert kann bei der Eingabe vom Terminal editiert werden. Die + Eingabe kann vom Benutzer-Terminal so umgeleitet werden, daß sie + von einer Datei aus erfolgt (vergl. 'sysin'). + + PROC get (REAL VAR value) + Zweck: Einlesen eines REAL-Wertes vom Bildschirm. Der einzulesende + REAL-Wert kann bei der Eingabe vom Terminal editiert werden. Die + Eingabe kann vom Benutzer-Terminal so umgeleitet werden, daß sie + von einer Datei aus erfolgt (vergl. 'sysin'). + + PROC get (TEXT VAR word) + Zweck: Liest einen Text in die Variable 'word' mit maximal 255 Zeichen. + Es werden solange Zeichen vom Terminal gelesen, bis ein Leer- + zeichen oder ein Positionierungszeichen eingegeben wird. Dabei + werden führende Leerzeichen übergeben. Der einzulesende Text kann + bei der Eingabe editiert werden. Eine leere Eingabe ist nicht + erlaubt. Die Eingabe kann vom Benutzer-Terminal so umgeleitet + werden, daß sie von einer Datei aus erfolgt (vergl. 'sysin'). + + PROC get (TEXT VAR word, INT CONST laenge) + Zweck: Liest einen Text vom Bildschirm mit der Länge 'laenge' oder bis + ein Positionierungszeichen angetroffen wird. Der einzulesende Wert + kann bei der Eingabe editiert werden. Dabei gilt: + + 1 <= laenge <= 255 + + PROC get (TEXT VAR word, TEXT CONST separator) + Zweck: Liest einen Text vom Bildschirm, bis ein Zeichen 'separator' ange- + troffen oder ein Positionierungszeichen eingegeben wird. Der ein- + zulesende Text kann bei der Eingabe editiert werden. + +get cursor + PROC get cursor (INT VAR x, y) + Zweck: Erfragung der aktuellen Cursor-Position. Die Koordinaten des Cur- + sors werden in 'x' und 'y' geliefert. Die aktuelle Cursor-Position + ist nach Ausgabe von 'HOME' (Code = 1) oder einer Positionierung + des Cursors mit der Prozedur 'cursor' stets definiert. Die Proze- + dur 'get cursor' liefert jedoch undefinierte Werte, wenn über den + rechten Rand einer Zeile hinausgeschrieben wurde (die Wirkung + einer solchen Operation hängt von der Hardware eines Terminals ab). + +getline + PROC get line (TEXT VAR line) + Zweck: Das System wartet auf eine Zeile vom Bildschirm (max. 255 Zeichen). + Eine leere Eingabe ist nicht möglich. Die Eingabe kann vom Benut- + zer-Terminal so umgeleitet werden, daß sie von einer Datei aus + erfolgt (vergl. 'sysin'). + +heap size + INT PROC heap size + Zweck: Informationsprozedur für die Größe (in KB) des TEXT-Heaps. + +hour + REAL CONST hour + Zweck: Liefert die Anzahl der Sekunden einer Stunde (3600.0). + +inchar + PROC inchar (TEXT VAR character) + Zweck: Wartet solange, bis ein Zeichen von der Tastatur eingegeben wird, + und schreibt dieses Zeichen in die Variable 'character'. + +incharety + TEXT PROC incharety + Zweck: Versucht, ein Zeichen von der Tastatur zu lesen. Wurde kein + Zeichen eingegeben, wird niltext geliefert. + + TEXT PROC incharety (INT CONST time limit) + Zweck: Versucht, ein Zeichen vom Bildschirm zu lesen. Dabei wird maximal + eine 'time limit' lange Zeit auf das Zeichen gewartet (gemessen in + Zehntel-Sekunden). + +INCR + OP INCR (INT VAR left, INT CONST right) + Zweck: Wirkt wie left := left + right + + OP INCR (REAL VAR left, REAL CONST right) + Zweck: Wirkt wie left := left + right + +initialize random + PROC initialize random (INT CONST value) + Zweck: Initialisieren der 'random'-Prozedur, um nicht reproduzierbare + Zufallszahlen zu bekommen. Diese 'init random'-Prozedur gilt für + den "INT-Random Generator". + + PROC initialize random (REAL CONST z) + Zweck: Initialisieren der 'random'-Prozedur mit verschiedenen Werten für + 'z', um nicht reproduzierbare Zufallszahlen zu bekommen. Diese + Prozedur gilt für den "REAL-Random Generator". + +insert char + PROC insert char (TEXT VAR string, TEXT CONST char, INT CONST insert pos) + Zweck: Fügt ein Zeichen 'char' in den Text 'string' an der Position + 'insert pos' ein. Für + + insert pos > LENGTH string + 1 + + wird keine Aktion vorgenommen. Daher ist es möglich, mit dieser + Prozedur auch am Ende eines Textes (Position: LENGTH string + 1) + ein Zeichen anzufügen. + +int + INT PROC int (REAL CONST a) + Zweck: Konvertierungsprozedur. + + INT PROC int (TEXT CONST number) + Zweck: Umwandlung eines Textes in einen INT-Wert. Der Text 'number' darf + ein "+"- oder "-"-Zeichen vor den Ziffern enthalten. Führende + Blanks werden überlesen. Enthält 'number' an einer Position ein + Zeichen, das nicht umgewandelt werden kann, so wird die Umwand- + lung gestoppt und der bis dahin umgewandelte Wert (bzw. der Wert 0) + geliefert. + +last conversion ok + BOOL PROC last conversion ok + Zweck: Liefert den Wert TRUE, sofern die letzte Konvertierungsprozedur + nicht auf einen Fehler bei der Umwandlung gestoßen ist, andernfalls + FALSE. + +length + INT PROC length (TEXT CONST text) + Zweck: Anzahl von Zeichen ("Länge") von 'text' einschließlich Leerzeichen. + +LENGTH + INT OP LENGTH (TEXT CONST text) + Zweck: Anzahl von Zeichen ("Länge") von 'text' einschließlich Leerzeichen. + +line + PROC line + Zweck: Es wird zum Anfang einer neuen Zeile positioniert. + + PROC line (INT CONST number) + Zweck: Es werden 'number' Zeilenwechsel vorgenommen. + +ln + REAL PROC ln (REAL CONST x) + Zweck: Natürlicher Logarithmus. + Fehlerfall: + * ln mit nicht positiver Zahl + Nur echt positive Argumente sind zulässig. + +log2 + REAL PROC log2 (REAL CONST z) + Zweck: Logarithmus zur Basis 2. + Fehlerfall: + * log2 mit negativer zahl + Nur echt positive Argumente sind zulässig. + +log10 + REAL PROC log10 (REAL CONST x) + Zweck: Logarithmus zur Basis 10. + Fehlerfall: + * log10 mit negativer zahl + Nur echt positive Argumente sind zulässig. + +max + INT PROC max (INT CONST first, second) + Zweck: Liefert den Größten der beiden INT-Werte. + + REAL PROC max (REAL CONST first, second) + Zweck: Liefert den Größten der beiden REAL-Werte. + +maxint + INT CONST maxint + Zweck: Größter INT-Wert im EUMEL-System (32 767). + +maxreal + REAL CONST maxreal + Zweck: Größter REAL-Wert im EUMEL-System (9.999999999999e126). + +max text length + INT CONST max text length + Zweck: Maximale Anzahl von Zeichen in einem TEXT (32 000). + +min + INT PROC min (INT CONST first, second) + Zweck: Liefert den Kleinsten der beiden INT-Werte. Beispiele: + + min (3.0, 2.0) ==> 2.0 + min (-2.0, 3.0) ==> -2.0 + + REAL PROC min (REAL CONST first, second) + Zweck: Liefert den Kleinsten der beiden REAL-Werte. + +MOD + INT OP MOD (INT CONST left, right) + Zweck: Liefert den Rest einer INT-Division. Beispiele: + + 3 MOD 2 ==> 1 + -3 MOD 2 ==> 1 + + Fehlerfall: + * DIV by 0 + Division durch 0 ist verboten. + + REAL OP MOD (REAL CONST left, right) + Zweck: Modulo-Funktion für REALs (liefert den Rest). Beispiele: + + 5.0 MOD 2.0 ==> 1.0 + 4.5 MOD 4.0 ==> 0.5 + +no + BOOL PROC no (TEXT CONST question) + Zweck: Wirkt wie + + NOT yes + +NOT + BOOL OP NOT (BOOL CONST a) + Zweck: Logische Negation. + +online + BOOL PROC online + Zweck: Liefert TRUE, wenn die Task mit einem Terminal gekoppelt ist. + +OR + BOOL OP OR (BOOL CONST a, b) + Zweck: Logisches oder. + +out + PROC out (TEXT CONST text) + Zweck: Ausgabe eines Textes auf dem Bildschirm. Im Unterschied zu 'put' + wird kein Blank an den ausgegebenen Text angefügt. 'out' kann + nicht umgeleitet werden (vergl. 'sysout'). + +out subtext + PROC out subtext (TEXT CONST source, INT CONST from) + Zweck: Ausgabe eines Teiltextes von 'source' von der Position 'from' bis + Textende. Es wird keine Aktion vorgenommen für + + from > LENGTH source + + PROC out subtext (TEXT CONST source, INT CONST from, to) + Zweck: Ausgabe eines Teiltextes von 'source' von der Position 'from' bis + zur Position 'to'. Für + + to > LENGTH source + + wird für die fehlenden Zeichen Leerzeichen (blanks) ausgegeben. + +page + PROC page + Zweck: Es wird zum Anfang einer neuen Seite positioniert (hier: linke + obere Ecke des Bildschirms, wobei der Bildschirm gelöscht wird). + +pause + PROC pause (INT CONST time limit) + Zweck: Wartet 'time limit' in Zehntel-Sekunden. Bei negativen Werten ist + die Wirkung nicht definiert. Die Wartezeit wird nicht nur durch + das Erreichen der Grenze abgebrochen, sondern auch durch die + Eingabe eines beliebigen Zeichens. + +pi + REAL CONST pi + Zweck: Die Zahl pi (3.141593). + +pos + INT PROC pos (TEXT CONST source, pattern) + Zweck: Liefert die erste Position des ersten Zeichens von 'pattern' in + 'source', falls 'pattern' gefunden wird. Wird 'pattern' nicht + gefunden oder ist 'pattern' niltext, so wird der Wert '0' ge- + liefert. Beispiel: + + TEXT VAR t1 :: "abcdefghijk...xyz", + t2 :: "cd"; + ... pos (t1, t2) ... (* liefert 3 *) + ... pos (t2, t1) ... (* liefert 0 *) + + INT PROC pos (TEXT CONST source, pattern, INT CONST from) + Zweck: Wie obige Prozedur, jedoch wird erst ab der Position 'from' ab + gesucht. Dabei gilt folgende Einschränkung: + + length (pattern) < 255 + +INT PROC pos (TEXT CONST source, low char, high char, INT CONST from) + Zweck: Liefert die Position des ersten Zeichens 'x' in 'source' ab der + Position 'from', so daß + + low char <= x <= high char + + 'low char' und 'high char' müssen TEXTe der Länge 1 sein. Wird + kein Zeichen in 'source' in dem Bereich zwischen 'low char' und + 'high char' gefunden, wird der Wert '0' geliefert. Beispiel: + + (* Suche nach dem ersten Zeichen <> blank nach einer Leerspalte *) + TEXT VAR zeile :: "BlaBla Hier gehts weiter"; + INT VAR pos erstes blank :: pos (zeile, " "), + ende leerspalte :: pos (zeile, ""33"", ""254"", pos erstes blank); + +put + PROC put (INT CONST number) + Zweck: Ausgabe eines INT-Wertes auf dem Bildschirm. Anschließend wird + ein Leerzeichen ausgegeben. Die Ausgabe kann umgeleitet werden + (vergl. 'sysout'). + + PROC put (REAL CONST real) + Zweck: Ausgabe eines REAL-Wertes auf dem Bildschirm. Anschließend wird + ein Leerzeichen ausgegeben. Die Ausgabe kann umgeleitet werden + (vergl. 'sysout') + + PROC put (TEXT CONST text) + Zweck: Ausgabe eines Textes auf dem Bildschirm. Nach der Ausgabe von + 'text' wird ein Blank ausgegeben, um nachfolgenden Ausgaben auf + der gleichen Zeile voneinander zu trennen. Hardwareabhängig sind + die Aktionen, wenn eine Ausgabe über eine Zeilengrenze (hier: + Bildschirmzeile) vorgenommen wird. Meist wird die Ausgabe auf der + nächsten Zeile fortgesetzt. Die Ausgabe kann umgeleitet werden + (vergl. 'sysout'). + +putline + PROC putline (TEXT CONST text) + Zweck: Ausgabe von 'text' auf dem Bildschirm. Nach der Ausgabe wird auf + den Anfang der nächsten Zeile positioniert. Gibt man TEXTe nur mit + 'putline' aus, so ist gesichert, daß jede Ausgabe auf einer neuen + Zeile beginnt. Hardwareabhängig sind die Aktionen, wenn eine Aus- + gabe über eine Zeilengrenze (hier: Bildschirmzeile) vorgenommen + wird. Meist wird die Ausgabe auf der nächsten Zeile fortgesetzt. + Die Ausgabe kann umgeleitet werden (vergl. 'sysout'). + +random + INT PROC random (INT CONST lower bound, upper bound) + Zweck: Pseudo-Zufallszahlen-Generator im Intervall 'upper bound' und + 'lower bound' einschließlich. Es handelt sich hier um den "INT + Random Generator". + + REAL PROC random + Zweck: Pseudo-Zufallszahlen-Generator im Intervall 0 und 1. Es handelt + sich hier um den "REAL Random Generator". + +real + REAL PROC real (INT CONST a) + Zweck: Konvertierungsprozedur. + + REAL PROC real (TEXT CONST text) + Zweck: Konvertierung eines TEXTes 'text' in einen REAL-Wert. Achtung: Zur + Zeit werden keine Überprüfungen vorgenommen, d.h. in dem TEXT + muß ein REAL-Wert stehen. + +replace + PROC replace (TEXT VAR destination, INT CONST position, TEXT CONST source) + Zweck: Ersetzung eines Teiltextes in 'destination' durch 'source' an der + Position 'position' in 'destination'. Es muß gelten + + 1 <= position <= LENGTH destination + + d.h. 'position' muß innerhalb von 'destination' liegen und 'source' + muß von der Position 'position' ab in 'destination' einsetzbar + sein. Dabei bleibt die Länge von 'destination' unverändert. + +round + REAL PROC round (REAL CONST real, INT CONST digits) + Zweck: Runden eines REAL-Wertes auf 'digits' Stellen. Für positive Werte + wird auf Nachkommastellen gerundet. Beispiel: + + round (3.14159, 3) + + liefert '3.142'. Für negative 'digits'-Werte wird auf Vorkomma- + stellen gerundet. Beispiel: + + round (123.456, -2) + + liefert '100.0'. Abweichung vom Standard: Es wird mit 'digits'- + Ziffern gerundet. + +say + PROC say (TEXT CONST message) + Zweck: Sofern der Kommando-Dialog eingeschaltet ist (vergl. 'command + dialogue'), wird der TEXT 'message' an die augenblickliche Cursor- + Position geschrieben. + +sign + INT PROC sign (INT CONST argument) + Zweck: Feststellen des Vorzeichens eines INT-Wertes. Folgende Werte + werden geliefert: + + argument > 0 ==> 1 + argument = 0 ==> 0 + argument < 0 ==> -1 + + INT OP SIGN (INT CONST argument) + Zweck: Feststellen des Vorzeichens eines INT-Wertes. + + INT PROC sign (REAL CONST number) + Zweck: Feststellen des Vorzeichens eines REAL-Wertes. + + INT OP SIGN (REAL CONST number) + Zweck: Feststellen des Vorzeichens eines REAL-Wertes. + +sin + REAL PROC sin (REAL CONST x) + Zweck: Sinus-Funktion. 'x' muß in Radiant (Bogenmaß) angegeben werden. + +sind + REAL PROC sind (REAL CONST x) + Zweck: Sinus-Funktion. 'x' muß im Winkelgrad angegeben werden. + +smallreal + REAL PROC smallreal + Zweck: Kleinster darstellbarer REAL-Wert im EUMEL-System für den + + 1.0 - smallreal <> 1.0 + 1.0 + smallreal <> 1.0 + + gilt (1.0E-12). + +sqrt + REAL PROC sqrt (REAL CONST z) + Zweck: Wurzel-Funktion. + Fehlerfall: + * sqrt von negativer Zahl + Das Argument muß größer gleich 0.0 sein. + +stop + PROC stop + Zweck: Abbruch (vergl. Fehlerbehandlung). + +SUB + TEXT OP SUB (TEXT CONST text, INT CONST pos) + Zweck: Liefert ein Zeichen aus 'text' an der Position 'pos'. Entspricht + + subtext (text, pos, pos) + + Anmerkung: Effizienter als obiger Prozedur-Aufruf. Für + + pos <= 0 + pos > LENGTH text + + wird niltext geliefert. + +subtext + TEXT PROC subtext (TEXT CONST source, INT CONST from) + Zweck: Teiltext von 'source', der bei der Position 'from' anfängt. Die + Länge des Resultats ergibt sich also zu + + LENGTH source - from + 1 + + d.h. von der Position 'from' bis zum Ende von 'source'. 'from' muß + innerhalb von 'source' liegen. Ist from < 1, dann wird 'source' + geliefert. Falls from > LENGTH source ist, wird niltext geliefert. + + TEXT PROC subtext (TEXT CONST source, ITT CONST from, to) + Zweck: Teiltext von 'source' von der Position 'from' bis einschließlich + der Position 'to'. Die Länge des Resultats ist also + + from - to + 1 + + Dabei muß gelten + + 1 <= from <= to <= LENGTH source + + d.h. die Positionen 'from' und 'to' müssen in dieser Reihenfolge + innerhalb von 'source' liegen. Ist + + to >= LENGTH source + + wird 'subtext (source, from)' ausgeführt. Für die Bedingungen für + 'from' siehe vorstehende Beschreibung von 'subtext'. + +sysin + PROC sysin (TEXT CONST file name) + Zweck: Eingabe-Routinen ('get', 'getline' und 'line') lesen nicht mehr + vom Benutzer-Terminal, sondern aus der Datei 'file name'. + + TEXT PROC sysin + Zweck: Liefert den Namen der eingestellten 'sysin'-Datei. "" bezeichnet + das Benutzer-Terminal. + +sysout + PROC sysout (TEXT CONST file name) + Zweck: Ausgabe-Routinen ('put', 'putline', 'write', 'line') gehen nicht + mehr zum Benutzer-Terminal, sondern in die Datei 'file name'. + + TEXT PROC sysout + Zweck: Liefert den Namen der eingestellten 'sysout'-Datei. "" bezeichnet + das Benutzer-Terminal. + +tan + REAL PROC tan (REAL CONST x) + Zweck: Tangens-Funktion. 'x' muß in Radiant angegeben werden. + +tand + REAL PROC tand (REAL CONST x) + Zweck: Tangens-Funktion. 'x' muß in Winkelgrad angegeben werden. + +text + TEXT PROC text (INT CONST number) + Zweck: Umwandlung eines INT-Wertes in einen Text. Negative Werte werden + mit einem "-"-Zeichen geliefert. + + TEXT PROC text (INT CONST number, laenge) + Zweck: Umwandlung eines INT-Wertes 'number' in einen Text mit der Länge + 'laenge'. Für + + LENGTH (text (number)) < laenge + + werden die Ziffern rechtsbündig in einen Text mit der Länge + 'laenge' eingetragen. Fehlende Ziffern der gewünschten 'laenge' + werden im TEXT vorne mit Leerzeichen aufgefüllt. Für + + LENGTH (text (number)) > laenge + + wird ein Text mit der Länge 'laenge' geliefert, der mit + "*"-Zeichen gefüllt ist. + + TEXT PROC text (REAL CONST real) + Zweck: Konvertierung eines REAL-Wertes in einen TEXT. Ggf. wird der TEXT + in Exponenten-Darstellung geliefert. + + TEXT PROC text (REAL CONST real, laenge) + Zweck: Siehe oben. 'laenge' gibt die Anzahl von Zeichen an. + + TEXT PROC text (REAL CONST real, INT CONST laenge, fracs) + Zweck: Konvertierung eines REAL-Wertes in einen TEXT. Dabei gibt 'laenge' + die Länge des Resultats einschließlich des Dezimalpunktes und + 'fracs' die Anzahl der Dezimalstellen an. Kann der REAL-Wert nicht + wie gewünscht dargestellt werden, wird + + laenge * "*" + + geliefert. + + TEXT PROC text (TEXT CONST source, INT CONST laenge) + Zweck: Teiltext aus 'source' mit der Länge 'laenge', beginnend bei der + Position 1 von 'source'. Es muß gelten + + 1 <= laenge <= LENGTH source + + d.h. der gewünschte Teiltext muß aus 'source' ausblendbar sein. + Wenn + + laenge > LENGTH source + + die Länge des gewünschten Resultats ist größer als die Länge von + 'source' ist, wird der zu liefernde TEXT mit der an 'laenge' + fehlenden Zeichen mit Leerzeichen aufgefüllt. + + TEXT PROC text (TEXT CONST source, INT CONST laenge, from) + Zweck: Teiltext aus 'source' mit der Länge 'laenge', beginnend an der + Position 'from' in dem TEXT 'source'. Entspricht + + text (subtext (source, from, LENGTH source), laenge) + + Es muß + + laenge >= 0 + 1 <= from <= LENGTH source + + gelten, d.h. 'from' muß eine Position angeben, die innerhalb von + 'source' liegt. Für + + laenge > LENGTH source - from + 1 + + also wenn die angegebene Länge 'laenge' größer ist als der auszu- + blendende Text, wird das Resultat rechts mit Leerzeichen aufge- + füllt. Wenn + + laenge < LENGTH source - from + 1 + + d.h. wenn die angegebene Länge kleiner ist als der Teiltext von + 'from' bis zum letzten Zeichen von 'source', wird das Resultat mit + der Länge + + LENGTH source - from + 1 + + geliefert. + +time + TEXT PROC time (REAL CONST time) + Zweck: Konvertierungsprozedur für die Zeiten der CPU-Zeituhr. Liefert die + Zeiten in der Form 'hh:mm:ss.s'. Vergl. dazu 'clock'. + + TEXT PROC time (REAL CONST value, INT CONST laenge) + Zweck: Konvertiert die Zeit in externe Darstellung. Für die 'laenge'- + Werte ergibt sich: + + laenge = 10 (* hh:mm:ss.s *) + laenge = 12 (* hhh:mm:ss.s *) + +REAL PROC time (TEXT CONST time) + Zweck: Konvertierungsprozedur für Texte der CPU-Zeituhr in REAL-Werte. + +time of day + TEXT PROC time of day (REAL CONST time) + Zweck: Konvertierungsprozedur für REALs, wie sie die Realzeituhr + liefert. Es wird die Tageszeit in der Form 'hh:mm' geliefert. + Beispiel: + + put (time of day (clock (1))) (* z.B.: 17:25 *) + + + TEXT PROC time of day + Zweck: Liefert die aktuelle Tageszeit. Entspricht + + time of day (clock (1)) + +TIMESOUT + OP TIMESOUT (INT CONST times, TEXT CONST text) + Zweck: Ausgabe eines TEXTes 'text' 'times'mal. An die Ausgabe wird im + Gegensatz zu 'put' kein Leerzeichen angefügt. Es wird kein Text + ausgegeben für + + times < 1 + +write + PROC write (TEXT CONST text) + Zweck: Gibt 'text' ohne Trennblank aus ('put' mit Trennblank). Läßt sich + im Gegensatz zu 'out' in eine Datei umleiten (vergl. 'sysout'). + +XOR + BOOL OP XOR (BOOL CONST a, b) + Zweck: Exklusives oder. + +yes + BOOL PROC yes (TEXT CONST question) + Zweck: Sofern der Kommando-Dialog (vergl. 'command dialogue') einge- + schaltet ist, wird der TEXT 'question' auf dem Bildschirm des + Benutzers geschrieben. Der TEXT 'question' wird dabei mit einem + Fragezeichen ergänzt. Der Benutzer kann nun am Terminal mit den + Zeichen 'j' oder 'n' antworten (oder: 'J', 'N', 'y', 'n', 'Y', + 'N'). Nach Eingabe eines dieser Zeichen wird von der Prozedur + 'yes' auf eine neue Zeile positioniert. Die Prozedur 'yes' liefert + den Wert TRUE bei der Eingabe von 'j' und den Wert FALSE bei der + Eingabe von 'n'. Ist der Kommando-Dialog nicht eingeschaltet, + liefert die Prozedur 'yes' den Wert TRUE. + -- cgit v1.2.3