software:diy:andere:gofolio
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen angezeigt.
Beide Seiten der vorigen RevisionVorhergehende Überarbeitung | |||
software:diy:andere:gofolio [21/01/2009 21:01] – typo uxt | software:diy:andere:gofolio [Unbekanntes Datum] (aktuell) – Externe Bearbeitung (Unbekanntes Datum) 127.0.0.1 | ||
---|---|---|---|
Zeile 1: | Zeile 1: | ||
+ | ====== Dokumentation zu Gofolio Version 2.2 (2004) ====== | ||
+ | |||
+ | ===== INHALTSVERZEICHNIS ===== | ||
+ | |||
+ | 1.0 Copyright | ||
+ | 1.1 Vorbemerkung | ||
+ | 2.0 Einleitung | ||
+ | 2.1 Eigenschaften | ||
+ | 2.2 Compilieren und Ausführen von Programmen | ||
+ | 3.0 Der Aufbau von Gofolio-Programmen | ||
+ | 3.1 Beispiel-Programm | ||
+ | 3.2 Bezeichner in Gofolio | ||
+ | 3.2.1 Preprocessor-Anweisungen | ||
+ | 3.3 Variablen | ||
+ | 3.4 Darstellung von Zahlenkonstanten | ||
+ | 3.5 Arrays | ||
+ | 3.6 Strings | ||
+ | 3.7 Dateien | ||
+ | 3.8 Funktionen | ||
+ | 3.8.1 Die Deklaration von Funktionen | ||
+ | 3.8.2 Parameterübergabe | ||
+ | 3.9 Zusammenfassung zum Aufbau von Gofolio-Programmen | ||
+ | 4.0 Operatoren in Gofolio | ||
+ | 4.1 Additive Operatoren | ||
+ | 4.2 Multiplikative Operatoren | ||
+ | 4.3 Relationale Operatoren | ||
+ | 4.4 Der Zuweisungs-Operator := | ||
+ | 5.0 Beschreibung der Gofolio-Funktionen in alphabetischer Reihenfolge | ||
+ | 6.0 Fehlermeldungen des Compilers (GF.EXE) | ||
+ | 7.0 Versionsinformationen | ||
+ | 8.0 Tips | ||
+ | 8.1 Maschinenprogramme unter Gofolio | ||
+ | 8.2 Unterprogramme zur Stringbearbeitung | ||
+ | 8.3 Geschwindigkeitsoptimierung | ||
+ | |||
+ | |||
+ | ===== 1.0 Copyright ===== | ||
+ | |||
+ | GOFOLIO ist Freeware. D.h., sie können mit GOFOLIO kostenlos arbeiten und es beliebig weitergeben. Haben Sie Fragen oder Anregungen zu GOFOLIO, so können sie sich gerne an den Autoren wenden:\\ | ||
+ | \\ | ||
+ | Lutz Herrmann | ||
+ | Lorichsstrasse 35 | ||
+ | 22307 Hamburg. | ||
+ | | ||
+ | E-Mail : windkraft@hotmail.com | ||
+ | Hompage: http:// | ||
+ | \\ | ||
+ | Sollten Sie ein interessantes Programm mit GOFOLIO entwickelt haben, so können Sie es mir gerne zusenden. Ich werde es dann in die Sammlung der Beispielprogramme mitaufnehmen. | ||
+ | |||
+ | ==== 1.1 Vorbemerkung ==== | ||
+ | |||
+ | Bei den weiteren Ausführungen ist die folgende Terminologie zu beachten:\\ | ||
+ | \\ | ||
+ | * Alle Schlüsselworte, | ||
+ | |||
+ | * Soll ausgedrückt werden, daß bestimmte Elemente eines Gofolio-Programms oder einer Gofolio-Funktion als Option vorgesehen sind, so werden diese zwischen spitzen Klammern angegeben, z.B.: < | ||
+ | |||
+ | * Soll ausgedrückt werden, daß ein bestimmtes Element eines Gofolio-Programms oder einer Gofolio-Funktion sich hier beliebig oft wiederholen kann, so wird dies durch 4 aufeinander folgende Punkte angezeigt, z.B.: | ||
+ | Ausdruck, Ausdruck, | ||
+ | Zu beachten ist hierbei auch immer das Zeichen, welches die einzelnen Wiederholungen voneinander trennt (in diesem Fall das Komma).\\ | ||
+ | |||
+ | |||
+ | |||
+ | ===== 2.0 Einleitung ===== | ||
+ | |||
+ | Gofolio ist ein leistungsfähiger Semi-Compiler (GF.EXE) mit Runtime-Modul (GO.EXE). Die mit GF.EXE compilierten Programme enthalten nur den reinen Objekt-Code, | ||
+ | \\ | ||
+ | Gofolio wurde ursprünglich für den Atari-Portfolio entwickelt; Compiler und Runtime-Modul sind daher vom Codeumfang sehr klein gehalten. Gofolio eignet sich daher besonders für alle Dos-Rechner mit kleinem Hauptspeicher bzw. Massenspeicher (Palmtop-/ | ||
+ | \\ | ||
+ | Zu den meisten heute erhältlichen Compilern gehören riesige Laufzeitbibliotheken, | ||
+ | \\ | ||
+ | |||
+ | |||
+ | |||
+ | ==== 2.1 Eigenschaften ==== | ||
+ | |||
+ | Gofolio ist eine eigenständige Programmiersprache. Die Syntax wurde an die Form der Funktionen von Tabellenkalkulations-Arbeitsblättern angelehnt. D.h. alle Befehle und Kontrollstrukturen werden in Form von Funktionen ausgedrückt. Gofolio unterstützt strukturierte Programmierung mit der Möglichkeit zur Definition eigener Funktionen (welche auch rekursiv verwendet werden können), der Bildung von Blöcken sowie der Anwendung von Kontrollstrukturen wie IF.... ELSE ....-Entscheidungen und WHILE-Schleifen. Es stehen die folgenden Datentypen zur Verfügung: | ||
+ | |||
+ | |||
+ | * Charakter (Zeichen) | ||
+ | * Byte (Ganzzahlen 0 bis 255) | ||
+ | * Integer (Ganzzahlen -32768 bis 32767) | ||
+ | * Real (Fließkommazahlen 3.4E-38 bis 3.4E+38). | ||
+ | |||
+ | Von diesen Typen können jeweils beliebig-dimensionale Arrays (Felder) gebildet werden. Arrays vom Typ Char können als Strings (Zeichenketten) verwendet werden. Weiterhin können über vordefinierte Variablen vom Typ Integer die Prozessorregister geladen und gelesen werden (_AX, _BX, _CX, _DX,_SI, _DI, _FI). Gofolio verwaltet maximal 32000 Byte für Daten.\\ | ||
+ | \\ | ||
+ | Gofolio beinhaltet eine Menge Funktionen, welche zum Sprachumfang gehören. U.a. zur formatierten Ein- und Ausgabe von Daten (SCAN, PRINT), zur systemnahen Programmierung (PEEK, POKE, IN, OUT, INTR) sowie mathematische Funktionen (z.B.: SIN, ASIN, COS, ACOS, TAN, ATAN, EXP, LN). Die Ein- und Ausgabefunktionen, | ||
+ | \\ | ||
+ | |||
+ | |||
+ | ==== 2.2 Compilieren und Ausführen von Programmen ==== | ||
+ | |||
+ | Der Programmquelltext muß als reiner ASCII-Text vorliegen. Zur Erstellung eines Programms kann z.B. der DOS-Editor Edit vewendet werden. Der Progamm-Quelltext wird compiliert, indem die Quelltext-Datei GF.EXE als Kommandozeilenparameter übergeben wird. GF.EXE hat nach erfolgreicher Compilierung eine Datei mit der Erweiterung .GFO erstellt. Die Datei mit der Erweiterung .GFO wird ausgeführt, | ||
+ | \\ | ||
+ | Ihre Datei mit dem Programmquelltext heißt myprog.txt. Um myprog.txt zu compilieren geben Sie folgendes ein:\\ | ||
+ | \\ | ||
+ | <code dos> | ||
+ | gf myprog.txt | ||
+ | </ | ||
+ | \\ | ||
+ | GF.EXE hat (wenn kein Fehler aufgetreten ist) die Datei myprog.gfo erzeugt. Um myprog.gfo zu starten geben Sie folgendes ein:\\ | ||
+ | \\ | ||
+ | <code dos> | ||
+ | go myprog | ||
+ | </ | ||
+ | \\ | ||
+ | Das Editieren, Compilieren und Ausführen kann durch die folgende Batch-Datei automatisiert werden:\\ | ||
+ | \\ | ||
+ | <code dos> | ||
+ | @echo off | ||
+ | edit %1 | ||
+ | gf %1.txt | ||
+ | if not errorlevel 1 go %1 | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | ===== 3.0 Der Aufbau von Gofolio-Programmen ===== | ||
+ | |||
+ | |||
+ | ==== 3.1 Beispiel-Programm ==== | ||
+ | |||
+ | Der typische Aufbau eines Gofolio-Programms wird im folgenden anhand eines dokumentierten Beispiels erläutert. Das Programm füllt ein Integer-Array mit Zufallszahlen und sortiert das Array dann aufsteigend. Das Sortieren wird am Bubble-Sort-Algorithmus und am Quick-Sort-Algorithmus demonstriert. Schlüsselworte, | ||
+ | \\ | ||
+ | |||
+ | |||
+ | <code c> | ||
+ | |||
+ | 1: DEFINT(intfeld[1000], | ||
+ | 2: | ||
+ | 3: VOIDTYPE # | ||
+ | 4: BLOCK( | ||
+ | 5: DEFINT(nr), | ||
+ | 6: nr:=0, | ||
+ | 7: WHILE(nr <= n, BLOCK( | ||
+ | 8: intfeld[nr]: | ||
+ | 9: INC(nr)) | ||
+ | 10: ), | ||
+ | 11: | ||
+ | 12: ); | ||
+ | 13: | ||
+ | 14: VOIDTYPE # | ||
+ | 15: BLOCK( | ||
+ | 16: | ||
+ | 17: i:=l, j:=r, | ||
+ | 18: | ||
+ | 19: | ||
+ | 20: | ||
+ | 21: | ||
+ | 22: IF(i <= j, BLOCK( | ||
+ | 23: | ||
+ | 24: | ||
+ | 25: | ||
+ | 26: | ||
+ | 27: )) | ||
+ | 28: ), | ||
+ | 29: IF(l < j, QuickSort(l, | ||
+ | 30: IF(i < r, QuickSort(i, | ||
+ | 31: | ||
+ | 32: ); | ||
+ | 33: | ||
+ | 34: VOIDTYPE # | ||
+ | 35: BLOCK( | ||
+ | 36: | ||
+ | 37: | ||
+ | 38: | ||
+ | 39: | ||
+ | 40: | ||
+ | 41: ), | ||
+ | 42: | ||
+ | 43: ); | ||
+ | 44: | ||
+ | 45: VOIDTYPE # | ||
+ | 46: BLOCK( | ||
+ | 47: | ||
+ | 48: i:=1, | ||
+ | 49: | ||
+ | 50: j:=n, | ||
+ | 51: | ||
+ | 52: | ||
+ | 53: | ||
+ | 54: | ||
+ | 56: | ||
+ | 57: ), | ||
+ | 58: | ||
+ | 59: ), | ||
+ | 60: | ||
+ | 61: ), | ||
+ | 62: | ||
+ | 63: ); | ||
+ | 64: | ||
+ | 65: CLS(); | ||
+ | 66: PRINT(" | ||
+ | 67: FillFeld(anzahl); | ||
+ | 68: QuickSort(0, | ||
+ | 69: @ BubbleSort(anzahl); | ||
+ | 70: PrintFeld(anzahl). | ||
+ | |||
+ | </ | ||
+ | |||
+ | In Zeile 1 werden die globlalen Variablen deklariert. Die globalen Variablen sind vom Typ Integer und werden mit der Funktion DEFINT(Variable,< | ||
+ | Bei der Variablen intfeld handelt es sich um ein eindimensionales Integer-Array mit 1001 Elementen.\\ | ||
+ | Die Variable anzahl ist eine einfache Integer-Variable.\\ | ||
+ | Die ersten Anweisungen in einem Gofolio-Programm müssen immer die Deklarationen der globalen-Variablen sein. Eine Anweisung wird in Gofolio immer mit einem Semikolon beendet.\\ | ||
+ | |||
+ | In Zeile 3 wird die Funktion FillFeld deklariert. VOIDTYPE gibt den Typ der Funktion an. VOIDTYPE bedeutet, daß die Funktion keinen Rückgabewert liefert (Funktionen können weiterhin vom Typ CHARTYPE, INTTYPE und REALTYPE sein, wobei sie den entsprechenden Daten-Typ zurückliefern). Der Name der Funktion wird in der Deklaration immer mit dem #-Zeichen eingeleitet. Sollen der Funktion Parameter übergeben werden können, so werden in Klammern hinter dem Funktionsnamen Variablen deklariert, welche beim Aufruf der Funktion die Parameter aufnehmen. Der Funktion FillFeld kann somit beim Aufruf ein Parameter vom Typ Integer übergeben werden.\\ | ||
+ | Sollen mehrere Parameter übergeben werden, so muß die Reihenfolge der Übergabe der Deklarations-Reihenfolge entsprechen. Die Funktions-Deklaration (Zeile 3) wird mit einem Semikolon abgeschlossen.\\ | ||
+ | \\ | ||
+ | Die Nachfolgende Anweisung stellt den Programm-Code der Funktion FillFeld dar. Wenn der Programm-Code mehrere Anweisungen umfassen soll, so muß er zu einem BLOCK zusammengefaßt werden. Dies geschieht in Zeile 4 durch die Funktion BLOCK(Anweisung, | ||
+ | \\ | ||
+ | Die in einem BLOCK befindlichen Anweisungen werden durch Kommata voneinander getrennt. In Zeile 6 wird der lokalen Variablen nr der Wert 0 zugewiesen. Der Doppelpunkt mit dem Gleichheitszeichen := ist hierbei der Zuweisungsoperator.\\ | ||
+ | \\ | ||
+ | In Zeile 7 beginnt eine WHILE-Schleife. Die Funktion WHILE enthält eine Bedingung sowie eine Anweisung bzw. mehrere in einem BLOCK zusammengefaßte Anweisungen: | ||
+ | \\ | ||
+ | Die Anweisungen in den Zeilen 8 und 9 sind in einen BLOCK zusammengefaßt und werden sooft wiederholt bis nr < = n (Inhalt der Variablen nr kleiner gleich dem Inhalt der Variablen n) ist. Wobei die Variable n der Übergabeparameter an die Funktion FillFeld ist.\\ | ||
+ | \\ | ||
+ | In Zeile 8 wird dem Array-Element des Arrays intfeld mit der Nummer entsprechned dem Inhalt der Variablen nr eine Zufallszahl zwischen 0 und 99 zugewiesen. Die Funktion RND() erzeugt Zufallszahlen zwischen 0 und 30000. Das Prozentzeichen (%) ist der Modulo-Operator, | ||
+ | \\ | ||
+ | In Zeile 9 wird der Inhalt der Variablen nr durch die Funktion INC(Variable) um 1 erhöht (incrementiert). Die Variable nr hätte auch durch die Anweisung nr:=nr+1 um 1 erhöht werden können. Die Variante über INC() wird aber wesendlich schneller ausgeführt. Nach dem die Klammer der Funktion INC() geschlossen wurde, wird die Klammer der Funktion BLOCK() geschlossen.\\ | ||
+ | \\ | ||
+ | In Zeile 10 wird die Klammer der Funktion WHILE() geschlossen. Da WHILE() eine Anweisung innerhalb des BLOCK´s von Zeile 4 ist, wird die nächste Anweisung in Zeile 11 mit einem Komma getrennt.\\ | ||
+ | \\ | ||
+ | In Zeile 11 wird die Funktion FillFeld durch Aufruf der Funktion RETURN() verlassen. Da FillFeld eine VOIDTYPE Funktion ist, also keinen Wert zurückliefert, | ||
+ | \\ | ||
+ | In Zeile 12 wird der Anweisungsblock der Funktion FillFeld geschlossen. Es folgt ein Semikolon, da sämtliche Blöcke verlassen sind.\\ | ||
+ | \\ | ||
+ | In Zeile 14 wird die Funktion QuickSort deklariert. Beim Aufruf von QuickSort können 2 Parameter vom Typ Integer übergeben werden, auf welche innerhalb von QickSort über die Varialen l und r zugegriffen werden kann.\\ | ||
+ | In Zeile 22 wird die Funktion IF() verwendet. IF() enthält eine Bedingung und mindestens eine Anweisung: IF(Bedingung, | ||
+ | \\ | ||
+ | QuickSort ist eine rukursive Funktion, dies zeigen die Zeilen 29 und 30, in denen sich QuickSort selbst aufruft.\\ | ||
+ | \\ | ||
+ | In Zeile 34 wird die Funktion PrintFeld deklariert. PrintFeld enthält in der Zeile 39 die Funktion PRINT(). PRINT() wird verwendet, um Daten auf dem Bildschirm, auf dem Drucker oder in eine Datei auszugeben. In Zeile 39 soll eine Ausgabe auf dem Bildschirm erfolgen. PRINT() hat die folgende Aufrufsyntax: | ||
+ | \\ | ||
+ | In Zeile 65 wird die Funktion CLS() aufgerufen. CLS() bewirkt ein Löschen des Bildschirmes.\\ | ||
+ | \\ | ||
+ | Zeile 66 einthält die Funktion SCAN(). SCAN() ermöglicht ein Einlesen von Daten von der Tastatur oder aus einer Datei in eine Variable. Es gilt die folgende Aufrufsyntax: | ||
+ | \\ | ||
+ | In Zeile 67 wird die oben definierte Funktion FillFeld() aufgerufen, und hierbei der Inhalt der Variablen anzahl als Parameter übergeben.\\ | ||
+ | \\ | ||
+ | In Zeile 68 wird die oben definierte Funktion QuickSort() aufgerufen, und es werden zwei Parameter übergeben.\\ | ||
+ | \\ | ||
+ | Zeile 69 wird vom Compiler ignoriert, da sie mit dem @-Zeichen beginnt. Stößt der Compiler auf das @-Zeichen so wird der folgende Programmtext bis zum Zeilenende überlesen. Diese Methode bietet also die Möglichkeit Kommentare in den Programmtext einzufügen.\\ | ||
+ | \\ | ||
+ | Zeile 70 endet mit einem Punkt. Gofolio-Programme enden immer mit einem Punkt.\\ | ||
+ | \\ | ||
+ | Wenn Sie die Geschwindigkeit der Sortierfunktionen QuickSort() und BubbleSort() vergleichen wollen, so stellen Sie Zeile 69 wieder her und machen Zeile 68 zur Kommentarzeile.\\ | ||
+ | \\ | ||
+ | |||
+ | |||
+ | ==== 3.2 Bezeichner in Gofolio ==== | ||
+ | |||
+ | Gofolio unterscheidet nicht zwischen Groß- und Kleinschreibung. Es bleibt also Ihnen überlassen, | ||
+ | \\ | ||
+ | |||
+ | |||
+ | === 3.2.1 Preprocessor-Anweisungen === | ||
+ | |||
+ | Eine besondere Art von Bezeichnern sind die sog. Preprocessoranweisungen. Dies sind konstante Bezeichner, die am Beginn des Programmtextes stehen und durch das "&" | ||
+ | Schreiben Sie z.B. in die erste Zeile ihres Programmtextes\\ | ||
+ | <code c> | ||
+ | & | ||
+ | </ | ||
+ | so ist im folgenden Quelltext der Bezeicher &Pi immer gleichbedeutend mit 3.14. Bitte beachten Sie, | ||
+ | * dass Preprocessoranweisungen immer vor dem eigentlichen GoFolio-Programm stehen müssen; | ||
+ | * dass eine Preprocessoranweisung mit einem Semikolon endet; | ||
+ | * dass der Preprocessor im Prinzip nur Textersetzungen im Programmquelltext vornimmt. Daher findet keine Typüberprüfung statt; | ||
+ | * das Beispielprogramm pre.txt zur weiteren Erläuterung. | ||
+ | |||
+ | Beispiel: | ||
+ | |||
+ | <code c> | ||
+ | & | ||
+ | & | ||
+ | |||
+ | defreal(r[& | ||
+ | defint(n); | ||
+ | |||
+ | n:=0; | ||
+ | while(n < &rMax, block( | ||
+ | r[n]: | ||
+ | inc(n)) | ||
+ | ); | ||
+ | n:=0; | ||
+ | while(n < &rMax, block( | ||
+ | print(" | ||
+ | inc(n)) | ||
+ | ). | ||
+ | </ | ||
+ | |||
+ | ==== 3.3 Variablen ==== | ||
+ | |||
+ | Zum Erzeugen von Variablen bietet Gofolio die folgenden Funktionen: | ||
+ | |||
+ | * DEFBYTE(Bezeichner, | ||
+ | * DEFCHAR(Bezeichner, | ||
+ | * DEFINT(Bezeichner, | ||
+ | * DEFREAL(Bezeichner, | ||
+ | \\ | ||
+ | Gofolio besitzt eine strenge Typen-Überprüfung. Wollen Sie einer Variablen den Wert einer anderen zuweisen, wobei die andere Variable einen unterschiedlichen Typ hat, so muß dieser Typ in den Typ der Ziel-Variablen gewandelt werden. Andernfalls erhalten Sie einen Syntaxfehler. Lediglich Variablen vom Typ Byte und Integer sind zuweisungskompatibel. Wollen Sie z.B. den Wert der Real-Variable r der Integer-Variablen i zuweisen, so gilt:\\ | ||
+ | <code c> | ||
+ | i:=INT(r) | ||
+ | </ | ||
+ | \\ | ||
+ | Um Typenwandlungen vorzunehmen, | ||
+ | * CHAR(Bezeichner) wandelt in den Typ Charakter, | ||
+ | * INT(Bezeichner) wandelt in den Typ Integer und Byte, | ||
+ | * REAL(Bezeichner) wandelt in den Typ Real. | ||
+ | \\ | ||
+ | |||
+ | ==== 3.4 Darstellung von Zahlenkonstanten ==== | ||
+ | |||
+ | Zahlenkonstanten können in Gofolio in dezimaler und hexadezimaler Schreibweise dargestellt werden. Variablen vom Typ Real können nur Zahlen zugewiesen werden, welche dezimal mit Dezimalpunkt angegeben sind. Variablen vom Typ Integer und Byte können Zahlen in dezimaler Darstellung (ohne Dezimalpunkt !) sowie in hexadezimaler Darstellung zugewiesen werden.\\ | ||
+ | \\ | ||
+ | Hexadezimale Konstanten beginnen immer mit den Zeichen 0x, worauf die Hex-Ziffern folgen (analog zur Programmiersprache C).\\ | ||
+ | \\ | ||
+ | |||
+ | Beispiel: | ||
+ | |||
+ | <code c> | ||
+ | DEFINT(i, | ||
+ | DEFREAL(r); | ||
+ | i:=0xEF11; | ||
+ | n:=100; | ||
+ | r:=100.0; | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | ==== 3.5 Arrays ==== | ||
+ | |||
+ | In Gofolio können Array-Variablen von beliebiger Dimension erzeugt werden. Deklariert werden Array-Variablen mit den Gofolio-Funktionen DEFINT(), DEFCHAR(), DEFBYTE() und DEFREAL(). Wollen Sie ein eindimensionales Integer-Array mit 10 Elementen erzeugen, so geben Sie DEFINT(i[9]) ein. Hinter dem Variablen-Bezeichner schließt für jede Dimension ein Paar eckiger Klammern eine Zahl ein, welche die Anzahl der Elemente für die entsprechende Dimension minus 1 angibt. Anzahl-1 deshalb, weil das erste Element den Index 0 hat. Das letzte Element hat einen Index entsprechend der angegebenen Zahl.\\ | ||
+ | Ein 3-dimensionales Real-Array mit jeweils 20 Elementen pro Dimension, wird wie folgt deklariert: | ||
+ | <code c> | ||
+ | DEFREAL(raum[19][19][19]) | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | |||
+ | ==== 3.6 Strings ==== | ||
+ | |||
+ | Strings (Zeichenketten) werden in Gofolio als Arrays vom Typ Charakter aufgefaßt. Die Behandlung von Strings erfolgt ähnlich wie in der Programmiersprache C; d.h. das letzte Element eines Strings muß immer den Wert 0 (binäre Null) besitzen. Gofolio-Funktionen wie PRINT() oder STRCPY() erkennen so das Ende der Zeichenkette. Das folgende kleine Programm erzeugt einen String und gibt ihn auf dem Bildschirm aus:\\ | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFCHAR(str[20]); | ||
+ | STRCPY(ADDR(str)," | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | Die Gofolio-Funktion: | ||
+ | \\ | ||
+ | STRCPY(Adresse-Zielstring, | ||
+ | \\ | ||
+ | kopiert die String-Constante an die Startadresse von str. Um die Adresse einer Variablen zu ermitteln, steht die Gofolio-Funktion ADDR(Variable) zur Verfügung. ADDR() gibt einen Integer-Wert zurück (welcher den Offset der Variablen im Datensegment darstellt). ADDR(str) ist mit ADDR(str[0]) identisch. Soll das Wort " | ||
+ | Die Gofolio-Funktion PRINT() erwartet, um einen String auszugeben, immer die Adresse des Strings. Von dieser Adresse an werden dann solange Zeichen ausgegeben, bis PRINT() auf eine binäre Null stößt. Soll aus obigem String z.B. nur " | ||
+ | Zeichenketten werden also immer zwischen "" | ||
+ | \\ | ||
+ | \n Zeilenvorschub | ||
+ | \r Wagenrücklauf | ||
+ | \t Tabulator | ||
+ | \f Seitenvorschub | ||
+ | \v Vertikaltabulator. | ||
+ | \\ | ||
+ | Ferner kann, wenn hinter dem Gegenstrich ein x folgt, der ASCII-Code in hexadezimaler Form direkt eingegeben werden.\\ | ||
+ | \\ | ||
+ | Beispiel: | ||
+ | <code c> | ||
+ | DEFCHAR(st1[10], | ||
+ | STRCPY(ADDR(st1), | ||
+ | STRCPY(ADDR(st2), | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | Das Einlesen einer Zeichenkette von der Tastatur wird mit der Gofolio-Funktion SCAN() durchgeführt. SCAN(" | ||
+ | \\ | ||
+ | |||
+ | |||
+ | |||
+ | ==== 3.7 Dateien ==== | ||
+ | |||
+ | Die Bearbeitung von Dateien unterstützt Gofolio mit den folgenden Funktionen: | ||
+ | \\ | ||
+ | * OPENIN(String), | ||
+ | * OPENOUT(String), | ||
+ | * CLOSEIN(), diese Funktion schließt eine mit OPENIN() geöffnete Datei.\\ | ||
+ | * CLOSEOUT(), diese Funktion schließt eine mit OPENOUT() geöffnete Datei.\\ | ||
+ | * EOF(), diese Funktion gibt den Integer-Wert 1 zurück, wenn das Ende der Datei, aus der gerade gelesen wird, erreicht ist. Ist das Datei-Ende noch nicht erreicht gibt EOF() den Wert 0 zurück.\\ | ||
+ | \\ | ||
+ | Geschrieben und gelesen wird in bzw. aus Dateien mit den Funktionen PRINT() bzw. SCAN(), wobei als Aus-/ | ||
+ | In dem folgenden Beispiel werden die beiden Worte "Hallo Welt" in die Datei d1.txt geschrieben und anschließend wieder aus der Datei gelesen und auf dem Bildschirm ausgegeben.\\ | ||
+ | |||
+ | <code c> | ||
+ | DEFCHAR(str[10]); | ||
+ | IF(OPENOUT(" | ||
+ | PRINT(" | ||
+ | HALT()) | ||
+ | ); | ||
+ | PRINT(FILE," | ||
+ | PRINT(FILE," | ||
+ | CLOSEOUT(); | ||
+ | IF(OPENIN(" | ||
+ | PRINT(" | ||
+ | HALT()) | ||
+ | ); | ||
+ | SCAN(FILE," | ||
+ | PRINT(" | ||
+ | SCAN(FILE," | ||
+ | PRINT(" | ||
+ | CLOSEOUT(). | ||
+ | </ | ||
+ | |||
+ | Anstatt Zeichen und Zeichenketten können natürlich auch Zahlen vom Typ Integer, Byte und Real in Dateien geschrieben bzw. aus Dateien gelesen werden.\\ | ||
+ | |||
+ | ==== 3.8 Funktionen ==== | ||
+ | |||
+ | |||
+ | === 3.8.1 Die Deklaration von Funktionen === | ||
+ | |||
+ | Die Deklaration von Funktionen in Gofolio muß immer direkt der Deklaration der globalen Programm-Variablen (wenn denn welche deklariert wurden) folgen. Funktionen können die folgenden Rückgabe-Typen haben:\\ | ||
+ | \\ | ||
+ | * CHARTYPE # | ||
+ | * INTTYPE | ||
+ | * REALTYPE # | ||
+ | * VOIDTYPE # | ||
+ | \\ | ||
+ | Beispielprogamm mit Funktionsdeklaration: | ||
+ | |||
+ | <code c> | ||
+ | DEFCHAR(str[20]); | ||
+ | |||
+ | INTTYPE # | ||
+ | BLOCK( | ||
+ | | ||
+ | n:=0, | ||
+ | | ||
+ | | ||
+ | ); | ||
+ | |||
+ | STRCPY(ADDR(str)," | ||
+ | PRINT(" | ||
+ | |||
+ | </ | ||
+ | \\ | ||
+ | In Zeile 3 des Programms wird die Funktion Pos() deklariert. Pos() liefert einen Rückgabewert vom Typ Interger. Die Funktionsdeklaration wird deshalb mit dem Gofolio-Bezeichner INTTYPE eingeleitet. In der Deklarationsphase folgt jetzt das #-Zeichen, welches die Deklaration des Funktionsnamen einleitet. Zwischen den Klammern hinter dem Funktionsnamen werden die Variablen für eventuelle Funktionsparameter deklariert. Im obigen Fall ist es die Variable mit dem Namen ch, und sie ist vom Typ Charakter. Die Zeilen 4-9 enthalten den Progamm-Code der Funktion Pos(). Dieser kann - wie im vorliegenden Fall - zu einem Block zusammengefaßt sein. Er kann aber auch nur aus einer einzelnen Anweisung bestehen - der Gofolio-Funktion RETURN().\\ | ||
+ | Funktionen müssen immer mit RETURN() beendet werden. RETURN() wird verwendet, um eine Funktion zu verlassen sowie um einen Rückgabewert zurückzugeben. Auch VOIDTYPE-Funktionen müssen mit RETURN() verlassen bzw. beendet werden. Allerdings ohne Rückgabewert, | ||
+ | \\ | ||
+ | <code c> | ||
+ | REALTYPE # | ||
+ | RETURN(x*x); | ||
+ | | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | Eine Funktion kann wiederum eine andere Funktion aufrufen, wenn diese vor der rufenden Funktion deklariert wurde. Wie an dem kommentierten Programmbeispiel gezeigt, kann eine Funktion sich auch selbst aufrufen (Rekursion). In Gofolio ist es nicht möglich innerhalb einer Funktion weitere Funktionen - also funktionslokale Funktionen - zu deklarieren.\\ | ||
+ | Beispiel zum Thema Funktion ruft Funktion:\\ | ||
+ | \\ | ||
+ | <code c> | ||
+ | REALTYPE # | ||
+ | RETURN(x*x); | ||
+ | | ||
+ | REALTYPE # | ||
+ | RETURN(HochZwei(x)*HochZwei(x)); | ||
+ | | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | |||
+ | === 3.8.2 Parameterübergabe === | ||
+ | |||
+ | Den Funktionen können beliebig viele Parameter (Argumente) übergeben werden. Hierzu werden - wie oben schon gezeigt - zwischen den Klammern hinter dem Funktionsbezeichner Variablen deklariert, über die auf die Übergabeparameter zugegriffen werden kann. Diese Variablen werden als formale Parameter bezeichnet. Die formalen Parameter können vom Typ Charakter, Byte, Integer sowie Real sein.\\ | ||
+ | Bei den Typen Integer und Byte ist es bezüglich der Parameterübergabe egal welchen Sie verwenden. Die Verwendung von Byte ist hier nicht sparsamer. Ich empfehle für den Fall der Formalparameter-Deklaration eine Beschränkung auf die Typen Charakter, Integer und Real. Die Parameter-übergabe erfolgt immer als Wertübergabe. D.h. wird beim Funktionsaufruf als Parameter eine Variable aus dem rufenden Progammteil übergeben, so wird deren Inhalt nicht durch die aufgerufene Funktion verändert. Die Positionen der Übergabeparameter beim Aufruf der Funktion müssen immer mit denen der formalen Parameter exakt übereinstimmen. Übergeben werden die Parameter jeweils getrennt durch ein Komma.\\ | ||
+ | \\ | ||
+ | Beispiel: | ||
+ | \\ | ||
+ | <code c> | ||
+ | VOIDTYPE # | ||
+ | BLOCK( | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | RETURN() | ||
+ | ); | ||
+ | | ||
+ | Test(123, | ||
+ | </ | ||
+ | \\ | ||
+ | Der Compiler überprüft hierbei nicht, ob Sie beim Aufruf der Funktion die Parameter bezüglich Anzahl und Position korrekt übergeben haben. Sollte dies nicht der Fall sein, so stürzt Ihr Programm mit Sicherheit ab.\\ | ||
+ | \\ | ||
+ | |||
+ | === 3.8.3 Lokale Variablen === | ||
+ | |||
+ | Innnerhalb von Funktionen können Variablen deklariert werden. Die Deklarationen dieser lokalen Variablen müssen die ersten Anweisungen in einer Funktion sein. Die so erzeugten Variablen haben nur Gültigkeit innerhalb der Funktion, in welcher sie deklariert wurden. Es kann also weder vom Hauptprogramm noch von einer evt. rufenden Funktion auf sie zugegriffen werden. Die Namen der lokalen Variablen können identisch mit globalen Variablen aus dem Hauptprogramm sein. Ein Zugriff auf eine solche Variable innerhalb einer Funktion bezieht sich dann immer auf die lokale Variable. Grundsätzlich kann aber von Funktionen aus auf jede globale Programm-Variable zugegriffen werden (wenn sie nicht den selben Namen wie eine lokale Variable trägt).\\ | ||
+ | Ruft eine Funktion eine andere Funktion, so kann die gerufene Funktion nicht auf die lokalen Variablen der rufenden Funktion zugreifen. Ferner ist zu beachten, daß ein Name einer lokalen Variablen nicht identisch sein darf mit einem Namen eines formalen Parameters der entsprechenden Funktion. Denn die formalen Parameter sind praktisch ebenfalls lokale Variablen.\\ | ||
+ | \\ | ||
+ | |||
+ | |||
+ | ==== 3.9 Zusammenfassung zum Aufbau von Gofolio-Programmen ==== | ||
+ | |||
+ | Beim Aufbau eines Gofolio-Programms muß also die folgende Reihenfolge beachtet werden:\\ | ||
+ | |||
+ | - < | ||
+ | - < | ||
+ | - < | ||
+ | - < | ||
+ | - < | ||
+ | - < | ||
+ | - RETURN(< | ||
+ | - < | ||
+ | - Letzte Anweisung. | ||
+ | \\ | ||
+ | |||
+ | ===== 4.0 Operatoren in Gofolio ===== | ||
+ | |||
+ | ==== 4.1 Additive Opreatoren ==== | ||
+ | |||
+ | * Additions-Operator + | ||
+ | Dieser Operator kann auf die Typen Byte, Integer und Real angewendet werden. Die Operanden werden addiert. Z.B.: PRINT(" | ||
+ | \\ | ||
+ | * Subtraktions-Operator - | ||
+ | Dieser Operator kann auf die Typen Byte, Integer und Real angewendet werden. Vom linken Operand wird der rechte subtrahiert.\\ | ||
+ | \\ | ||
+ | Z.B.: PRINT(" | ||
+ | \\ | ||
+ | |||
+ | ==== 4.2 Multiplikative Operatoren ==== | ||
+ | |||
+ | * Multiplikations-Operator * | ||
+ | Dieser Operator kann auf die Typen Byte, Integer und Real angewendet werden. Die Operanden werden multipliziert. Z.B.: PRINT(" | ||
+ | \\ | ||
+ | * Divisions-Operator / | ||
+ | Dieser Operator kann auf die Typen Byte, Integer und Real angewendet werden. Der linke Operand wird durch den rechten dividiert.\\ | ||
+ | Z.B.: PRINT(" | ||
+ | \\ | ||
+ | * Modulo-Operator % | ||
+ | Dieser Operator kann nur auf die Typen Byte und Integer angewendet werden. Modulo (Divisionsrest wird gebildet) Z.B.: PRINT(" | ||
+ | \\ | ||
+ | * Operator zum Potenzieren ^ | ||
+ | Dieser Operator kann nur auf den Typ Real angewendet werden. Der linke Operand entspricht der Basis, und der rechte dem Exponenten.\\ | ||
+ | Z.B.: PRINT(" | ||
+ | \\ | ||
+ | |||
+ | |||
+ | ==== 4.3 Relationale Operatoren ==== | ||
+ | |||
+ | * Vergleichs-Operator Gleich = | ||
+ | Kann auf alle Typen angewendet werden. Bildet mit einem linken und einem rechten Operanden (müssen vom gleichen Typ sein) eine Bedingung, welche wahr ist, wenn diese gleich sind.\\ | ||
+ | Z.B.: IF(3 = 4, PRINT(" | ||
+ | \\ | ||
+ | * Vergleichs-Operator Größer-Gleich >= | ||
+ | Kann auf alle Typen angewendet werden. Bildet mit einem linken und einem rechten Operanden (müssen vom gleichen Typ sein) eine Bedingung, welche wahr ist, wenn der linke größer-gleich dem rechten ist. Z.B.: IF(3 >= 4, PRINT(" | ||
+ | \\ | ||
+ | * Vergleichs-Operator Kleiner-Gleich < = | ||
+ | Kann auf alle Typen angewendet werden. Bildet mit einem linken und einem rechten Operanden (müssen vom gleichen Typ sein) eine Bedingung, welche wahr ist, wenn der linke kleiner-gleich dem rechten ist. Z.B.: IF(3 < = 4, PRINT(" | ||
+ | \\ | ||
+ | * Vergleichs-Operator Größer > | ||
+ | Kann auf alle Typen angewendet werden. Bildet mit einem linken und einem rechten Operanden (müssen vom gleichen Typ sein) eine Bedingung, welche wahr ist, wenn der linke größer dem rechten ist. Z.B.: IF(3 > 4, PRINT(" | ||
+ | \\ | ||
+ | * Vergleichs-Operator Kleiner < | ||
+ | Kann auf alle Typen angewendet werden. Bildet mit einem linken und einem rechten Operanden (müssen vom gleichen Typ sein) eine Bedingung, welche wahr ist, wenn der linke kleiner dem rechten ist. Z.B.: IF(3 < 4, PRINT(" | ||
+ | \\ | ||
+ | * Vergleichs-Operator Ungleich <> | ||
+ | Kann auf alle Typen angewendet werden. Bildet mit einem linken und einem rechten Operanden (müssen vom gleichen Typ sein) eine Bedingung, welche wahr ist, wenn diese ungleich sind.\\ | ||
+ | Z.B.: IF(3 <> 4, PRINT(" | ||
+ | \\ | ||
+ | Eine Bedingung gibt für den Fall, daß sie wahr ist, den Wert 1 zurück. Für den Fall, daß die Bedingung nicht wahr ist, wird 0 zurückgegeben. Es ist daher möglich das Ergebnis einer Bedingung einer Variablen zuzuweisen. Der Rückgabewert ist immer vom Typ Integer.\\ | ||
+ | \\ | ||
+ | Beispiel: | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFINT(bool); | ||
+ | bool:=(10.1 > 10.0); | ||
+ | PRINT(" | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | ==== 4.4 Der Zuweisungs-Operator := ==== | ||
+ | |||
+ | Der Zuweisungsoperator kann auf alle Typen angewendet werden. Dem linken Operanden wird der rechte zugewiesen. Beide Operanden müssen vom gleichen Typ sein. Bei dem linken Operanden muß es sich um eine Variable handeln. Der rechte Operand kann eine Variable oder ein Ausdruck sein.\\ | ||
+ | \\ | ||
+ | Z.B.:\\ | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFCHAR(ch); | ||
+ | DEFINT(i, | ||
+ | DEFREAL(r); | ||
+ | |||
+ | ch:=´k´; | ||
+ | i:=135; | ||
+ | r: | ||
+ | a:=i; | ||
+ | a:=i+1; | ||
+ | i: | ||
+ | a:=INT(r); | ||
+ | r: | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ===== 5.0 Beschreibung der Gofolio-Funktionen in alphabetischer Reihenfolge ===== | ||
+ | |||
+ | In diesem Abschnitt werden sämtliche Gofolio-Funktionen nach folgendem Schema beschrieben: | ||
+ | \\ | ||
+ | * Rückgabetyp FUNKTIONSNAME(Prametertyp, | ||
+ | \\ | ||
+ | * Real ABS(Real), | ||
+ | <code c> | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Real ACOS(Real), | ||
+ | <code c> | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Integer ADDR(Variable), | ||
+ | \\ | ||
+ | * Integer AND(Bedingung, | ||
+ | <code c> | ||
+ | IF(AND(1 >= 0, 2 = 2), PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Integer ANDB(Integer, | ||
+ | <code c> | ||
+ | | ||
+ | </ | ||
+ | \\ | ||
+ | * Real ASIN(Real), | ||
+ | <code c> | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Real ATAN(Real), | ||
+ | <code c> | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Void BLOCK(Anweisung, | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFINT(i); | ||
+ | i:=0; | ||
+ | WHILE(i < 100, BLOCK( | ||
+ | | ||
+ | | ||
+ | ) | ||
+ | </ | ||
+ | \\ | ||
+ | < | ||
+ | Sie können die Syntax von GoFolio vereinfachen, | ||
+ | Die einzelnen Anweisungen werden dann nur durch Kommata getrennt. | ||
+ | Obige Programmzeilen würden sich in die folgenden ändern (evt. Funktionsdeklarationen müssen sich | ||
+ | allerdings vor dem BLOCK befinden): | ||
+ | </ | ||
+ | |||
+ | \\ | ||
+ | <code c> | ||
+ | BLOCK( | ||
+ | DEFINT(i), | ||
+ | i:=0, | ||
+ | WHILE(i < 100, BLOCK( | ||
+ | PRINT(" | ||
+ | i:=i+1) | ||
+ | ) | ||
+ | </ | ||
+ | |||
+ | \\ | ||
+ | * Charakter CHAR(alle Typen),\\ wandelt den übergebenen Typ in einen Wert vom Typ Charakter.\\ | ||
+ | \\ | ||
+ | * Void CLOSEIN(Void), | ||
+ | \\ | ||
+ | * Void CLOSEOUT(Void), | ||
+ | \\ | ||
+ | * Void CLS(Void), | ||
+ | \\ | ||
+ | * Real COS(Real), | ||
+ | \\ | ||
+ | * Void DEC(Integer Varable),\\ erniedrigt (decrementiert) den Inhalt der übergebenen Integer-Variablen um 1. Diese Verfahren erfolgt wesendlich effizenter als z.B.: n:=n-1.\\ | ||
+ | \\ | ||
+ | * Void DEFBYTE(Bezeichner, | ||
+ | \\ | ||
+ | * Void DEFCAHR(Bezeichner, | ||
+ | \\ | ||
+ | * Void DEFINT(Bezeichner, | ||
+ | \\ | ||
+ | * Void DEFREAL(Bezeichner, | ||
+ | \\ | ||
+ | * Integer DS(Void),\\ gibt die Segmentadresse des Datensegments zurück. Soll z.B. mit den Funktionen PEEK() oder POKE() auf eine Variable zugegriffen werden, so wird die Adresse des Datensegments in denen sich die Variablen befinden benötigt. Z.B.:\\ | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFINT(i); | ||
+ | i:=10000; | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Void ELSE(Anweisung, | ||
+ | \\ | ||
+ | <code c> | ||
+ | IF(x < y, BLOCK( | ||
+ | print(" | ||
+ | y:=y-1), | ||
+ | ELSE( | ||
+ | print(" | ||
+ | x:=x-1 | ||
+ | ); | ||
+ | </ | ||
+ | \\ | ||
+ | * Integer EOF(Void), | ||
+ | \\ | ||
+ | * Real EXP(Real), | ||
+ | \\ | ||
+ | * Void GOTOXY(Integer, | ||
+ | \\ | ||
+ | * Void HALT(Void), | ||
+ | \\ | ||
+ | * Void IF(Bedingung, | ||
+ | \\ | ||
+ | * Byte IN(Integer), | ||
+ | \\ | ||
+ | * Void INC(Integer), | ||
+ | \\ | ||
+ | * Integer INT(alle Typen),\\ wandelt den übergenbenen Typ in einen Wert vom Typ Integer.\\ | ||
+ | \\ | ||
+ | * Void INTR(Integer), | ||
+ | \\ | ||
+ | <code c> | ||
+ | _AX: | ||
+ | INTR(0x21); | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | Hier noch ein paar Erläuterungen zum Umgang mit den Prozessorregistern unter GoFolio:\\ | ||
+ | Die Register AX, BX usw. sind 16 Bit breit. Sie werden prozessorintern aber noch unterteilt in ein High-Byte (8-Bit) und ein Low-Byte (ebenfalls 8-Bit).\\ | ||
+ | Viele Programmiersprachen erlauben es z.B. das Register AX auf drei Arten anzusprechen: | ||
+ | \\ | ||
+ | * einmal als 16-Bit-Register z.B. mit AX:=0x2eff | ||
+ | * einmal die unteren 8 Bit von AX z.B. mit AL:=0xff | ||
+ | * einmal die oberen 8 Bit von AX z.B. mit AH:=0x2e | ||
+ | \\ | ||
+ | Aus Performence-Gründen gibt es unter Gofolio die Register AL, AH, BL, BH usw. nicht. Sondern sie müssen mit folgendem Trick angesprochen werden (das Beispiel betrifft wieder das AX-Register, | ||
+ | \\ | ||
+ | * beschreiben der unteren 8-Bit von AX: _AX:=0xff (entspr. AL:=0xff) | ||
+ | * beschreiben der oberen 8-Bit von AX: _AX: | ||
+ | * lesen der unteren 8-Bit von AX: bit: | ||
+ | * lesen der oberen 8-Bit von AX: bit: | ||
+ | \\ | ||
+ | * Integer KEY(Void), | ||
+ | \\ | ||
+ | * Real LN(Real),\\ gibt den natürlichen Logarithmus des Arguments zurück.\\ | ||
+ | \\ | ||
+ | * Integer NOT(Bedingung), | ||
+ | \\ | ||
+ | * Integer OPENIN(String), | ||
+ | \\ | ||
+ | * Integer OPENOUT(String), | ||
+ | \\ | ||
+ | * Integer OR(Bedingung, | ||
+ | \\ | ||
+ | * Integer ORB(Integer, | ||
+ | \\ | ||
+ | * Void OUT(Integer, | ||
+ | \\ | ||
+ | * Byte PEEK(Integer, | ||
+ | \\ | ||
+ | * Void POKE(Integer, | ||
+ | \\ | ||
+ | * Void PRINT(< | ||
+ | * < | ||
+ | * - bewirkt eine linksbündige Ausgabe; | ||
+ | * + bewirkt, daß numerische Werte mit ihrem entsprechenden Vorzeichen ausgegeben werden. | ||
+ | * < | ||
+ | * < | ||
+ | * Typ, die Angabe über den Typ des konvertierten Zeichen:\\ | ||
+ | \\ | ||
+ | ^ Typ ^ Ausdruck | ||
+ | | i | Integer | ||
+ | | o | Integer | ||
+ | | u | Integer | ||
+ | | x | Integer | ||
+ | | f | Real | ||
+ | | e | Real | ||
+ | | c | Charakter | ||
+ | | s | String | ||
+ | \\ | ||
+ | Beispiel: | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFINT(i); DEFREAL(r); DEFCHAR(ch[20]); | ||
+ | i:=-1234; | ||
+ | r: | ||
+ | STRCPY(ADDR(ch)," | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | </ | ||
+ | \\ | ||
+ | < | ||
+ | </ | ||
+ | \\ | ||
+ | * Real REAL(alle Typen),\\ wandelt den übergebene Typ in einen Wert vom Typ Real.\\ | ||
+ | \\ | ||
+ | * Void RETURN(Alle Typen),\\ beendet die Funktion, welche momentan bearbeitet wird. Die Funktion, die beendet wurde, gibt den Wert zurück, welcher RETURN() als Argument übergeben wurde. Es ist unbedingt darauf zu achten, daß der Typ des Arguments von RETURN() und der Rückgabe-Typ der Funktion übereinstimmen.\\ | ||
+ | \\ | ||
+ | * Integer RND(Void), | ||
+ | \\ | ||
+ | * Void SCAN(< | ||
+ | % < | ||
+ | |||
+ | * < | ||
+ | * < | ||
+ | \\ | ||
+ | Beispiele: | ||
+ | * SCAN(" | ||
+ | \\ | ||
+ | * SCAN(" | ||
+ | \\ | ||
+ | * SCAN(" | ||
+ | \\ | ||
+ | * Typ, legt fest nach welchen Typ die Daten eingelesen werden sollen:\\ | ||
+ | \\ | ||
+ | ^ Typ ^ Eingabe | ||
+ | | i | Integer (dezimal) | ||
+ | | o | Integer (oktal) | ||
+ | | x | Integer (hexadezimal) | ||
+ | | f | Real | Real | | ||
+ | | s | String | ||
+ | | c | Zeichen | ||
+ | \\ | ||
+ | Beispiel: | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFCHAR(ch[20]); | ||
+ | PRINT(" | ||
+ | SCAN(" | ||
+ | PRINT(" | ||
+ | SCAN(" | ||
+ | PRINT(\nBitte Realwert eingeben: "); | ||
+ | SCAN(" | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | Auch SCAN() stimmt nahezu mit der C-Funktion scanf() überein. Der Unterschied zur C-Funktion besteht bei SCAN() darin, daß nur eine Variable angegeben werden darf und der Format-String nur als Constante (d.h. zwischen Anführungszeichen) angegeben werden darf.\\ | ||
+ | \\ | ||
+ | < | ||
+ | </ | ||
+ | \\ | ||
+ | * Real SIN(Real), | ||
+ | \\ | ||
+ | * Void STRCPY(Integer, | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFCHAR(c1[20], | ||
+ | STRCPY(ADDR(c1), | ||
+ | STRCPY(ADDR(c2), | ||
+ | PRINT(" | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Real TAN(Real), | ||
+ | \\ | ||
+ | * Real VAL(String), | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFCHAR(ch[10]); | ||
+ | STRCPY(ADDR(ch), | ||
+ | r: | ||
+ | r:=r-1.0; | ||
+ | PRINT(" | ||
+ | </ | ||
+ | \\ | ||
+ | * Void WHILE(Bedingung, | ||
+ | \\ | ||
+ | Beispiel:\\ | ||
+ | \\ | ||
+ | <code c> | ||
+ | DEFINT(n); | ||
+ | n:=0; | ||
+ | WHILE(n < 100, BLOCK( | ||
+ | PRINT(" | ||
+ | INC(n)) | ||
+ | ) | ||
+ | </ | ||
+ | \\ | ||
+ | * Integer XORB(Integer, | ||
+ | \\ | ||
+ | |||
+ | ===== 6.0 Fehlermeldungen des Compilers (GF.EXE) ===== | ||
+ | |||
+ | ^Fehlernummer^Bedeutung^ | ||
+ | | 1|" | ||
+ | | 2|" | ||
+ | | 3|"," | ||
+ | | 4|Type-Error (Typen sind nicht kompatibel)| | ||
+ | | 5|Der verwendete Bezeichner wurde schon deklariert| | ||
+ | | 6|": | ||
+ | | 7|" | ||
+ | | 8|Bezeichner erwartet| | ||
+ | | 9|String erwartet| | ||
+ | | 10|Unbekannter Bezeichner| | ||
+ | | 11|" | ||
+ | | 12|";" | ||
+ | | 13|Zahlen-Konstante erwartet| | ||
+ | <note important> | ||
+ | Achtung! Wurde Ihr Programm fehlerfrei compiliert und läuft beim Starten mit GO nicht bzw. stürzt ab, so haben Sie in einer Ihrer selbsgeschriebenen Funktionen sicherlich ein RETURN() vergessen. Überprüfen Sie also, ob Sie Ihre Funktionen immer mit RETURN() verlassen. Dies ist einer die häufigsten Fehler beim Schreiben von GOFOLIO-Programmen. | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | ===== 7.0 Versionsinformationen ====== | ||
+ | Version 1.0 von GF.EXE und GO.EXE (1994) | ||
+ | |||
+ | * Version 1.1 von GF.EXE und GO.EXE (1996):\\ | ||
+ | In den Versionen 1.0 gab es einen Fehler beim Vergleichen von Real-Zahlen, | ||
+ | Auf dem ATARI Portfolio arbeitet GF.EXE teilweise nicht korrekt. Ursache waren hier Compilereinstellungen beim Übersetzen des Programms GF.EXE.\\ | ||
+ | GF.EXE wurde erneut übersetzt und arbeitet jetzt korrekt auf dem ATARI Portfolio.\\ | ||
+ | \\ | ||
+ | * Version 1.2 von GF.EXE und GO.EXE (1996):\\ | ||
+ | Auf älteren ATARI Portfolio Versionen funktioniert das Überschreiben von Dateien nicht korrekt. Dies hatte zur Folge, daß, wenn mit GF.EXE ein Programm erneut übersetzt und somit eine bestehende *.GFO Datei überschrieben wurde, die neu erzeugte *.GFO Datei fehlerhaft war. Man kann dieses Problem umgehen, indem vor einer neuen Compilation die entsprechende *.GFO Datei gelöscht wird (es wird dann also keine Datei überschrieben). Die Version 1.2 von GF.EXE löscht vor dem Schreiben der *.GFO Datei eine evt. vorhandene *.GFO Datei automatisch, | ||
+ | \\ | ||
+ | * Version 1.3 von GF.EXE und GO.EXE (1998):\\ | ||
+ | Die Ausgabe von Byte-Arrays mit der Funktion PRINT() funktionierte teilweise nicht richtig. Dieser Fehler wurde behoben.\\ | ||
+ | \\ | ||
+ | * Version 1.31 von GF.EXE und GO.EXE (1998):\\ | ||
+ | An GO.EXE wurde eine kleine interne Änderung vorgenommen. Das Programm wurde dadurch etwas kleiner und schneller.\\ | ||
+ | \\ | ||
+ | * Version 1.32 von GF.EXE und GO.EXE (1998):\\ | ||
+ | Der interne Puffer für String-Konstenten wurde bei GF.EXE vergrößert.\\ | ||
+ | \\ | ||
+ | * Version 1.33 von GF.EXE und GO.EXE (1998):\\ | ||
+ | Ein Fehler der bei der Verwendung der Funktionen AND() und OR() auftrat wurde behoben.\\ | ||
+ | \\ | ||
+ | * Version 1.50 von GF.EXE und GO.EXE (1998):\\ | ||
+ | GO.EXE wurde überarbeitet. Das Programm wurde dadurch schneller.\\ | ||
+ | \\ | ||
+ | * Version 1.51 von GF.EXE und GO.EXE (1998):\\ | ||
+ | Fehler, die sich bei der Überarbeitung von GO.EXE eingeschlichen haben wurden bereinigt. Die Funktionen PEEK(), POKE() und OUT() arbeiten wieder korrekt.\\ | ||
+ | \\ | ||
+ | * Version 2.0 von GF.EXE und GO.EXE (2001):\\ | ||
+ | GoFolio hat einen Preprocessor erhalten. Sprachumfang und Ausführungsgeschwindigkeit haben sich gegenüber der Version 1.51 nicht geändert.\\ | ||
+ | Genaue Erläuterungen siehe Punkt 3.2.1.\\ | ||
+ | \\ | ||
+ | * Version 2.1 von GF.EXE und GO.EXE (2001):\\ | ||
+ | Der Preprocessor legt eine temporäre Quelltextdatei an. In der Version 2.0 wurde diese Datei auch dann angelegt, wenn wenn keine Preprocessoranweisungen vorhanden waren. In der Version 2.1 wird diese temporäre Datei nur angelegt, wenn tatsächlich Preprocessoranweisungen vorliegen.\\ | ||
+ | \\ | ||
+ | * Version 2.2 von GF.EXE (2004):\\ | ||
+ | Ein Fehler im Preprocessor wurde behoben.\\ | ||
+ | \\ | ||
+ | |||
+ | ===== 8.0 Tips ===== | ||
+ | |||
+ | |||
+ | ==== 8.1 Maschinenprogramme unter Gofolio ==== | ||
+ | |||
+ | Sie haben die Möglichkeit Maschinencode in Ihre Gofolio-Programme zu integrieren. Hierzu schreiben Sie die Hex-Codes des Maschinenprogramms in ein Char-Array (String). Gestartete wird das Maschinenprogramm, | ||
+ | Es ist darauf zu achten, daß die letzte Anweisung in dem Maschinenprogramm immer IRET (Interrupt-Return) ist.\\ | ||
+ | \\ | ||
+ | In dem folgenden Gofolio-Programm wird der (freie) Interrupt 63h auf das Beispiel-Maschinenprogramm, | ||
+ | \\ | ||
+ | Beispiel-Maschinenprogramm: | ||
+ | \\ | ||
+ | <code asm> | ||
+ | PUSH AX | ||
+ | PUSH DX | ||
+ | MOV DL,07 | ||
+ | MOV AH,02 | ||
+ | INT 21 | ||
+ | POP DX | ||
+ | POP AX | ||
+ | IRET | ||
+ | </ | ||
+ | \\ | ||
+ | Gofolio-Programm: | ||
+ | \\ | ||
+ | <code c> | ||
+ | defchar(ch[20]); | ||
+ | defint(off, | ||
+ | off: | ||
+ | strcpy(off," | ||
+ | _ax: | ||
+ | _dx:=off; | ||
+ | intr(0x21); | ||
+ | intr(0x63) | ||
+ | </ | ||
+ | \\ | ||
+ | Mit dem Befehl intr(0x63) wird das Maschinenprogramm gestartet.\\ Der Datenaustausch zwischen Maschinen- und Hauptprogramm kann über die Registervariablen _AX, _BX, _CX usw. erfolgen.\\ | ||
+ | \\ | ||
+ | |||
+ | |||
+ | ==== 8.2 Unterprogramme zur Stringbearbeitung ==== | ||
+ | |||
+ | Gofolio beinhaltet nur wenige Funktionen zur Stringbehandlung. Anhand der Funktionen len() (berechnet die Länge eines Strings) und pos() (berechnet die Position eines Zeichens in einem String) soll demonstriert werden, wie eigene Funktionen zur Stringbehandlung effektiv selbstgeschrieben werden können.\\ | ||
+ | \\ | ||
+ | Beispiel: | ||
+ | \\ | ||
+ | <code c> | ||
+ | defchar(c[50], | ||
+ | |||
+ | inttype # | ||
+ | block( | ||
+ | defint(n), | ||
+ | n:=0, | ||
+ | while(peek(ds(), | ||
+ | return(n) | ||
+ | ); | ||
+ | |||
+ | inttype # | ||
+ | block( | ||
+ | defint(n), | ||
+ | n:=0, | ||
+ | while(char(peek(ds(), | ||
+ | if(len(x) < n, return(-1), return(n)), | ||
+ | ); | ||
+ | |||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | print(" | ||
+ | </ | ||
+ | \\ | ||
+ | |||
+ | ==== 8.3 Geschwindigkeitsoptimierung ==== | ||
+ | |||
+ | Besondes bei der Programmierung der Hardware (z.B. beim Ein-/ | ||
+ | Laufvariablen von WHILE-Schleifen immer als Integer definieren und mit den Funktionen INC() bzw. DEC() erhöhen bzw. erniedrigen. Dies ist wesentlich schneller als z.B.: i:=i+1 bzw. i:=i-1.\\ | ||
+ | Beim Umgang mit Variablen gibt es beträchtliche Geschwindigkeitsunterschiede: | ||
+ | * Am schnellsten arbeiten die globalen Nicht-Array-Variablen. | ||
+ | * Dann folgen lokale Nicht-Array-Variablen | ||
+ | * Dann folgen globale Array-Variablen | ||
+ | * Am langsamsten arbeiten lokale Array-Variablen. | ||
+ | |||