Turbo Toolbox

home *** CD-ROM | disk | FTP | other *** search

/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / read.me next >

Wrap

Text File | 1991-03-20 | 98.3 KB | 1,840 lines

ToolboX- Language ⌐████ ████ █████ █████ ███ ███ █ ⌐█ ¬░░░⌐█ ¬░░⌐█¬░⌐█ ¬░░░░░ ¬░░⌐█¬░░⌐█¬░░⌐█ ¬░⌐█¬░⌐█ ¬░ ⌐███ ⌐████ ⌐███ ⌐███ ¬░⌐█ ¬░⌐█████ ⌐█ ¬░ ¬░⌐█¬░⌐█ ¬░░░░⌐█ ¬░░░ ⌐█ ¬░░░ ⌐█ ¬░⌐█ ¬░░⌐█¬░⌐█ ¬░ ⌐████ ⌐█ ¬░ ⌐█████ ⌐█████ ⌐███¬░⌐█ ¬░ ⌐█ ⌐█████ ¬ ░░░░ ░ ░░░░░ ░░░░░ ░░░ ░ ░ ░░░░░ ⌐█ █ ███ ⌐█ █ █ █ █ █████ █ █ █ ⌐█ ¬░ ⌐█ █ ¬░⌐█¬░⌐█ ¬░ ⌐█¬░⌐█ ¬░ ⌐█¬░⌐█ ¬░ ⌐█¬░░░░ ⌐█¬░⌐█ ¬░⌐█ ¬░ ⌐█ ¬░ ⌐█ █ ¬░ ⌐█ ⌐█ ¬░ ⌐█¬░ ░ ⌐█¬░ ░ ⌐█ █ ¬░ ⌐█¬░ ░ ⌐█ ¬░ ⌐█¬░⌐█ █ ¬░ ⌐█ ⌐█ ¬░ ⌐█ ⌐█¬░ ⌐█ ⌐█¬░ ░ ⌐█ ¬░ ⌐█ █¬░ ⌐█ ¬░ ⌐█¬░ ░ ⌐███ ████ █ █ ¬░⌐█¬░ ⌐█ ¬░⌐█¬░ ⌐█ █ ¬░ ⌐█ ¬░⌐█¬░ ⌐████ ░ ░░░ ░░░░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░░░░ ,,0 ⌐0. INHALTSVERZEICHNIS ⌐═════════════════════ ⌐<0>¬..........Inhaltsverzeichnis ⌐<1>¬..........Bedienung des Readme-Programms ⌐<2>¬..........Schneller Einstieg in TXL ⌐<3>¬..........TXL für DOS: Der Editor ⌐<4>¬..........TXL für DOS: Die Befehle ⌐<5>¬..........Besonderheiten der Atari-ST Version von TXL ⌐<6>¬..........TXL unter Windows: Die Befehle ⌐<7>¬..........Eigene Befehle implementieren ⌐<8>¬..........Die Geschichte der ToolboX Language ⌐<9>¬..........Registrierung und Support für TXL ,,1 ⌐1. BEDIENUNG DES README-PROGRAMMS ⌐═════════════════════════════════ ⌐<Cursor hoch/runter>¬.........Eine Zeile nach oben/unten scrollen ⌐<Bild hoch/runter>¬...........Eine Seite nach oben/unten blättern ⌐<Pos1>, <Ende>¬...............Zum Anfang/Ende des Textes springen ⌐<Esc>¬........................Readme verlassen Außerdem können Sie alle Kapitel bequem über die in ⌐<¬ und ⌐>¬ einge- schlossenen Hotkeys anwählen, die im Inhaltsverzeichnis angegeben sind. ,,2 ⌐2. Schneller Einstieg in TXL ⌐════════════════════════════ Pascal, C oder auch Basic-Programmierern dürfte es nicht schwerfallen, einen schnellen Einstieg in die "ToolboX Language" zu bekommen. Schleifenfunktionen, Fenster-, Ein- und Ausgaberoutinen bieten eine Fülle von Möglichkeiten. Das an sich ist jedoch nicht die Besonderheit der TXL. TXL erlaubt es im Gegensatz zu herkömmlichen Interpreter-Sprachen auf einfache Weise, nicht vorhandene Befehle schnell und problemlos in C einzubinden. Der Leistungsfähigkeit der TXL sind somit keine Grenzen gesetzt. Aber auch schon im vorhandenen Befehlsumfang wird einiges geboten, sodaß man wahrscheinlich nur in Spezialfällen dazu gezwungen ist, wirklich neue Anweisungen hinzuzufügen. Zu beachten ist bei der Erstinstallation von TXL, daß der Sourcecode der DOS-Version (Diskette 3/3) als selbstentpackende Datei vorliegt. Vor dem Start ist also für ausreichend Platz auf Diskette oder Fest- platte zu sorgen. Durch das offene Konzept von TXL es möglich, sich die vorliegenden entsprechenden Befehlsnamen und Parameter so anzupassen, daß sie mit bisher bekannten und verwendeten Routinen und Bibliotheken übereinstimmen. Um die ersten Berührungsängste zu nehmen, sollte man sich über die Hilfe-Funktion (HILFE oder F1) und im On-Line Dialog (nur DOS- und Windows-Version) einen kleinen Überblick verschaffen. Eine Kurzübersicht aller aktuell implemetierter Befehle erhält man durch den Befehl "COMMANDS". Detaillierte Angaben sind dann jeweils über die Hilfefunktion zu finden. Die meisten Befehle lassen sich auch im Direktmodus ausführen, sodaß die Wirkung unmittelbar beobachtet werden kann. Der integrierte Editor ermöglicht weiterhin eine komfortable Programmentwicklung und das Starten von TXL-Programmen aus dem Editor heraus (CTRL-T). ,,3 ⌐3. TXL für DOS: Der Editor ⌐══════════════════════════ Das Editor-System ──────────────────────────────────────────────────────────────────────── Das Editorsystem für TXL erlaubt 10 Editoren, die gleichzeitig verschiedene Dateien bearbeiten können und eine Schnittstelle zu TXL besitzen, d.h. (fast) jede Editorfunktion kann durch einen TXL-Befehl simuliert werden. Da 50 Hotkeys für die Editoren in TXL auf Unterprogamme gelegt werden können (Alt/Shift/Ctrl-F1-F10, F1-F10, Alt0-Alt9), lassen sich so einafch MAKROS programmieren. Im Direktmodus bearbeitet "edit" das aktuelle Programm, speichert es am Ende unter "AKTUELL.TXL" und läd es in den Interpreter. "edit <file>" läd eine bestimmte Datei, die explizit gesichert werden muß (z.B. edit "Programm.TXL"). Editorbefehle beim Editieren ──────────────────────────────────────────────────────────────────────── Funktionsnr Hotkey 10 INS 11 DEL 12 Backspace 13 Return 14 Ctrl-Y Zeile löschen 15 Ctrl-Left Wort links 16 Ctrl-Right Wort rechts 17 Ctrl-B Blockbeginn setzen 18 Ctrl-E Blockende setzen 19 Ctrl-C Block kopieren 20 Ctrl-D Block löschend 21 Ctrl-V Block verschieben 22 Ctrl-R Block von Diskette lesen 24 Ctrl-W Block auf Diskette schreiben Editorbefehle beim Editieren ──────────────────────────────────────────────────────────────────────── Funktionsnr Hotkey 23 Ctrl-S Datei speichern 25 Home Cursor an Deteianfang 26 End Cursor an Textende 30 Alt-R Fenster mit Cursortasten in Größe ändern 31 Alt-M Fenster mit Cursortasten verschieben 32 Alt-Z Fenster zoomen, d.h. auf ganzen Bildschirm ausdehnen -- Ctrl-T Aufruf des Präprozessors 0 Eingabe eines Zeichens 1,2,3,4 Simulieren der 5,6,7,8,9 Cursortasten Der TXL-Befehl "edfunction <Ed-Nr> <Func-Nr> <Char>" führt die Funktionsnummer <Func-Nr> im Editor <Ed-Nr> aus. <Char> ist bei Funktion 0 der ASCII-Code des Zeichens, das eingefügt werden soll. (Über Makros sind so auch die unteren Zeichen des Zeichensatzes ansprechbar.) ,,4 ⌐4. TXL für DOS: Die Befehle ⌐═══════════════════════════ ╔════════════════════════════════════════════════════════════════╗ ║ Befehlsübersicht: Standard-Befehle ║ ╟─────────────┬──────────────────────────────────────────────────╢ ║ Befehlsname │ Funktion ║ ╟─────────────┼──────────────────────────────────────────────────╢ ║ lauf │ Ausführen eines Interpreterprogramms im Speicher ║ ║ drucke │ Ausgabe von Text oder Werten auf dem Terminal ║ ║ setze │ Zuweisen eines Wertes an eine Variable ║ ║ wenn │ Bedingte Programmausführung (siehe unten) ║ ║ gehezu │ Programm an anderer Stelle fortführen ║ ║ ende │ Ende eines Interpreterprogramms ║ ║ merke │ Kommentar ║ ║ liste │ Auflisten des Interpreterprogramms ║ ║ neu │ Programm im Speicher löschen ║ ║ lade │ Laden eines TXL-Quelltexts ║ ║ speichere │ Speichern eines TXL-Quelltexts (ASCII-Format) ║ ║ verlasse │ Verlassen des Interpreters ║ ║ info │ Die Entstehungsgeschichte des TXL-Interpreters ║ ╚═════════════╧═══════════════════════════════════════< weiter >═╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Befehlsübersicht: Neue-Befehle ║ ╟─────────────┬──────────────────────────────────────────────────╢ ║ Befehlsname │ Funktion ║ ╟─────────────┼──────────────────────────────────────────────────╢ ║ hilfe │ Hilfe am Bildschirm anzeigen ║ ║ dos │ Startet ein Dos-Programm oder Dos-Shell ║ ║ setfarbe │ Stellt die Farbe ein für zeig,loesch,lese,box ║ ║ zeig │ Positionierte Ausgabe auf dem Bildschirm ║ ║ lese │ Positioniertes Einlesen einer Variable ║ ║ loesch │ Ganzer Bildschirm oder Ausschnitt löschen ║ ║ sbild │ Bildschirm in eine Variable sichern ║ ║ rbild │ Bildschirm aus einer Var. wieder herstellen ║ ║ attribut │ Wechselt die Farbe am Bildschirm ║ ║ box │ Zeichnet eine Box an die angegebenen Koordin. ║ ║ pause │ Wartet auf einen Tastendruck ║ ║ iftaste │ Abfrage der letzten Taste von PAUSE und LESE ║ ║ piep │ Erzeugt einen Piepton ║ ╚═════════════╧═══════════════════════════════════════< weiter >═╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Befehlsübersicht: Weitere neue Befehle Befehle Seite 3 ║ ╟─────────────┬──────────────────────────────────────────────────╢ ║ Befehlsname │ Parameter und Funktion ║ ╟─────────────┼──────────────────────────────────────────────────╢ ║ strdef │ <String-Var> <Länge> ║ ║ │ Definition eines Strings mit bestimmter Länge ║ ║ strset │ <String-Var> = <String> Stringzuweisung ║ ║ strtoi │ <String(-var)> <Integer-Var> ║ ║ │ Wandelt String in long um ║ ║ itostr │ <Integer(-var)> <String-Var> ║ ║ │ Wandelt long in String um ║ ║ readln │ <String-Var> ║ ║ │ Liest String von Tastatur ║ ║ │ ║ ║ randomize │ Initialisiet den Zufallszahlengenerator ║ ║ random │ <Integer(-var)> <Integer-Var> ║ ║ │ Setzt 2. Variable auf Zufallszahl, maximal ║ ║ │ auf den Wert des ersten Parameters ║ ╚═════════════╧═══════════════════════════════════════< weiter >═╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Verweise auf weitere Befehlsgruppen Befehle Seite 4 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Unterprogramm-Erstellung ║ ║ blockbegin,blockend,gosub -> siehe <gosub> ║ ║ ║ ║ Stackverwaltung (push/pop) -> siehe <push> ║ ║ ║ ║ Gemischte Arrays ║ ║ DefArrayElem, SetArrayElem, GetArrayElem ║ ║ ║ ║ Windows -> eigene Befehlsübersicht ║ ║ Editor -> folgt nach der Fensterbefehl-Beschreibung ║ ║ Datenbank -> 10 ausführliche Hilfsseiten ║ ║ Präprozessor -> folgt nach der Datenbankbeschreibung ║ ║ ║ ║ Menüs -> siehe bei Windows ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: ║ ╟────────────────────────────────────────────────────────────────╢ ║ lauf<Return> ║ ║ drucke "String";<Return> ║ ║ drucke Variable;<Return> ║ ║ setze Variable1 = Variable2;<Return> ║ ║ setze Variable = (Formel);<Return> ║ ║ wenn (Bedingung)<Return> ║ ║ (Dann-Zweig)<Return> ║ ║ (Sonst-Zweig)<Return> ║ ║ gehezu Zeilennummer<Return> ║ ║ ende<Return> ║ ║ merke Kommentar<Return> ║ ║ liste<Return> ║ ║ neu<Return> ║ ║ lade "Filename.Extension"<Return> ║ ║ speichere "Filename.Extension"<Return> ║ ║ verlasse<Return> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<hilfe> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: HILFE ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ hilfe<Return> Zeigt die gesammte Hilfe an. ║ ║ ║ ║ hilfe BEFEHL<Return> ║ ║ BEFEHL<F1> Zeigt die Hilfe zum angegebenen Befehl ║ ║ F1 ║ ║ ║ ║ Hilfetext erweitern oder ändern : ║ ║ ║ ║ Der gesammte Hilfetext ist in der Datei "hilfe.txl" ║ ║ gespeichert. ║ ║ Die einzelnen Bildschirmseiten sind durch das Zeichen 124 ║ ║ voneinander abgetrennt. ║ ║ Um einen Befehl in den SUCH-INDEX aufzunehmen, ║ ║ reicht es, den gewünschten Befehl nach einem Seitenzeichen ║ ║ zwischen die Zeichen '<' und '>' zu schreiben. <neubef> ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<dos> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: DOS ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ dos<Return> Dos-Shell ║ ║ ║ ║ dos "BEFEHL"<return> Dosbefehl ausführen ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<setfarbe> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: SETFARBE ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ setfarbe n1 n2<Return> Bildschirmfarbe einstellen für ║ ║ zeig, loesch und lese ║ ║ ║ ║ n1 : Vordergrund ║ ║ n2 : Hintergrund ║ ║ ║ ║ Farben : ║ ║ -------- ║ ║ 0 schwarz ║ ║ 1 blau ║ ║ 2 grün ║ ║ 3 türkis ║ ║ 4 rot ║ ║ 5 lila ║ ║ 6 braun ║ ║ 7 weiss ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<zeig> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: ZEIG ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ zeig n1 n2 "String"<Return> Positionierte ║ ║ zeig n1 n2 Variable "MASKE"<Return> Bildschirmausgabe. ║ ║ ║ ║ n1 : Zeile ( 0-24 ) ║ ║ n2 : Spalte ( 0-79 ) ║ ║ "String" : Ausgabetext ║ ║ Variable : Ausgabevariable ║ ║ MASKE : Ausgabemaske ist nur bei Var-Ausgabe aktiv ! ║ ║ ║ ║ "99999999" Zahlen ║ ║ "99999.99" Dezimalzahl ║ ║ "XXXXXXXX" String ║ ║ ║ ║ Siehe auch <SETFARBE> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<lese> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: LESE 1. Seite ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ lese n1 n2 Variable "MASKE"<return> Einlesen einer ║ ║ Variable. ║ ║ n1 : Zeile ( 0-24 ) ║ ║ n2 : Spalte ( 0-79 ) ║ ║ Variable : Variable, die eingelesen wird ║ ║ MASKE : Siehe nächste Seite ║ ║ "9999" Integer einlesen ║ ║ "9.99" Dezimalzahl einlesen ║ ║ "XXXX" String ║ ║ "DD.DD.DDDD" Datum ║ ║ ║ ║ Mit diesen Tasten wird LESE beendet : ║ ║ Return, ESC, Pfeiltasten rauf runter, ║ ║ Seite auf ab, alle Funktionstasten. ║ ║ ║ ║ Siehe auch <SETFARBE> <IFTASTE> <nächste Seite> ║ ╚═════════════════════════════════════════════════< weiter >═════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: LESE 2. Seite ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ MASKE : "99999999" Zahlen -1234567890 ║ ║ "99999.99" Dezimalzahl -.1234567890 ║ ║ "XXXXXXXX" String Alle Zeichen ║ ║ "DD.DD.DD" Datum TT.MM.JJ ║ ║ "DD.DD.DDDD" TT.MM.JJJJ ║ ║ ║ ║ Jedes Maskenzeichen ergibt eine Eingabestelle. ║ ║ ║ ║ ║ ║ Sezial : "@X" = Maske wird automatisch Alle Zeichen ║ ║ auf Stringlänge erstellt. ║ ║ ║ ║ "@D" = Maske wird automatisch TT.MM.JJJJ ║ ║ auf Datumfeld erstellt. ║ ║ ║ ║ Siehe auch <SETFARBE> <IFTASTE> <vorherige Seite> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<loesch> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: LOESCH ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ loesch ;<Return> Löscht den ganzen Bildschirm ║ ║ loesch n1 n2 n3 n4 <Return> Löscht einen Ausschnitt ║ ║ auf dem Bildschirm ║ ║ ║ ║ n1 : obere Zeile ( 0-24 ) ║ ║ n2 : linke Spalte ( 0-79 ) ║ ║ n3 : untere Zeile ( 0-24 ) ║ ║ n4 : rechte Spalte ( 0-79 ) ║ ║ ║ ║ Bsp. ║ ║ ║ ║ loesch 10 5 20 40<Return> ║ ║ ║ ║ ║ ║ Siehe auch <SETFARBE> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<sbild> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: SBILD (Im ANSI-Modus nicht aktiv !) ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ sbild n1 n2 n3 n4 Str-Var<Return> Sichert den Bildschirm ║ ║ des angegebenen ║ ║ Fensters in Variable. ║ ║ ║ ║ n1 : obere Zeile ( 0-24 ) ║ ║ n2 : linke Spalte ( 0-79 ) ║ ║ n3 : untere Zeile ( 0-24 ) ║ ║ n4 : rechte Spalte ( 0-79 ) ║ ║ Str-Var : Variable vom Type STRING ║ ║ Bsp. ║ ║ ║ ║ sbild 10 5 20 40 screen<Return> ║ ║ ║ ║ ║ ║ Siehe auch <RBILD> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<rbild> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: RBILD (Im ANSI-Modus nicht aktiv !) ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ rbild n1 n2 n3 n4 Str-Var<Return> Stellt den Bildschirm ║ ║ aus einer Variablen ║ ║ wieder her. ║ ║ ║ ║ n1 : obere Zeile ( 0-24 ) ║ ║ n2 : linke Spalte ( 0-79 ) ║ ║ n3 : untere Zeile ( 0-24 ) ║ ║ n4 : rechte Spalte ( 0-79 ) ║ ║ Str-Var : Variable vom Type STRING ║ ║ Bsp. ║ ║ ║ ║ rbild 10 5 20 40 screen<Return> ║ ║ ║ ║ ║ ║ Siehe auch <SBILD> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<attribut> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: ATTRIBUT (Im ANSI-Modus nicht aktiv !) ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ attribut n1 n2 n3 n4 v h<Return> Stellt die Bildschirm- ║ ║ farbe im angegebenen ║ ║ Fenster um. ║ ║ Die Zeichen auf den ║ ║ Bildschirm werden ║ ║ nicht verändert. ║ ║ ║ ║ n1 : obere Zeile ( 0-24 ) ║ ║ n2 : linke Spalte ( 0-79 ) ║ ║ n3 : untere Zeile ( 0-24 ) ║ ║ n4 : rechte Spalte ( 0-79 ) ║ ║ v : Vordergrundfarbe ( 0-7 ) (Farbtabelle ║ ║ h : Hintergrundfarbe ( 0-7 ) bei SETFARBE) ║ ║ ║ ║ Siehe auch <SETFARBE> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<box> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: BOX ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ box n1 n2 n3 n4 "Box-Str"<Return> Zeichnet eine Box ║ ║ an die angegebenen ║ ║ Koordinaten. ║ ║ ║ ║ n1 : obere Zeile ( 0-24 ) ║ ║ n2 : linke Spalte ( 0-79 ) ║ ║ n3 : untere Zeile ( 0-24 ) ║ ║ n4 : rechte Spalte ( 0-79 ) ║ ║ "Box-Str" : Variable vom Type STRING ║ ║ ║ ║ Boxstring "12345678#" ergibt 12222223 ║ ║ 4######8 ║ ║ 4######8 ║ ║ "╔═╗║╝═╚║ " 76666665 ║ ║ ║ ║ Siehe auch <SETFARBE> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<pause> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: PAUSE ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ pause<Return> Das Programm wartet auf einen Tasten- ║ ║ druck. ║ ║ ║ ║ Siehe auch <IFTASTE> ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<iftaste> ╔════════════════════════════════════════════════════════════════╗ ║ Syntaxbeschreibung: IFTASTE ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ iftaste TASTENWERT<Return> Fragt den Tastenwert ab, ║ ║ (Dann-Zweig)<Return> mit dem die Funktion ║ ║ (Sonst-Zweig)<Return> PAUSE oder LESE verlassen ║ ║ wurde. ║ ║ ║ ║ Tasten-Tabelle auf der nächsten Seite ! ║ ║ ║ ║ Siehe auch <PAUSE> <LESE> < nächste Seite > ║ ╚════════════════════════════════════════════════════════════════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Tastenwert-Tabelle für IFTASTE ║ ╟────────────────────────────────────────────────────────────────╢ ║ Normal Shift Ctrl Alt ║ ║ ------ ----- ---- --- ║ ║ F1 9059 SF1 9084 CF1 9094 AF1 9104 ║ ║ F2 9060 SF2 9085 CF2 9095 AF2 9105 ║ ║ F3 9061 SF3 9086 CF3 9096 AF3 9106 ║ ║ F4 9062 SF4 9087 CF4 9097 AF4 9107 ║ ║ F5 9063 SF5 9088 CF5 9098 AF5 9108 ║ ║ F6 9064 SF6 9089 CF6 9099 AF6 9109 ║ ║ F7 9065 SF7 9090 CF7 9100 AF7 9110 ║ ║ F8 9066 SF8 9091 CF8 9101 AF8 9111 ║ ║ F9 9067 SF9 9092 CF9 9102 AF9 9112 ║ ║ F10 9068 SF10 9093 CF10 9103 AF10 9113 ║ ║ ║ ║ Escape 9027 Page up 9073 ║ ║ Return 9013 Page down 9081 ║ ║ Pfeilrunter 9080 Pfeilrauf 9072 ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<info> ╔════════════════════════════════════════════════════════════════╗ ║ TXL, die "toolbox language", ist ein nach allen Seiten ║ ║ offenes Interpreterkonzept für PC und Atari-ST. ║ ║ Jedem C-Programmierer wird es damit möglich, sich seine ║ ║ eigene Sprache zu gestalten. ║ ║ Neben der Verwendung der TXL für Schulungszwecke lassen ║ ║ sich auch hervorragend rechnerunabhängige Anwendungen ║ ║ realisieren. Einzige Voraussetzung ist ein ANSI-C ║ ║ Compiler. ║ ║ Das Grundgerüst für den TXL-Interpreter wurde in der ║ ║ Zeitschrift toolbox, Heft 9/10'1990 vorgestellt. ║ ║ Wesentliche Erweiterungen sowie eine Windows-Version ║ ║ wurden im Rahmen eines Wettbewerbs in der toolbox 04'91 ║ ║ veröffentlicht. ║ ║ Bezogen werden kann der aktuelle Grundinterpreter als ║ ║ toolbox-Special 20. ║ ║ Bestellungen richten sie bitte an den DMV-Verlag ║ ║ Postfach 250 ║ ║ 3440 Eschwege ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<gosub> ╔════════════════════════════════════════════════════════════════╗ ║ Unterprogramme ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Unterprogramme werden mit den Befehlen 'blockbegin' am Anfang ║ ║ und 'blockend' am Ende gekennzeichnet. Mit 'gosub <zeile>' ║ ║ wird ein Unterprogramm aufgerufen. Zur Namensgebung lassen ║ ║ sich Variablen verwenden. ║ ║ ║ ║ Beispiel : ║ ║ ║ ║ 010 setze SUB = 100; ║ ║ 020 gosub SUB ║ ║ 030 gehezu 200 ║ ║ 100 blockbegin ║ ║ 110 drucke " Hier Unterprogramm. " ║ ║ 120 blockend ║ ║ 200 merke Programmende ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<DefArray> ╔════════════════════════════════════════════════════════════════╗ ║ Arrays ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Mit "DefArray" definierte Arrays können jeden Datentyp - außer ║ ║ weitere Arrays - als Elemente enthalten, auch gemischte ║ ║ Arrays (verschiedene Typen in einem Array) sind möglich. ║ ║ ║ ║ Mit "DefArray" muß das Array zuerst definiert werden. ║ ║ ║ ║ ║ ║ Syntax : DefArray <name> : <dim1> [,dim2] [,dim3] ║ ║ ║ ║ Beispiel : DefArray quadrat : 10,10 ║ ║ (definiert ein 10*10 Felder großes Array) ║ ║ ║ ║ Mit DefArray könnten Arrays auch redefiniert werden, da aber ║ ║ Speicher verloren geht, wenn bereits Werte in das Array ein- ║ ║ getragen sind, ist von der Redefinition abzuraten. ║ ║ ║ ╚══════════════════════════════════════════════════════<weiter>══╝ | ⌐<SetArrayElem> ╔════════════════════════════════════════════════════════════════╗ ║ Arrays : "SetArrayElem" ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Syntax : SetArrayElem <name> (dim1 [,dim2[,dim3]]) = <wert> ║ ║ ║ ║ Setzt ein Arrayelement an der Stelle (dim1,dim2,dim3), wobei ║ ║ <wert> ein einfacher Typ (Fließkomma, Ganzzahl oder Zeichen) ║ ║ oder ein String sein kann. ║ ║ ║ ║ Beispiel : SetArrayElem quadrat (4,4) = zahl ║ ║ ║ ║ Anmerkungen : ║ ║ - Hinter dem "=" muß eine Variable stehen, Direktwerte sind ║ ║ nicht erlaubt. ║ ║ - Die Numerierung der Elemente beginnt bei 0 ║ ║ - vollständiges Beispiel auf nächster Seite ║ ║ ║ ╚══════════════════════════════════════════════════════<weiter>══╝ | ⌐<GetArrayElem> ╔════════════════════════════════════════════════════════════════╗ ║ Arrays : "GetArrayElem" ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Syntax : GetArrayElem <name> (dim1 [,dim2[,dim3]]) -> <wert> ║ ║ ║ ║ Speichert das Element an der Stelle (dim1,dim2,dim3) in <wert>.║ ║ <wert> muß den Typ des Elements haben. ║ ║ ║ ║ Beispiel : DefArray quadrat : 10,10 ║ ║ setze string = "Ein String im Array " ║ ║ setze zahl = 100; ║ ║ SetArrayElem quadrat (0,0) = string ║ ║ SetArrayElem quadrat (0,1) = zahl ║ ║ GetArrayElem quadrat (0,0) -> string2 ║ ║ GetArrayElem quadrat (0,1) -> zahl2 ║ ║ drucke string2 ║ ║ drucke zahl2 ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<push> ╔════════════════════════════════════════════════════════════════╗ ║ Integer-Stack ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Mit den Befehlen "push" und "pop" ist der Stack, auf dem nur ║ ║ Ganzzahl-Variablen (long) gespeichert werden können. ║ ║ ║ ║ Die Größe des Stacks ist nur durch den freien Heap begrenzt. ║ ║ Der Stack läßt sich gut zur Rückgabe von Funktionswerten ║ ║ in Unterprogrammen oder zur Parameterübergabe benutzen. ║ ║ ║ ║ Syntax : push <var oder Konstante> ║ ║ pop <var> ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<window> ╔════════════════════════════════════════════════════════════════╗ ║ Das Window-System (c) 1991 toolbox ║ ╟────────────────────────────────────────────────────────────────╢ ║ Das Windowsystem für TXL erlaubt soviele Fenster, wie der Heap ║ ║ kann. Einen ersten Überblick gibt die Kurzb. der Befehle: ║ ║ ║ ║ openwindow Fenster öffnen und Farben definieren ║ ║ closewindow Oberstes Fenster schließen ║ ║ setcursor Cursor relativ zum Fenster positionieren ║ ║ newfirstwindow Verdecktes Fenster nach vorne bringen ║ ║ newwindowkoor Neue Koordinaten für oberstes Fenster ║ ║ resizewindow Ändern der Größe des obersten Fensters ║ ║ movewindow Verschieben " " " ║ ║ winreadstring String in neuem Fenster einlesen (mit Infoz.)║ ║ winmessage Ausgabe einer Meldung in einem Fenster ║ ║ winwrite Schnelle Stringausgabe im ob. Fenster ║ ║ ║ ╚═══════════════════════════< genaue Beschreibung folgt ... >════╝ | ⌐<openwindow> ╔════════════════════════════════════════════════════════════════╗ ║ Neue Fenster öffnen Das Window-System 1 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Syntax ║ ║ ║ ║ openwindow <x1> <y1> <x2> <y2> <f1> <f2> <f3> <f4> [num] ║ ║ ║ ║ Die linke obere Ecke wird mit x1/y1, die rechte untere mit ║ ║ x2/y2 angegeben. Es folgen vier Farbangaben : ║ ║ ║ ║ f1 : Farbe des Rahmens ║ ║ f2 : Farbe des Inneren ║ ║ f3 : Farbe für Überschrift (für Editor) ║ ║ Überschriften für Nicht-Editor-Fenster können mit ║ ║ "winwrite" erzeugt werden. ║ ║ f4 : Farbe der Statuszeile (siehe f3) ║ ║ ║ ║ Im optionalen Parameter [num] wird die Fensternummer des ║ ║ neuen Fensters gespeichert. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<resizewindow> ╔════════════════════════════════════════════════════════════════╗ ║ Fensterkoordinaten ändern Das Window-System 2 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Der allgemeine Befehl zum Ändern der Fensterkoordinaten ║ ║ Fensters) ist ║ ║ ║ ║ newwindowkoor <x1> <y1> <x2> <y2>. ║ ║ Die Parameternamen sprechen für sich. ║ ║ ║ ║ Nur Breite und Höhe bzw. Position ändern folgende Befehle : ║ ║ ║ ║ (1) resizewindow <rel-x> <rel-y> ║ ║ (2) movewindow <rel-x> <rel-y> ║ ║ ║ ║ Bei (1) wird die rechte untere Ecke um relx/rely verschoben, ║ ║ bei (2) das gesamte Fenster. ║ ║ (Da keine negativen Werte möglich sind, muß "newwindowkoor" ║ ║ benutzt werden, um negative Werte zu ersetzen.) ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<winmessage> ╔════════════════════════════════════════════════════════════════╗ ║ "Automatische Fenster" Das Window-System 3 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ winmessage <string> ║ ║ Gibt den <string> und die Aufforderung, eine Taste ║ ║ zu drücken in einem zentrierten Fenster aus, das ║ ║ nach einem Tastendruck wieder geschlossen wird. ║ ║ ║ ║ winreadstr <frage> <str-var> <laenge> ║ ║ ║ ║ Gibt in einem zentrierten Fenster <frage> aus und ║ ║ liest einen String in <str-var> ein. Das Fenster ║ ║ wird wieder geschlossen. <laenge> gibt an, wie ║ ║ lang das Eingabefeld minimal sein soll. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<winwrite> ╔════════════════════════════════════════════════════════════════╗ ║ weitere Window-Befehle Das Window-System 4 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ closewindow Schließt das oberste Fenster ║ ║ ║ ║ newfirstwindow <num> Das Fenster <nr> (siehe Openwindow) ║ ║ wird neues oberes Fenster ║ ║ ║ ║ winwrite <x> <y> <a> <str> Schreibt <str> mit dem Farbattribut ║ ║ <a> an die Position x/y des oberen ║ ║ Fensters. ║ ║ 0/0 gibt die linke obere Ecke des ║ ║ Rahmens an. ║ ║ setcursor <x> <y> Setzt den Cursor an x/y ║ ║ (oberes Fenster) ║ ║ ║ ║ "winwrite" und "setcursor" funktionieren auch ohne geöffnetes ║ ║ Fenster. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<menue> ╔════════════════════════════════════════════════════════════════╗ ║ Pulldown- und Auswahlmenüs 1 von 2 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Die hier implementierten Pulldownmenüs werden mit den Cursor- ║ ║ tasten gesteuert, und mit <ESC> verlassen. Die Auswahlmenüs ║ ║ werden nach der Auswahl eines Punktes mit <Return> geschlossen.║ ║ Beide Formen öffnen kein Fenster, dieses muß also vorher ║ ║ geöffnet werden. Dadurch hat man aber die freie ║ ║ Wahl in der Farbe und Position des Menüs und die Menü- ║ ║ Parameterzeile wird nicht zu lang. ║ ║ Der Auswahlbalken wird in der Rahmenfarbe dargestellt. ║ ║ ║ ║ Syntax : ║ ║ ║ ║ auswahl <punkt1> <punkt2> ... <punkt n> ║ ║ menue <punkt1> <uprog1> ... <punkt n> <uprog n> ║ ║ ║ ║ Beschreibung wird auf nächster Seite fortgesetzt. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Pulldown- und Auswahlmenüs 2 von 2 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Der "menue"-Befehl ruft im Gegensatz zum "auswahl"-Befehl nach ║ ║ jeder Wahl ║ ║ eines Menüpunktes ein Unterprogramm, das durch seine Zeilen- ║ ║ nummer in den Parametern <uprog x> angegeben ist, auf. ║ ║ Nach Ausführung des Unterprogramms wird die Menüschleife ║ ║ solange weiter durchlaufen, bis <ESC> gedrückt wird. ║ ║ Das Unterprogramm kann natürlich auch aus einer Zeile ║ ║ bestehen, wenn kein "blockbegin" angegeben ist. ║ ║ ║ ║ Der "auswahl"-Befehl wird nach Auswahl eines Punktes beendet ║ ║ und legt die Nummer des ausgewählten Punktes auf den Stack ║ ║ (erster Punkt : 1), so daß sie mit pop <xxx> ausgelesen ║ ║ werden sollte. ║ ║ ║ ║ Hinweis : Das Fenster für die Menüs muß nach Beenden des Menüs ║ ║ wieder explizit geschlossen werden. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<edit> ╔════════════════════════════════════════════════════════════════╗ ║ Das Editor-System (c) 1991 toolbox ║ ╟────────────────────────────────────────────────────────────────╢ ║ Das Editorsystem für TXL erlaubt 10 Editoren, die gleichzeitig ║ ║ verschiedene Dateien bearbeiten können und eine Schnittstelle ║ ║ zu TXL ║ ║ besitzen, d.h. (fast) jede Editorfunktion kann durch einen ║ ║ TXL-Befehl simuliert werden. Da 50 Hotkeys für die Editoren in ║ ║ TXL auf Unterprogramme gelegt werden können, lassen sich so ║ ║ (Alt/Shift/Ctrl-F1-F10, F1-F10, Alt0-Alt9) Makros programmieren║ ║ ║ ║ Im Direktmodus bearbeitet "edit" das aktuelle Programm, ║ ║ speichert es am Ende unter "AKTUELL.TXL" und läd es in den ║ ║ Interpreter. ║ ║ ║ ║ "edit <file>" läd eine bestimmte Datei, die explizit ║ ║ gesichert werden muß (z.B. edit "Programm.TXL"). ║ ║ ║ ╚═══════════════════════════< Übersichttafeln folgen ... >═══════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Editorbefehle beim Editieren Der Editor 1 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Funktionsnr Hotkey ║ ║ 10 INS ║ ║ 11 DEL ║ ║ 12 Backspace ║ ║ 13 Return ║ ║ 14 Ctrl-Y Zeile löschen ║ ║ 15 Ctrl-Left Wort links ║ ║ 16 Ctrl-Right Wort rechts ║ ║ 17 Ctrl-B Blockbeginn setzen ║ ║ 18 Ctrl-E Blockende setzen ║ ║ 19 Ctrl-C Block kopieren ║ ║ 20 Ctrl-D Block löschen ║ ║ 21 Ctrl-V Block verschieben ║ ║ 22 Ctrl-R Block von Diskette lesen ║ ║ 24 Ctrl-W Block auf Diskette schreiben ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<edfunction> ╔════════════════════════════════════════════════════════════════╗ ║ Editorbefehle beim Editieren Der Editor 2 ║ ╟──────────────────────────────────────────── ───────────────────╢ ║ Funktionsnr Hotkey ║ ║ 23 Ctrl-S Datei speichern ║ ║ 25 Home Cursor an Dateianfang ║ ║ 26 End Cursor an Textende ║ ║ 30 Alt-R Fenster mit Cursortasten in Größe ändern║ ║ 31 Alt-M Fenster mit Cursortasten verschieben ║ ║ 32 Alt-Z Fenster zoomen ║ ║ -- Ctrl-T Aufruf des Präprozessors ║ ║ 0 Eingabe eines Zeichens ║ ║ 1,2,3,4 Simulieren der ║ ║ 5,6,7,8,9 Cursortasten ║ ║ ║ ║ Der TXL-Befehl "edfunction <Ed-Nr> <Func-Nr> <Char>" führt die ║ ║ Funktionsnummer <Func-Nr> im Editor <Ed-Nr> aus. <Char> ist bei║ ║ Funktion 0 der ASCII-Code des Zeichens, das eingefügt werden ║ ║ soll. (Über Makros sind so auch die unteren Zeichen des ║ ║ Zeichensatzes ansprechbar.) ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<initeditor> ╔════════════════════════════════════════════════════════════════╗ ║ Editorbefehle für TXL Der Editor 3 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Grundsätzlich ist ein Editor nicht an ein bestimmtes Fenster ║ ║ gebunden; die Ausgaben der Editorfunktionen finden immer im ║ ║ obersten Fenster statt. ║ ║ Da insgesamt 10 Editoren zur Verfügung stehen (Nummer 0 bis 9) ║ ║ , ist der erste Parameter der meisten Editor-Befehle die Nummer║ ║ des angesprochenen Editors. Zuerst wird ein Editor mit ║ ║ ║ ║ initeditor <nummer> [file] ║ ║ ║ ║ initialisiert. Der optionale Parameter [file] hat den selben ║ ║ Zweck, wie [file] beim "edit"-Befehl. Wird er weggelassen, so ║ ║ lädt der Editor das TXL-Programm. ║ ║ Der Befehl ║ ║ ║ ║ editorproc <nummer> ║ ║ ║ ║ veranlaßt den Editor <nummer>, Benutzereingaben zu bearbeiten, ║ ║ bis <ESC> oder <Ctrl>-T gedrückt wird. Der Editor wird durch ║ ║ Eingaben nicht automatisch geschlossen (anders als "edit"). ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<closeeditor> ╔════════════════════════════════════════════════════════════════╗ ║ Editorbefehle für TXL Der Editor 4 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Soll der vom Editorinhalt belegte Speicher freigegeben werden, ║ ║ so ist der Befehl ║ ║ ║ ║ closeeditor <nummer> ║ ║ ║ ║ anzuwenden. Dieser Befehl speichert nur, wenn das aktuelle ║ ║ TXL-Programm geladen ist, und dann in die Datei "aktuell.txl". ║ ║ Für Fälle, in denen es notwendig wird, den Fensterinhalt für ║ ║ einen Editor neu darzustellen, ist die Anweisung ║ ║ ║ ║ showeditor <nummer> ║ ║ ║ ║ gedacht. Sie ist aber nicht erforderlich, wenn der Text mit ║ ║ "editorproc" bearbeitet wird. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<setfkey> ╔════════════════════════════════════════════════════════════════╗ ║ Editorbefehle für TXL Der Editor 5 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Die Belegung der Hotkeys, die für alle Editoren gleichzeitig ║ ║ gelten, wird von ║ ║ ║ ║ setfkey <taste> <zeile> ║ ║ ║ ║ übernommen. Die Zeile mit der Nummer <zeile> wird angesprungen,║ ║ wenn die angegebene Taste gedrückt wird. Steht in dieser Zeile ║ ║ ein "blockbegin", so wird natürlich der darauf folgende Block ║ ║ ausgeführt. Die Angabe "0" bei <zeile> bewirkt die Löschung der║ ║ Hotkey-definition für <taste>. ║ ║ <taste> kann folgende Werte haben : ║ ║ ║ ║ 1-10 : F1-F10 31-40 : Alt-F1-F10 ║ ║ 11-20 : Shift-F1-F10 41-50 : Alt-1 bis Alt-0 ║ ║ 21-30 : Ctrl-F1-F10 ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<insertstring> ╔════════════════════════════════════════════════════════════════╗ ║ Editorbefehle für TXL Der Editor 6 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Neben der Funktion 0 von "edfunction", die einzelne Zeichen in ║ ║ den Editor eingibt, existiert auch eine Funktion, die Strings ║ ║ in den Editor eingibt: ║ ║ ║ ║ insertstring <editornr> <str> ║ ║ ║ ║ Außer dem String / der Stringvariablen wird als erster Param. ║ ║ die Editornummer erwartet. ║ ║ ║ ║ Das Lesen des Editors in TXL-Programmen kann wort- oder zeilen-║ ║ erfolgen : ║ ║ ║ ║ getedword <editornr> <str-var> ║ ║ getedstring <editornr> <str-var> ║ ║ ║ ║ Bei "getedword" muß der Cursor auf dem Anfang des Wortes stehen║ ║ ,"getedstring" wird die gesamte Zeile in <str-var> gespeichert.║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Das Datenbankmodul (c) 1991 toolbox ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Der Aufbau der Datenfelder ist frei wählbar und wird in einer ║ ║ Datei mit der Endung ".def" gespeichert, sobald einmal defin. ║ ║ Die Daten werden in gleichnamige Dateien, jedoch mit der Endung║ ║ ".dat" geschrieben. Als Datenfeldtypen stehen Zeichenfelder mit║ ║ frei definierbarer Länge und Integerfelder zur Verfügung. ║ ║ Die Sortierung der Daten erfolgt bei den Strings in einem ║ ║ binären Baum, was aber für die Programmierung in TXL nicht von ║ ║ Bedeutung ist. Die vielfältigen Möglichkeiten beim Suchen von ║ ║ Datensätzen und sonstigen Funktionen werden auf den folgenden ║ ║ Seiten beschrieben. ║ ║ ║ ║ Bei den Befehlen des Datenbankmoduls ist die Groß- und Klein- ║ ║ schreibung zu beachten. ║ ║ ║ ║ Es können gleichzeitig 3 Datenbanken geöffnet werden, daher ║ ║ haben die meisten Datenbankfunktionen einen Parameter <dbnr>, ║ ║ für den Werte von 0 bis 2 erlaubt sind. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<DefDB> ╔════════════════════════════════════════════════════════════════╗ ║ Erstellen und Öffnen einer Datenbank Das Datenbankmodul 1 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Zuerst muß der Aufbau eines Datensatzes definiert werden. ║ ║ Dazu wird für jedes Datenfeld die Funktion ║ ║ ║ ║ DefDB <dbnr> <int?> <strlen> ║ ║ ║ ║ aufgerufen. <int?>=1 zeigt an, daß es sich um ein Integerfeld ║ ║ handelt, der Parameter <strlen> muß vorhanden sein, sein Wert ║ ║ bedeutet aber in diesem Fall nichts. Wenn <int?>=0 ist, wird ║ ║ ein Stringfeld mit der Länge <strlen> erstellt. Der Parameter ║ ║ <dbnr> gibt die Nummer der Datenbank an (0 bis 2). ║ ║ Die Feldnummer wird automatisch ermittelt: Der erste Aufruf ║ ║ definiert Feld 1, maximal 20 Felder sind möglich. ║ ║ Ist die Definition vollständig, muß sie mit ║ ║ ║ ║ CreateDB <dbnr> <name> ║ ║ ║ ║ gespeichert werden. Dabei werden die Dateien "<name>.def" und ║ ║ "<name>.dat" ║ ║ neu erzeugt und dabei gelöscht, falls sie schon vorhanden sind.║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<OpenDB> ╔════════════════════════════════════════════════════════════════╗ ║ Öffnen und Schließen einer Datenbank Das Datenbankmodul 2 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Eine mit "CreateDB" erstellte Datenbank kann mit ║ ║ ║ ║ OpenDB <dbnr> <name> ║ ║ ║ ║ wieder geöffnet werden. Die Definition wird dabei automatisch ║ ║ geladen, die Anwendung von "DefDB" ist hier also nicht nötig. ║ ║ ║ ║ Nach der Bearbeitung wird die Datenbank mit ║ ║ ║ ║ CloseFile <dbnr> ║ ║ ║ ║ geschlossen. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | <WriteDB> ╔════════════════════════════════════════════════════════════════╗ ║ Datenspeicherung Das Datenbankmodul 3 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Das Beschreiben eines Datensatzes erfolgt für jedes Feld ║ ║ einzeln mit dem Befehl ║ ║ ║ ║ WriteDB <dbnr> <feldnr> <str> <int> ║ ║ ║ ║ In das Feld <feldnr> des aktuellen Datensatzes der Datenbank ║ ║ <dbnr> wird entweder der String <str>, oder der Integer <int> ║ ║ geschrieben, je nach Feldtyp. Beide Parameter müssen angegeben ║ ║ werden. Besonders günstig ist die Dateneingabe mit Hilfe des ║ ║ Editors, wie im Beispielprogramm demonstriert wird. ║ ║ Mit "AddDB" wird der aktuelle Datensatz auf Disk gespeichert. ║ ║ Syntax : AddDB <dbnr> ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<ReadDB> ╔════════════════════════════════════════════════════════════════╗ ║ Das Lesen der Daten Das Datenbankmodul 4 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Analog zum Beschreiben eines Satzes funktioniert das Auslesen :║ ║ ║ ║ ReadDB <dbnr> <feldnr> <str> <int> ║ ║ ║ ║ liest das Feld <feldnr> und speichert den Inhalt je nach Typ ║ ║ entweder in <str> oder <int>. ║ ║ ║ ║ Zur Formatierten Ausgabe bessert geeignet ist folgender Befehl:║ ║ ║ ║ ReadDBForm <dbnr> <feldnr> <str> ║ ║ ║ ║ gibt in jedem Fall einen String zurück, der auf die Maximale ║ ║ Länge des Feldes ausgedehnt ist (linksbündig ausgerichtet), ║ ║ und sich so gut für Tabellen eignet. Integerwerte werden in ║ ║ einen sechs Zeichen langen String umgewandelt. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<GotoBegin> ╔════════════════════════════════════════════════════════════════╗ ║ Bewegung innerhalb der Datenbank Das Datenbankmodul 5 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Nach der Öffnung befindet sich als aktueller Datensatz ein ║ ║ neuer Satz im Speicher, der hinter allen bisher gespeicherten ║ ║ Datensätzen in der Datei gespeichert wird. Um den aktuellen ║ ║ Datensatz zu ändern, existieren, außer den Datensuchbefehlen, ║ ║ folgende Befehle : ║ ║ ║ ║ Befehl Zielposition ║ ║ ║ ║ GotoBegin <dbnr> erster Datensatz der Datei ║ ║ GotoEnd <dbnr> ein Satz hinter dem letzten ║ ║ GoForward <dbnr> einen Satz weiter ║ ║ GoBackward <dbnr> einen Satz zurück, -> Anfang ║ ║ GoTo <dbnr> <filepos> Dateiposition(Bytenr.)<filepos>║ ║ GoToNr <dbnr> <satznr> Datensatz Nummer <satznr> ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<MarkCurrent> ╔════════════════════════════════════════════════════════════════╗ ║ Löschen von Datensätzen Das Datenbankmodul 6 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Der aktuelle Datensatz wird durch ║ ║ ║ ║ MarkCurrent <dbnr> <val> ║ ║ ║ ║ mit <val> markiert. <val> ungleich 0 bedeutet Löschen. ║ ║ ║ ║ DelMarked <dbnr> ║ ║ ║ ║ löscht alle markierten Datensätze physikalisch in der Datei. ║ ║ Die Markierung kann entweder mit "MarkCurrent <dbnr> 0" für ║ ║ einen speziellen Satz, oder mit ║ ║ ║ ║ UnMarkAll <dbnr> ║ ║ ║ ║ für alle markierten Sätze rückgängig gemacht werden. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | <SearchDB> ╔═══════════════════ ════════════════════════════════════════════╗ ║ Suchen ohne Baum Das Datenbankmodul 7 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Zur Suche mit komplexen Bedingungen ist der Befehl ║ ║ ║ ║ SearchDB <dbnr> <test> <ausg> ║ ║ ║ ║ gedacht. Er geht die Datenbank Satz für Satz durch und ruft für║ ║ jeden Satz das Unterprogramm ab der Zeile <test> auf. Dieses ║ ║ kann mit "ReadDB" den aktuellen Satz auf verschiedene ║ ║ Bedingungen testen und ruft "GefundenOK" ohne Parameter auf, ║ ║ falls der Datensatz den gewünschten Bedingungen entspricht. ║ ║ Ist dies der Fall, so ruft "SearchDB" das Unterprogramm <ausg> ║ ║ auf, das die Bearbeitung oder Ausgabe des Satzes übernimmt. ║ ║ In beiden Unterprogrammen kann die Suche mit dem parameterlosen║ ║ Befehl "StopSearch" beendet werden. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<MakeTree> ╔════════════════════════════════════════════════════════════════╗ ║ Sortieren Das Datenbankmodul 8 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Jede der Datenbanken kann für eines der Zeichenfelder einen ║ ║ binären Baum zur Sortierung aufbauen. Durch den Befehl ║ ║ ║ ║ MakeTree <dbnr> <feldnr> ║ ║ ║ ║ veranlaßt. Für das (String-)Feld <feldnr> baut die Datenbank # ║ ║ <dbnr> einen Baum auf. Dieser kann mit ║ ║ ║ ║ DelTree <dbnr> ║ ║ ║ ║ explizit wieder gelöscht werden, was aber automatisch geschieht║ ║ ,wenn erneut "MakeTree" für dieselbe Datenbank aufgerufen wird.║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<PassTree> ╔════════════════════════════════════════════════════════════════╗ ║ Nutzung des sortierten Baumes Das Datenbankmodul 9 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Die Funktion "PassTree" geht ebenso wie "SearchDB" die gesamte ║ ║ Datenbank durch, jedoch in der Reihenfolge, die durch den Baum ║ ║ vorgegeben ist. Für jeden Datensatz wird wieder eine Test- und ║ ║ dann je nach Ergebnis eine Bearbeitungs-/Ausgaberoutine auf- ║ ║ gerufen. Die Syntax ist demnach dieselbe wie bei "SearchDB" : ║ ║ ║ ║ PassTree <dbnr> <test> <ausg> ║ ║ ║ ║ Zum direkten Auffinden eines Datensatzes dient der Befehl: ║ ║ ║ ║ SearchTree <dbnr> <ERGEBNIS> <str> ║ ║ ║ ║ Er sucht <str> im Baum (<str> muß also in einem Feld stehen, ║ ║ daß im Baum sortiert wurde) und gibt die Dateiposition des ║ ║ gefundenen Satzes in <ERGEBNIS> zurück. Der Wert 1 Milliarde ║ ║ bedeutet, daß der Satz nicht gefunden wurde. ║ ║ Die Position ist mit "GoTo", nicht mit "GoToNr" direkt ║ ║ ansteuerbar, sie wird auch automatisch gesetzt, ║ ║ wenn <str> gefunden wurde. ║ ╚════════════════════════════════════════════════════════════════╝ | ⌐<ListTree> ╔════════════════════════════════════════════════════════════════╗ ║ Ausgabe des sortierten Baumes Das Datenbankmodul 10 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ Um eine einfache Baumausgaberoutine handelt es sich bei: ║ ║ ║ ║ ListTree <dbnr> ║ ║ ║ ║ Der Bauminhalt wird (sortiert) wie mit "drucke" ausgegeben, ║ ║ also nicht in irgendein Fenster. ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Der Präprozessor (c) 1991 toolbox 1 ║ ╟────────────────────────────────────────────────────────────────╢ ║ Der Präprozessor wandelt ein Programm im Editor in ein TXL-aus-║ ║ führbares Programm um. Er wird mit Ctrl-T im Editor aufgerufen.║ ║ Nach Drücken dieser Tastenkombination wird das Programm auto- ║ ║ matisch gespeichert, mit dem Präprozessor in die Datei ║ ║ "AKTUELL.TXL" umgewandelt und automatisch in den Programm- ║ ║ speicher eingelesen. ║ ║ ║ ║ Die Verbesserungen durch den Präprozessor sind : ║ ║ - Wegfall der Zeilennumern am Anfang jeder Zeile ║ ║ - Ansteuerung von Unterprogrammen und Programmzeilen (gehezu ║ ║ und gosub) mit Namen statt mit Zeilennummern ║ ║ - Einführung von Bezeichnern für Konstanten, die vom Präproz.║ ║ automatisch eingesetzt werden. ║ ║ - Leerzeilen sind möglich ║ ║ ║ ║ Sowohl Programmzeilenbezeichnungen, als auch Konstanten können ║ ║ auch nach ihrer ersten Bezeichnung noch definiert werden. ║ ║ ║ ╚══════════════════════════════════════════════════< weiter >════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Die Präprozessorbefehle 2 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ 1. label <name> ║ ║ ║ ║ ordnet der folgenden Zeile den Bezeichner <name> zu, der ║ ║ überall im Programm verwendet werden kann. ║ ║ ║ ║ 2. const <name> <wert> ║ ║ ║ ║ definiert eine Konstante, die den Wert <wert> und die Be- ║ ║ zeichnung <name> hat. ║ ║ ║ ╚══════════════════════════════════════════════════< weiter >════╝ | ╔════════════════════════════════════════════════════════════════╗ ║ Ein Beispiel für den Präprozessor 3 ║ ╟────────────────────────────────────────────────────────────────╢ ║ ║ ║ gehezu haupt ║ ║ ║ ║ label Unterprogramm ║ ║ blockbegin ║ ║ drucke KONSTANTE ║ ║ blockend ║ ║ ║ ║ label haupt ║ ║ ... ║ ║ gosub Unterprogramm ║ ║ ... ║ ║ ║ ║ const KONSTANTE 2000 ║ ║ ║ ╚════════════════════════════════════════════════════════════════╝ ,,5 ⌐5. Besonderheiten der Atari-ST Version von TXL ⌐══════════════════════════════════════════════ Die TXL-Version für den Atari-ST ist nicht voll kompatibel zur DOS-Version. Durch Eingabe von "COMMANDS" erhalten sie auch hier eine komplette Befehlsübersicht. Die Atari-ST-Version verfügt allerdings über ein paar sehr mächtige zusätzliche Funktionen. Tracer sowie Formelinterpreter und dynamische Strings bieten hier ein weites Feld für jeden Programmierer. Die Funktionen im Detail: Der Tracer ---------- dient wie seine Kollegen gleichen Namens zur Unterstützung bei der Fehler- suche. Zu diesem Zweck wurde er mit folgenden Fähigkeiten ausgestattet: - Nach Ausführung der aktuellen Zeile wird diese angezeigt, woraufhin der Tracer auf eine Tasteneingabe wartet. Die mit Funktionen belegten Tasten werden im folgenden erklärt. - "H" erklärt kurz die Tracerfunktionen. - "V" zeigt alle Variablen mit Namen und Wert an. - "N" erfragt einen Variablennamen und zeigt deren Wert an. - "S" erfragt einen Variablennamen, sowie einen neuen Wert, und setze die Variable auf diesen Wert. - "L" zeigt die aktuelle Zeile noch einmal an. - "A" schaltet den Trace-Modus aus, d.h. der Tracer wird nach ausführen der einzelnen Zeilen nicht mehr aufgerufen. Der Trace-Modus wird durch den Interpreterbefehl " verfolge" wird aktiv. - "B" Beendet das Programm - Die Returntaste führt die nächste Zeile aus. Zur Implementierung : Der Tracer wird durch die Funktion Trace realisiert, welche die aktuelle Zeile anzeigt, auf einen Tastendruck wartet und die dazugehörigen Funktionen ausführt. Der Tracer wird in DoProgram in Abhän- gigkeit der Variablen traceFlag aufgerufen. Zu seiner Steuerung gibt es die Interpreterbefehle : - verfolge : schaltet den Tracer an, und gibt eine entsprechende Meldung aus folgenicht : schaltet den Tracer aus wachhund : um den Tracer für eine einmalig Inspektion der Variablen auf- zurufen ( auch aus dem Direktmodus möglich ); traceFlag wird nicht auf TRUE gesetzt der Wachhund meldet sich mit einem kräftigen "wuff wuff" Die Tracerfunktion "S" ( setze neuen Wert ) verwendet einen kleinen Trick. Um nicht extra eine Eingaberoutine schreiben zu müssen wird der Scanner auf den Eingabepuffer des Tracer's umgelenkt ( LinePos auf den Anfang des Puffer's setzen ), und ReadValue aufgerufen. Einziger Nachteil : Bei Strings müssen die Anführungszeichen mit angegeben werden, da der Scanner die Eingabe sonst nicht als String erkennt. Um das Programm aus dem Tracer heraus zu beenden, wird einfach IntError auf TRUE gesetzt. Folgende Erweiterungen in den einzelnen Modulen sind nötig : - 3 neue Tokens in interp.h - die Prototypen in intprot.h - die Funktionen ctrcon, ctrcoff,cwdog in ibefehle.c realisieren - diese Befehle, Aufrufnamen etc. in die Struktur TokBefDesc in intglob.c eintragen - die Variable traceFlag im selben Modul deklarieren - im Modul itracer.c die eigentliche Tracer-Funktion implementieren - den Modul itracer.c in die Projektdatei eintragen - in DoProgram in interp.c den Tracer aufrufen Eine Erweiterung die nicht mit dem Tracer zusammenhängt, aber ebenfalls bei der Suche nach Fehlern nützlich ist, soll hier erwähnt werden. In der Funktion DoProgram wird im Fehlerfall die fehlerbehaftete Zeile angezeigt, so da₧ man wei₧ wo der Fehler aufgetreten ist: Der Formelinterpreter --------------------- Die Auswertung eines Ausdrucks wurde vollständig umgestrickt, und erlaubt nun auch solche Ausdrücke wie "2*sqr(3+4*x)-min(2,y,4)". Dabei wird die Priorität der Operatoren beachtet. Es sind Funktionen mit mehr als einem Parameter, ja sogar mit einer beliebigen Zahl von Parametern möglich. Ein Beispiel dafür ist die Funktion min (welche, wie nicht schwer zu erraten, das Minimum der übergebenen Werte bestimmt), die sowohl mit einem, mit 2, mit 3 mit ... eben soviel Parametern aufgerufen werden kann, wie auf den Stack passen. Wie wird so ein Ausdruck nun ausgewertet ? Nun, ein Ausdruck ( im Fach- chinesisch Expression gennant ) besteht aus Operanden und Operatoren. Bspiel: 2*3+4*7 Dabei bindet der Operator * die Operanden 2,3,4,7 stärker als der Operator +. Wir können also den Ausdruck in 2 Teilausdrücke 2*3 und 4*7 aufteilen, die durch ein + verbunden sind. So einen Teilausdruck nennen wir fortan Term. Die durch das * verbundenen Operanden nennen wir Faktoren. Gleichrangig zu + ist -, sowie / zu *. Ein Faktor kann jedoch nicht nur eine Zahl sein, wie im obigen Beispiel, sondern auch : - eine Variable : 2*x+3*y - wiederum ein Ausdruck, der durch Klammern eingeschlossen ist : 2*(3+6/x)-2 - ein Funktionsbezeichner wie sin,cos,min,sqr ... in diesem Fall muß eine sich öffnende Klammer, ein Ausdruck und eine sich schließende Klammer folgen 2*sin(3+x)+cos(2)+sqr((4+y)*2). Viel deutlicher als mit Worten, läßt sich dies mit Hilfe des EBNF ( Erweiterten Backus Naur Formalismus ) erklären. Der EBNF ist eine Metasprache, eine Sprache, welche die Beschreibung einer natürlichen Sprache oder einer Programmiersprache ermöglicht. Und solche Ausdrücke wie oben, sind jedem beim Programmieren schon ungezählte male begegnet. Die EBNF verwendet folgende Metasymbole zum Beschreiben der Sprachregeln: | um eine Alternative anzuzeigen : a | b bedeutet entweder a oder b [] um ein ein- oder keinmaliges Vorkommen zu beschreiben [ a ] bedeutet ein a oder kein a {} um eine beliebige Wiederholung auszudrücken {a} kann a aa aaa aaaa aaaaa ... bedeuten in " eingeschlossene Symbole müssen an der Stelle ihres Auftretens stehen. Eine Expression können wir also so beschreiben : Expression = ["+" | "-" ] Term { AddOppearator Term }. Als erstes Symbol einer Expression KANN ein "+" oder ein "-" stehen. Diese beiden Symbole können aber auch fehlen ( siehe [] ). Dann muß ein Term folgen. Darauf können beliebig viele Wiederholungen eines Addoperators, gefolgt von einem Term stehen. Bsp. : - 2 + 3*4 Vorzeichen Term Addoperator Term 4*3 - 2 + 4*x Term AddOperator Term AddOperator Term. Daraus wird auch schon die Erklärung des AddOpeartors ersichtlich AddOpeartor = "+" | "-". Die noch fehlenden Regeln : Term = Faktor { MulOpeartor Faktor } MulOperator = "*" | "/". Faktor = Zahl | Variablenname | "(" Expression ")" | Funktionsname "(" Expression ")". Zahl, Variablenname und Funktionsname dürften klar sein. Die Metasymbole entsprechen im Programm jeweils einer Anweisung. | entspricht z.B. einem if else Konstrukt, {} einer Schleife. Ein weiteres wichtiges Mittel zur Implementierung ist die Rekursion, da die Regeln sich selbst wieder aufrufen, z.B. kann ein Faktor wiederum eine Expression sein. Die Auflösung eines Ausdrucks geschieht also durch wiederholtes ( rekursives )Aufrufen der Funktionen Expression, Term und Faktor. Dabei wird der Ausdruckin die UPN transformiert. 2+3 ergibt also 2 3 +, 2+3*4 2 3 4 * +. Gerade das letzte Beispiel zeigt, das ein Operatorenstack zur Berechnung des Ausdruck's nicht geeignet ist, da er die Priorität der Operatoren nicht gewährleistet. Bei 2+3 muß das "+" also solange zwischengespeichert werden, bis die 3 auch gelesen ist. Dazu eignet sich eine lokale Variable, die auch beim Aufruf von Term erhalten bleibt bestens. Globale Variablen erfüllen diesen Zweck mitnichten. Im Gegensatz zur bisherigen Version werden also nicht alle Operanden und Operatoren zuerst auf den entsprechenden Stack verfrachtet, und dann in einem Rutsch alle Berechnungen durchgeführt ( CalcResult ), sondern sobald alle Werte eines Operatoren auf dem Stack liegen aus Expression, Term oder Faktor heraus CalcResult für EINE Berechnung aufgerufen. Bsp. : 2 * 3 + 4 2 auf Stack -- merke * -- 3 auf Stack -- berechne *, ergibt 6 auf Stack merke + -- 4 auf Stack -- berechne +, ergibt 10 auf Stack CalcResult führt also nur jeweils eine Berechnung durch. Einige Funktionen, z.B. min, die eine unbestimmte Anzahl von Werten auf dem Stack verarbeiten, werden direkt, ohne Umweg über CalcResult, aufgerufen. Tiefer möchte ich auf diese Materie an dieser Stelle nicht eingehen, aber auf [1] und [2] verweisen, wobei vor allem in [2] der EBNF ausführlich erklärt wird, und in beiden ein Programm zur Auswertung von Expressions erstellt wird. Hier nun die bereits zur Verfügung stehenden Funktionen : sqr (Quadrat ), sqrt ( Quardratwurzel ), sin, cos, tan, atan, ln, exp. Zudem die beiden Funktionen min (Minimum) und max (Maximunm). Während die erstgenannten Funktionen genau einen Parameter benötigen, können diese beiden, wie oben bereits erklärt, mit einer variablen Anzahl von Parametern aufgerufen werden. Sie können jedoch wie die anderen in Ausdrücken verwendet werden. Bsp. setze x=sqr(3)+min(a,3,67,b)+23; Um ein ordentliches Ergebnis der Funktionen zu gewährleisten, wurde der Flotype in der Variablendeklaration als float deklariert ( siehe interp.h ). Der Stack verwaltet wie bisher nur einen Zahlentyp, dies ist nun ebenfalls float. Es gibt also keine Möglichkeit eine Integervariable zu deklarieren. Eine Unterscheidung dieser beiden Typen, würde eine Erweiterung des Funktion CalcResult erfordern. Zudem müßten bei gemischten Ausdrücken ( z.B. 2 * 3.5 ) d.h. integer * float, Typumwandlungen vorgenommen werden. Dies ist natürlich möglich, scheint uns aber beim gegenwärtigen Stand der Entwicklung mehr zu verwirren, als zu nützen. Schließlich soll jemand, der sich den Quelltext anschaut, den Überblick behalten. Alle Namen werden in ifuncs ( siehe intutil.c ) aufgenommen. Die Funktion TestFunc ( sie wird in Faktor aufgerufen, wenn ein Bezeichner gefunden wird ), vergleicht den gefundenen Bezeichner mit den vorhandenen Namen und liefert falls gefunden dessen Index. TestFunc arbeitet wie TestBefehl aus interp.c. Da in dieser Version kein Parameterstack mehr verwendet wird, wird der Operator der Funktion CalcResult als Parameter übergeben. Da die Anzahl der benötigten Operanden unterschiedlich ist ( +-*/ benötigen 2, sin,cos ... nur einen ) wird CalcResult als zweiter Parameter die Anzahl der benötigten Opaeranden übergeben. Die Auswertung von Bedingungen ( Compare ) arbeitet nun ebenfalls mit Aus- drücken. Ein Vergleich der Form 2*3+x <= 12-y ist somit möglich. Die benötigten Erweiterungen : - die neuen Prototypen in intprot.h - ändern der Prototypen von CalcResult, Compare und ReadComp - Deklaration der Variablen expOk in intutil.c, die anzeigt, ob die Auswertung eines Ausdrucks reibungslos verlaufen ist - die Funktionsnamen in ifuncs ( ebenfalls in intutil.c ) vereinbaren - die neuen Funktionen implementieren - CalcResult anpassen - die 3 Compare-Funktionen anpassen - Da CalcExpression nun auch von anderen Funktionen als SetVar aufgerufen wird, die nicht immer ein Zeilenende voraussetzen, wurde dieser Test nach SetVar verlagert. - Die Ausgabe funktioniert ebenfalls mit Audrücken : drucke 2*sqr(3) -> 18 - Erweitern des Scanners, sodaß er auch Kommas als Sonderzeichen erkennt, welche zur Trennung der Parameter benötigt werden Dynamische Strings ------------------ WIr haben uns für dynamische Strings entschieden, weil sie dem Anwender am meisten Komfort bieten, nicht so schwer zu implementieren sind, wie man im ersten Moment meint, weil's am meisten Spaß macht. Etwas Sorgfalt verlangt lediglich die Verwaltung des Speichers, den ein dynamischer String belegt. Ist dieser zu klein, können leicht andere wichtige Teile überschrieben werden. Ansonsten werden dynamische Strings ( ab jetzt einfach Strings genannt ) im TXL-Interpreter wie andere Daten auch behandelt. Gleichheit für alle. Natürlich sind nicht alle Operationen die auf Zahlen anwendbar sind, auch aufStrings anwendbar. sin("hallo Baby") geht wohl schlecht, daß hätten wir in Mathe mitbekommen. Dafür gibts aber auch Operationen, die nur mit Strings funktionieren. Trifft der Formelinterpreter also auf einen String, wird dieser auf den Stack verfrachtet, genauer gesagt, der Zeiger auf den String. Die Stringoperationen nehmen diesen Zeiger von Stack, ordnen ihn einem anderen Speicherplatz zu, wenn der Speicher durch die Operation zu klein wird und geben den alten Speicher frei. SetValue, richtet nun einfach VarWert.variable.text auf diesen Speicher aus, und gibt eventuell vorher schon durch diese Variable belegten Speicher wieder frei. Ganz einfach oder ? Die Stringoperatoren : + Verkettet Strings : "hallo"+ " wie "+"geht's" ergibt "hallo iw geht's" * setzt einen String linksbündig ein : "hallo"*"H" ergibt "Hallo" / setzt rechtbündig ein : "abcde"/"--" ergibt "abc--" 'links' liefert eine vorgegebene Anzahl Zeichen von links : links("hallo",2) ergibt "ha" 'rechts' wie links von rechts her : rechts("hallo",2) ergibt "lo" 'mitte' liefert Zeichen mitten aus dem String mitte ("hallalli",3,4) ergibt "lall" 'laenge' liefert die Länge eines String's : laenge("hey") ergibt 3 'suche' liefert die Position, an welcher ein String in einem anderen enthalten ist suche("45","1234567",0) ergibt 3 der 3. Parameter bezeichnet die Startposition der Suche. Das waren Funktionen, nun folgen noch neue Interpreterbefehle: 'kopiere' kopiert Zeichen in eine Stringvariable hinein. s="abcdefg" ergibt kopiere("123",s,1) "a123efg" 'einfuegen' fügt Zeichen ein, ohne andere dadurch zu überschreiben: einfügen("123",s,1 ) ergibt "a123bcdefg" 'loesche' löscht Zeichen. loesche(s,2,3) ergibt "abcfg" kopiere,einfuegen und loesche erwartet dabei an der Stelle an der in den Beispielen s steht eine Stringvariable. An allen anderen Stellen kann auch ein Stringausdruck stehen. Beispiele: mit s="hallo wie geht's" setze l=links(s+" denn so",laenge(s)+5) ergibt "hallo wie geht's denn" kopiere "WIE",s,suche("wie,s,0) ergibt "hallo WIE geht's" setze a="abcdefg"+"hijklm"*"~~"/".." ergibt "abcdefg~~jk.." Zudem sind die üblichen Vergleichsoperatoren auf Strings anwendbar. Die notwendigen Erweiterungen : - 3 neue Tokens in interp.h - die Prototypen in intprot.h - die Funktionen ccopy, cins, cdel in ibefehle.c realisieren - diese Befehle, Aufrufnamen etc. in die Struktur TokBefDesc in intglob.c eintragen - die Vergleiche für String realisieren Zudem wurden 3 Hilfsfunktionen in intutil.c aufgenommen, die zum aufschlüsseln der jeweils benötigten Parameter dienen. Die Erklärung siehe dort. Der lese-Befehl --------------- Syntax : lese Variablenbezeichner lese führt zur Funktion creadvar. Diese ruft Scan auf, und testet ob es sich um einen Bezeichner handelt ( Steuer == ALPHA ). Sodann wird SetVar aufge- rufen. Dadurch ist es auch möglich Ausdrücke zuzuweisen. Alles hat seine 2 Seiten, Strings müßten in " eingeschlossen sein, da sie sonst nicht als solche erkannt werden. Wollen Sie also den Sting "hallo" in die Variable "s" einlesen, müssen Sie "hallo" eingeben. Erweiterungen : - Token - Prototyp - TokBefDesc erweitern - creadvar Zum Schluß noch ein Hinweis auf einen Fehler im Scanner. Nach dem Einlesen von Strings trat ein Fehler auf, da mit dem letzten GetChar schon das erste Zeichen nach dem String gelesen wird. Daher muß dort ein NoSkipChar folgen. Verwendete Hardware : Atari 520 ST+ Programmiersprache : Turbo C 2.0 Literatur : [1] PASCAL international 8/87 CALC ein Mathe-Compiler für Formeln und Funktionen [2] MODULA-2 für Atari ST Ralf Morgenstern Heim-Verlag 1990 Kapitel 10 : Die MODULA-2 Syntax und der EBNF ,,6 ⌐6. TXL unter Windows: Die Befehle ⌐═════════════════════════════════ Die TXL-Version unter Windows verfügt wie alle TXL-Versionen über den vollen deutschen Grundbefehlssatz (siehe toolbox 10'90). Darüber hinaus nutzt es die Windows-Architektur optimal aus. Über die Funktionstasten F7 und F8 läßt sich blitzschnell zwischen Editor und Direktmodus wechseln. Um TXL-Programme zu laden, kann man entweder im Menü auf die Option "laden/load" gehen oder im Direktmodus <load"> mit abschließendem Return eingeben. Danach öffnet sich dann eine Fileselect Box und ermöglicht die interaktive Eingabe eines Filenamens. Mit "RUNB" lassen sich beispielsweise Programme im Hintergrund als einzelner Task starten. Ein Feature, was wesentlich teurere Systeme in dieser Form nicht anzubieten haben. Effektives Multitasking ohne lästige Speicherdefinitionen wird so erstmals unter einem Windows-Interpreter ermöglicht. Teilweise wurden Befehle des DOS-TXL nicht in die Windows-Version übernommen. Durch das offene System der Sprache ist es aber ohne Probleme möglich, sich die benötigten Erweiterungen selbst einzubinden. Die integrierte Hilfsfunktion erleichtert darüber hinaus das Arbeiten mit dem Interpreter. Dabei ist zu beachten, daß der deutsche Grundbefehlssatz nicht in die kontext-sensitive Hilfe implementiert wurde. Die funktionsgleichen englischen Befehle sind jedoch alle in das Hilfesystem integriert. Nachstehend die unter Win-TXL verfügbaren Befehle und die deutschen Anweisungen im Überblick: input liest Numerische Variable ein titlewindow setzt Fenstertitel rectangle zeichnet ausgefülltes Rechteck line zeichnet Linie ellipse zeichnet Kreis/Ellipse roundrect zeichnet ausgefülltes abgerundetes Rechteck arc zeichnet Kreisbogen setpixel zeichnet Punkt movewindow setzt Fenstergröße pie zeichnet unausgef. Tortenstück setprinter setzt Drucker - Display - Context play spielt Note cls löscht Fensterinhalt run startet Programm nicht abbrechbar print schreibt Variable Formeln Strings new neues Programm altes löschen if Wenn dann load Datei laden save Datei sichern goto gehezu end Programmende system Interpreter beenden Alt - F4 rem Bemerkung list Programm auflisten let Varable Wert zuweisen setscreen Druckerspooler aus typeset setze Schriftart llist Listing ausdrucken (später über Editor > 1 Seite) locate Textausgabe lokalisieren polyline zeichnet unausgefülltes Polygon floodfill ausfüllen einer Fläche settextcolor setze Textfarbe 0-15 setbkcolor setze Texthintergrund 0-15 setcolor setze Füllfarbe setpencolor setze Rand - Stiftfarbe msgbox gib Meldungsstring in Box aus viereck zeichnet unausgefülltes Viereck rectline zeichnet unausgefülltes Rechteck/Quadrat inline lese String in Variable for Schleifen next " while " wend " cursor Carret aus- und anschalten runb startet Programm abbrechbar im Multitasking commands listet alle Befehle auf messagebeep Beep readclipboard liest Clipboard-Wert in Variable writeclipboard schreibt Variable oder String ins Clipboard ⌐Der deutsche Grundbefehlssatz ⌐═════════════════════════════ lauf entspricht "run". Startet Programm nicht abbrechbar drucke Funktion wie "print". Gibt Strings, Variablen und Strings aus setze Zuweisungsanweisung, Funktion wie "let" wenn Bedingung, "wenn dann". Entspricht "if" gehezu Sprungbefehl, "gehezu Marke??". Entspricht "goto" ende Beendet ein TXL-Programm. Funktion wie "end" merke Hier läßt sich ein Kommentar einfügen. Funktion wie "rem" liste Führt zum auslisten eines Programms. Funktion wie "list" neu Löscht das aktuelle Programm im Speicher. Entspricht "new" lade Lädt ein TXL-Programm. Alternative zu "load" speichere Speichert ein TXL-Programm. Entspricht "save" verlasse Beendet den TXL-Interpreter. Funktionsgleich mit "system" ,,7 ⌐7. Eigene Befehle unter DOS implementieren ⌐══════════════════════════════════════════ Der Einbau eigener Befehle in die TXL ist nicht besonders schwierig. Das eigentliche Problem liegt darin, wirklich alle nötigen Definitionen in allen notwendigen Dateien bekannt zu machen. An einem kleinen Beispiel wollen wir die Vorgehensweise demonstrieren. Den einfachsten und daher zum Verständnis besten Fall stellt ein neuer Befehl dar, der weder Parameter übernimmt noch zurückliefert. Ein solcher Befehl wäre beispielsweise das Kommando zur Anzeige aller verfügbaren Befehle "COMMANDS". Um also "COMMANDS" zu implementieren, ist als erstes die benötigte Routine zu codieren. - In der Datei "NEUBEF.C" oder einer beliebigen anderen Quelldatei schreiben wir also unsere "COMMANDS"-Routine. "COMMANDS" greift auf die Befehlsstruktur "TokBefDesc[i].Befehl" zurück und ermittelt daraus die Befehlsnamen, was aber für die Darstellung der Einbindung keine Rolle spielt. - In der Datei "INTERP.H" ist entsprechend ein neues Token ein- zutragen. Bei der Windows-TXL-Version sind die Tokens in der Datei "GLOBAL.H" definiert. Neben dem eigentlichen Token ist auch die Konstante für die maximale Anzahl Tokens (TOKMAX) entsprechend zu erhöhen. - Die Prototypen der neuen Funktion sind in "INTPROT.H" einzutragen. - Den oder die neuen Befehle sind in der Struktur "TokBefDesc" einzutragen (Datei "INTGLOB.C". Hier wird auch entschieden, ob der neue Befehl Parameter übergeben bekommt oder nicht. - Befinden sich die neuen Befehle in einer eigenen Source-Datei und nicht in "NEUBEF.C", so ist diese Datei in die Projektdatei einzubinden. ,,8 ⌐8. Die Entstehungsgeschichte der ToolboX Language ⌐═════════════════════════════════════════════════ TXL, die "toolbox language", ist ein nach allen Seiten offenes Interpreterkonzept für PC und Atari-ST. Jedem C-Programmierer wird es damit möglich, sich seine eigene Sprache zu gestalten. Neben der Verwendung der TXL für Schulungszwecke lassen sich auch hervorragend rechnerunabhängige Anwendungen realisieren. Einzige Voraussetzung ist ein ANSI-C Compiler. Das Grundgerüst für den TXL-Interpreter wurde in der Zeitschrift toolbox, Heft 9/10'1990 vorgestellt. Wesentliche Erweiterungen sowie eine Windows-Version wurden im Rahmen eines Wettbewerbs in der toolbox 04'91 veröffentlicht. Bezogen werden kann der aktuelle Grundinterpreter als toolbox-Spezial-XX. Bestellungen richten sie bitte an den DMV-Verlag Postfach 250 3440 Eschwege ,,9 ⌐9. Registrierung ⌐════════════════ Am Anfang stand eine Idee. Der Interpreter zum selbermachen. Ein Sprachenbausatz für Jedermann. Inzwischen sind aus den wenigen Einsendungen megabyte große Erweiterungen geworden und TXL hat Einzug in Lehrbetriebe und Universitäten gefunden. Wohin diese Entwicklung gehen wird, ist noch nicht abzusehen. Mit Sicherheit wird auch der Erfolg- oder Mißerfolg des toolbox-Special-XX darüber entscheiden, ob es vielleicht schon bald einen Compiler zu TXL geben wird. Wenn sie über die aktuelle Entwicklung informiert werden wollen oder eigene Erweiterungen für TXL in der Schublade haben, drucken sie bitte die Datei "REGISTER.TXT" über den DOS-Print-Befehl (PRINT REGISTER.TXT) aus und schicken ihn ausgefüllt direkt an die toolbox Redaktion z.Hd. Ulrich Schmitz Stichwort "TXL-Registrierung" Fuldaer Straße 6 3440 Eschwege