PofoWiki

Die ultimative Informationsquelle zum ATARI Portfolio

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
software:diy:andere:gofolio

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
software:diy:andere:gofolio [21/01/2009 18:01] – Formatierung uxtsoftware:diy:andere:gofolio [Unbekanntes Datum] (aktuell) – Externe Bearbeitung (Unbekanntes Datum) 127.0.0.1
Zeile 71: Zeile 71:
 \\ \\
    
 +
  
 ==== 2.1 Eigenschaften ==== ==== 2.1 Eigenschaften ====
    
-Gofolio ist eine eigenständig 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:\\+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:\\
  
    
Zeile 576: Zeile 577:
 PRINT("%i\n",bool). PRINT("%i\n",bool).
 </code> </code>
 +
  
  
Zeile 585: Zeile 587:
 \\ \\
 <code c> <code c>
-  DEFCHAR(ch); +DEFCHAR(ch); 
-  DEFINT(i,a); +DEFINT(i,a); 
-  DEFREAL(r); +DEFREAL(r); 
-   + 
-  ch:=´k´; +ch:=´k´; 
-  i:=135; +i:=135; 
-  r:=(0.199)^2.0; +r:=(0.199)^2.0; 
-  a:=i; +a:=i; 
-  a:=i+1; +a:=i+1; 
-  i:=INT(ch)-10; +i:=INT(ch)-10; 
-  a:=INT(r); +a:=INT(r); 
-  r:=REAL(ch).+r:=REAL(ch).
 </code>  </code> 
 +
 +
 +
 +
  
 ===== 5.0 Beschreibung der Gofolio-Funktionen in alphabetischer Reihenfolge ===== ===== 5.0 Beschreibung der Gofolio-Funktionen in alphabetischer Reihenfolge =====
Zeile 603: Zeile 609:
 In diesem Abschnitt werden sämtliche Gofolio-Funktionen nach folgendem Schema beschrieben:\\ In diesem Abschnitt werden sämtliche Gofolio-Funktionen nach folgendem Schema beschrieben:\\
 \\ \\
-  * Rückgabetyp FUNKTIONSNAME(Prametertyp, Parametertyp, ....).\\ +  * Rückgabetyp FUNKTIONSNAME(Prametertyp, Parametertyp, ....).\\ Der Typ Void bedeutet hierbei, daß kein Wert zurückgegeben wird bzw., daß keine Parameter übergeben werden.\\
-Der Typ Void bedeutet hierbei, daß kein Wert zurückgegeben wird bzw., daß keine Parameter übergeben werden.\\+
 \\ \\
-  * Real ABS(Real),\\ +  * Real ABS(Real),\\ gibt den Absolutbetrag des Arguments zurück. Z.B.: 
-gibt den Absolutbetrag des Arguments zurück.\\ +<code c> 
-Z.B.: PRINT("%f\n",ABS(-1.23)).\\+PRINT("%f\n",ABS(-1.23)) 
 +</code>
 \\ \\
-  * Real ACOS(Real),\\gibt den Arcuscosinus (in Rad) des Arguments zurück.\\ +  * Real ACOS(Real),\\ gibt den Arcuscosinus (in Rad) des Arguments zurück. Z.B.:  
-Z.B.: PRINT("%f\n,ACOS(3.14)).\\+<code c> 
 +PRINT("%f\n,ACOS(3.14)) 
 +</code>
 \\ \\
-  * Integer ADDR(Variable),\\ +  * Integer ADDR(Variable),\\ gibt die Offset-Addresse einer Variablen (von beliebigem Typ) im Datensegment zurück.\\
-gibt die Offset-Addresse einer Variablen (von beliebigem Typ) im Datensegment zurück.\\+
 \\ \\
-  * Integer AND(Bedingung, <Bedingung>, <Bedingung>, ....),\\ +  * Integer AND(Bedingung, <Bedingung>, <Bedingung>, ....),\\ führt einen logischen Und-Vergleich der einzelnen Bedingungen durch. Gibt den Wert wahr (1) zurück, wenn alle Bedingungen wahr sind. Ist eine Bedingung falsch, so wird der Wert falsch (0) zurückgegeben. Z.B.:\\ 
-führt einen logischen Und-Vergleich der einzelnen Bedingungen durch.\\ +<code c>  
-Gibt den Wert wahr (1) zurück, wenn alle Bedingungen wahr sind.\\ +IF(AND(1 >= 0, 2 = 2), PRINT("wahr"), PRINT("falsch")) 
-Ist eine Bedingung falsch, so wird der Wert falsch (0) zurückgegeben.\\ +</code>
-Z.B.: IF(AND(1 >= 0, 2 = 2), PRINT("wahr"), PRINT("falsch")).\\+
 \\ \\
-  * Integer ANDB(Integer, Integer),\\ +  * Integer ANDB(Integer, Integer),\\ liefert das Ergebnis des bitweisen Und-Vergleiches der beiden Übergabeparameter zurück. Z.B.: 
-liefert das Ergebnis des bitweisen Und-Vergleiches der beiden Übergabeparameter zurück. Z.B.: PRINT("%i\n",ANDB(2,18)).\\+<code c> 
 + PRINT("%i\n",ANDB(2,18)) 
 +</code>
 \\ \\
-  * Real ASIN(Real),\\ +  * Real ASIN(Real),\\ gibt den Arcussinus (in Rad) des Arguments zurück. Z.B.:  
-gibt den Arcussinus (in Rad) des Arguments zurück.\\ +<code c> 
-Z.B.: PRINT("%f\n",ASIN(1.552)).\\+PRINT("%f\n",ASIN(1.552)) 
 +</code>
 \\ \\
-  * Real ATAN(Real),\\ +  * Real ATAN(Real),\\ gibt den Arcustangens (in Rad) des Arguments zurück. Z.B.:  
-gibt den Arcustangens (in Rad) des Arguments zurück.\\ +<code c> 
-Z.B.: PRINT("%f\n",ATAN(1.23)).\\+PRINT("%f\n",ATAN(1.23)) 
 +</code>
 \\ \\
-  * Void BLOCK(Anweisung, <Anweisung>, <Anweisung>, ....),\\ +  * Void BLOCK(Anweisung, <Anweisung>, <Anweisung>, ....),\\ faßt beliebig viele Anweisungen zu einem Block zusammen. Mit anderen Worten: es werden beliebig viele Anweisungen zu einer Anweisung zusammengefaßt. Es ist zu beachten, daß ausserhalb eines Blockes die einzelnen Anweisungen durch Strichpunkte (Semikolon) voneinander getrennt werden.\\ Innerhalb eines Blockes werden die Anweisungen dagegen durch Kommata getrennt. Z.B.:\\
-faßt beliebig viele Anweisungen zu einem Block zusammen. Mit anderen Worten: es werden beliebig viele Anweisungen zu einer Anweisung zusammengefaßt. Es zu beachten, daß ausserhalb eines Blockes die einzelnen Anweisungen durch Strichpunkte (Semikolon) voneinander getrennt werden. +
-\\Innerhalb eines Blockes werden die Anweisungen dagegen durch Kommata getrennt. Z.B.:\\+
 \\ \\
 +<code c>
   DEFINT(i);   DEFINT(i);
   i:=0;   i:=0;
Zeile 642: Zeile 651:
      PRINT("%i\n"),      PRINT("%i\n"),
      i:=i+1)      i:=i+1)
-  ).+  ) 
 +</code>
 \\ \\
 <note> <note>
Zeile 652: Zeile 662:
  
 \\ \\
-<code> +<code c> 
-                        BLOCK( +BLOCK( 
-                          DEFINT(i), +  DEFINT(i), 
-                          i:=0, +  i:=0, 
-                          WHILE(i < 100, BLOCK( +  WHILE(i < 100, BLOCK( 
-                            PRINT("%i\n"), +    PRINT("%i\n"), 
-                            i:=i+1) +    i:=i+1) 
-                          ). +)
 </code> </code>
 +
 \\ \\
-  * Charakter CHAR(alle Typen),\\ +  * Charakter CHAR(alle Typen),\\ wandelt den übergebenen Typ in einen Wert vom Typ Charakter.\\
-wandelt den übergebenen Typ in einen Wert vom Typ Charakter.\\+
 \\ \\
-  * Void CLOSEIN(Void),\\ +  * Void CLOSEIN(Void),\\ schließt die Datei, aus welcher gelesen wurde.\\
-schließt die Datei, aus welcher gelesen wurde.\\+
 \\ \\
-  * Void CLOSEOUT(Void),\\ +  * Void CLOSEOUT(Void),\\ schließt die Datei, in welche geschrieben wurde.\\
-schließt die Datei, in welche geschrieben wurde.\\+
 \\ \\
-  * Void CLS(Void),\\ +  * Void CLS(Void),\\ löscht den Bildschirm.\\
-löscht den Bildschirm.\\+
 \\ \\
-  * Real COS(Real),\\ +  * Real COS(Real),\\ gibt den Cosinus des Argments (in Rad) zurück.\\
-gibt den Cosinus des Argments (in Rad) zurück.\\+
 \\ \\
-  * Void DEC(Integer Varable),\\ +  * 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.\\
-erniedrigt (decrementiert) den Inhalt der übergebenen Integer-Variablen um 1. Diese Verfahren erfolgt wesendlich effizenter als z.B.: n:=n-1.\\+
 \\ \\
-  * Void DEFBYTE(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ +  * Void DEFBYTE(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ deklariert die übergebenen Bezeichner als Variablen vom Typ Byte.\\
-deklariert die übergebenen Bezeichner als Variablen vom Typ Byte.\\+
 \\ \\
-  * Void DEFCAHR(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ +  * Void DEFCAHR(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ deklariert die übergebenen Bezeichner als Variablen vom Typ Charakter.\\
-deklariert die übergebenen Bezeichner als Variablen vom Typ Charakter.\\+
 \\ \\
-  * Void DEFINT(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ +  * Void DEFINT(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ deklariert die übergebenen Bezeichner als Variablen vom Typ Integer.\\
-deklariert die übergebenen Bezeichner als Variablen vom Typ Integer.\\+
 \\ \\
-  * Void DEFREAL(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ +  * Void DEFREAL(Bezeichner, <Bezeichner>, <Bezeichner>, ....),\\ deklariert die übergebenen Bezeichner als Variablen vom Typ Real.\\
-deklariert die übergebenen Bezeichner als Variablen vom Typ Real.\\+
 \\ \\
-  * Integer DS(Void),\\ +  * 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.:\\
-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);   DEFINT(i);
   i:=10000;   i:=10000;
   PRINT("Low-Byte  %i\n", PEEK(DS(),ADDR(i));   PRINT("Low-Byte  %i\n", PEEK(DS(),ADDR(i));
-  PRINT("High-Byte %i\n", PEEK(DS(),ADDR(i)+1).+  PRINT("High-Byte %i\n", PEEK(DS(),ADDR(i)+1) 
 +</code>
 \\ \\
-  * Void ELSE(Anweisung, <Anweisung>, <Anweisung>, ....),\\ +  * Void ELSE(Anweisung, <Anweisung>, <Anweisung>, ....),\\ hat die gleiche Wirkung wie die Gofolio-Funktion BLOCK(). Es erhöht aber die Lesbarkeit Ihres Programmtextes, wenn die Anweisungen des Else-Zweiges der Gofolio IF() Funktion anstatt mit BLOCK() mit ELSE() zusammengefaßt werden. Z.B.:\\
-hat die gleiche Wirkung wie die Gofolio-Funktion BLOCK(). Es erhöht aber die Lesbarkeit Ihres Programmtextes, wenn die Anweisungen des Else-Zweiges der Gofolio IF() Funktion anstatt mit BLOCK() mit ELSE() zusammengefaßt werden. Z.B.:\\+
 \\ \\
 +<code c>
     IF(x < y, BLOCK(     IF(x < y, BLOCK(
       print("x ist kleiner y"),       print("x ist kleiner y"),
Zeile 711: Zeile 712:
       x:=x-1       x:=x-1
     );     );
 +</code>
 \\ \\
-  * Integer EOF(Void),\\ +  * Integer EOF(Void),\\ gibt 1 zurück, wenn das Ende einer Datei, aus welcher gelesen wird, erreicht ist.\\
-gibt 1 zurück, wenn das Ende einer Datei, aus welcher gelesen wird, erreicht ist.\\+
 \\ \\
-  * Real EXP(Real),\\ +  * Real EXP(Real),\\ Berechnet die Exponentialfunktion e^x.\\
-Berechnet die Exponentialfunktion e^x.\\+
 \\ \\
-  * Void GOTOXY(Integer, Integer),\\ +  * Void GOTOXY(Integer, Integer),\\ positioniert den Textcursor entsprechend der beiden übergebenen Integer-Werte, wobei der erste Wert die x-Position angibt, und der zweite die y-Position.\\
-positioniert den Textcursor entsprechend der beiden übergebenen Integer-Werte, wobei der erste Wert die x-Position angibt, und der zweite die y-Position.\\+
 \\ \\
-  * Void HALT(Void),\\ +  * Void HALT(Void),\\ wird diese Funktion aufgerufen, so wird das Programm beendet.\\
-wird diese Funktion aufgerufen, so wird das Programm beendet.\\+
 \\ \\
-  * Void IF(Bedingung, Anweisung1, <Anweisung2>),\\ +  * Void IF(Bedingung, Anweisung1, <Anweisung2>),\\ führt eine Verzweigung in Abhängigkeit der Bedingung durch. Ist die Bedingung wahr (1), so wird Anweisung1 ausgeführt. Ist die Bedingung falsch (0), so wird - wenn vorhanden - Anweisung2 ausgeführt. Ist keine Anweisung2 vorhanden, so wird der Programmlauf mit der nächsten Anweisung nach der IF()-Funktion weitergeführt.\\
-führt eine Verzweigung in Abhängigkeit der Bedingung durch. Ist die Bedingung wahr (1), so wird Anweisung1 ausgeführt. Ist die Bedingung falsch (0), so wird - wenn vorhanden - Anweisung2 ausgeführt. Ist keine Anweisung2 vorhanden, so wird der Programmlauf mit der nächsten Anweisung nach der IF()-Funktion weitergeführt.\\+
 \\ \\
-  * Byte IN(Integer),\\ +  * Byte IN(Integer),\\ list ein Byte aus einer I/O-Adresse, welche durch das Argument angegeben wird, und gibt den Inhalt des Bytes zurück.\\
-list ein Byte aus einer I/O-Adresse, welche durch das Argument angegeben wird, und gibt den Inhalt des Bytes zurück.\\+
 \\ \\
-  * Void INC(Integer),\\ +  * Void INC(Integer),\\ erhöht den Inhalt der übergebenen Integer-Variablen un 1. Dieses Verfahren ist wesendlich effizenter als z.B.: n:=n+1.\\
-erhöht den Inhalt der übergebenen Integer-Variablen un 1. Dieses Verfahren ist wesendlich effizenter als z.B.: n:=n+1.\\+
 \\ \\
-  * Integer INT(alle Typen),\\ +  * Integer INT(alle Typen),\\ wandelt den übergenbenen Typ in einen Wert vom Typ Integer.\\
-wandelt den übergenbenen Typ in einen Wert vom Typ Integer.\\+
 \\ \\
-  * Void INTR(Integer),\\ +  * Void INTR(Integer),\\ führt einen allgemeinen 8086-Software-Interrupt aus. Als Argument wird die Nummer des Interrupt-Vektors übergeben. Die Prozessorregister können hierbei über die folgenden in Gofolio vordefinierten Variablen beschrieben und gelesen werden:\\ _AX, _BX, _CX, _DX, _SI, _DI, _FL.\\ Das folgende Programm-Beispiel ermittelt über den Interrupt 0x21 und dessen Funktion 0x2a den Monat (1 bis 12) sowie den Tag des Monats (1 bis 31):\\
-führt einen allgemeinen 8086-Software-Interrupt aus. Als Argument wird die Nummer des Interrupt-Vektors übergeben. Die Prozessorregister können hierbei über die folgenden in Gofolio vordefinierten Variablen beschrieben und gelesen werden: _AX, _BX, _CX, _DX, _SI, _DI, _FL.\\ +
-Das folgende Programm-Beispiel ermittelt über den Interrupt 0x21 und dessen Funktion 0x2a den Monat (1 bis 12) sowie den Tag des Monats (1 bis 31):\\+
 \\ \\
-        _AX:=256*0x2a; +<code c> 
-        INTR(0x21); +_AX:=256*0x2a; 
-        PRINT("Tag=  %i\n",ANDB(_DX,0x00ff)); +INTR(0x21); 
-        PRINT("Monat=%i\n",ANDB(_DX,0xff00)/256).+PRINT("Tag=  %i\n",ANDB(_DX,0x00ff)); 
 +PRINT("Monat=%i\n",ANDB(_DX,0xff00)/256) 
 +</code>
 \\ \\
 Hier noch ein paar Erläuterungen zum Umgang mit den Prozessorregistern unter GoFolio:\\ Hier noch ein paar Erläuterungen zum Umgang mit den Prozessorregistern unter GoFolio:\\
Zeile 760: Zeile 754:
   * lesen der oberen 8-Bit von AX: bit:=andb(_AX,0xff00)/256 (entspr. bit:=AH)   * lesen der oberen 8-Bit von AX: bit:=andb(_AX,0xff00)/256 (entspr. bit:=AH)
 \\ \\
-  * Integer KEY(Void),\\ +  * Integer KEY(Void),\\ gibt den ASCII-Wert einer gedrückten Taste zurück. Wird keine Taste gedrückt, so wird 0 zurückgegeben.\\
-gibt den ASCII-Wert einer gedrückten Taste zurück. Wird keine Taste gedrückt, so wird 0 zurückgegeben.\\+
 \\ \\
-  * Real LN(Real),\\ +  * Real LN(Real),\\ gibt den natürlichen Logarithmus des Arguments zurück.\\
-gibt den natürlichen Logarithmus des Arguments zurück.\\+
 \\ \\
-  * Integer NOT(Bedingung),\\ +  * Integer NOT(Bedingung),\\ führt eine logische Verneinung der Bedingung durch. Wenn die Bedingung wahr (1) ist, so wird falsch (0) zurückgegeben. Ist die Bedingung falsch (0) so wird wahr (1) zurückgegeben.\\
-führt eine logische Verneinung der Bedingung durch. Wenn die Bedingung wahr (1) ist, so wird falsch (0) zurückgegeben. Ist die Bedingung falsch (0) so wird wahr (1) zurückgegeben.\\+
 \\ \\
-  * Integer OPENIN(String),\\ +  * Integer OPENIN(String),\\ als Argument wird ein Dateiname übergeben. Die betreffende Datei wird zum Lesen geöffnet. Sollte beim Öffnen ein Fehler auftreten (z.B. dadurch, daß die Datei nicht existiert), so wird der Wert 1 zurückgegeben. Im Falle einer fehlerfreien Öffnung der Datei wird der Wert 0 zurückgegeben.\\
-als Argument wird ein Dateiname übergeben. Die betreffende Datei wird zum Lesen geöffnet. Sollte beim Öffnen ein Fehler auftreten (z.B. dadurch, daß die Datei nicht existiert), so wird der Wert 1 zurückgegeben. Im Falle einer fehlerfreien Öffnung der Datei wird der Wert 0 zurückgegeben.\\+
 \\ \\
-  * Integer OPENOUT(String),\\ +  * Integer OPENOUT(String),\\ als Argument wird ein Dateiname übergeben. Die betreffende Datei wird zum Schreiben geöffnet. Sollte beim Öffnen ein Fehler auftreten, so wird der Wert 1 zurückgeben. Im Falle einer fehlerfreien Öffnung der Datei wird der Wert 0 zurückgegeben.\\
-als Argument wird ein Dateiname übergeben. Die betreffende Datei wird zum Schreiben geöffnet. Sollte beim Öffnen ein Fehler auftreten, so wird der Wert 1 zurückgeben. Im Falle einer fehlerfreien Öffnung der Datei wird der Wert 0 zurückgegeben.\\+
 \\ \\
-  * Integer OR(Bedingung, <Bedingung>, <Bedingung>, ....),\\ +  * Integer OR(Bedingung, <Bedingung>, <Bedingung>, ....),\\ führt einen logischen Oder-Vergleich der einzelnen Bedingungen durch. Ist mindestens eine Bedingung wahr (1), so wird wahr (1) zurückgegeben. Sind alle Bedingungen falsch (0), so wird falsch (0) zurückgegeben.\\
-führt einen logischen Oder-Vergleich der einzelnen Bedingungen durch. Ist mindestens eine Bedingung wahr (1), so wird wahr (1) zurückgegeben. Sind alle Bedingungen falsch (0), so wird falsch (0) zurückgegeben.\\+
 \\ \\
-  * Integer ORB(Integer, Integer),\\ +  * Integer ORB(Integer, Integer),\\ liefert den bitweisen Oder-Vergleich der beiden Argumente zurück.\\
-liefert den bitweisen Oder-Vergleich der beiden Argumente zurück.\\+
 \\ \\
-  * Void OUT(Integer, Byte),\\ +  * Void OUT(Integer, Byte),\\ schreibt ein Byte an eine I/O-Adresse, wobei das erste Argument die Adresse angibt, und das zweite Argument den Wert welcher geschrieben werden soll.\\
-schreibt ein Byte an eine I/O-Adresse, wobei das erste Argument die Adresse angibt, und das zweite Argument den Wert welcher geschrieben werden soll.\\+
 \\ \\
-  * Byte PEEK(Integer, Integer),\\ +  * Byte PEEK(Integer, Integer),\\ gibt den Wert des Bytes, welches durch eine Segmentadresse (erstes Argument) und eine Offsetadresse (zweites Argument) spezifiziert ist, zurück.\\
-gibt den Wert des Bytes, welches durch eine Segmentadresse (erstes Argument) und eine Offsetadresse (zweites Argument) spezifiziert ist, zurück.\\+
 \\ \\
-  * Void POKE(Integer, Interger, Byte),\\ +  * Void POKE(Integer, Interger, Byte),\\ schreibt ein Byte (drittes Argument) an die mit Offset (zweites Argument) und Segment (erstes Argument) angegebene Adresse.\\
-schreibt ein Byte (drittes Argument) an die mit Offset (zweites Argument) und Segment (erstes Argument) angegebene Adresse.\\+
 \\ \\
-  * Void PRINT(<Ausgabeeinheit>, String-Const, <Ausdruck>),\\ +  * Void PRINT(<Ausgabeeinheit>, String-Const, <Ausdruck>),\\ gibt zur Ausgabeinheit entsprechend dem in der String-Const angegebenen Format das Ergebnis des Ausdrucks aus. Wird keine Ausgabeeinheit angegeben, so erfolgt die Ausgabe auf dem Bildschirm. Wird der Gofolio-Bezeichner FILE als Ausgabeeinheit angegeben, so erfolgt die Ausgabe in eine zuvor mit der Gofolio-Funktion OPENOUT() geöffneten Datei.\\ Wird der Gofolio-Bezeichner LPT als Ausgabeeinheit angegeben, so erfolgt die Ausgabe an den Drucker (parallele Schnittstelle). Die String-Constante wird auch als Format-String bezeichnet. Er kann normale Zeichen enthalten, die direkt ausgegeben werden. Z.B.: PRINT("Hallo Welt").\\ Die String-Constante kann Konvertierungsanweisungen enthalten, die die Auswertung des als weiteres Argument vorhanden Ausdrucks bestimmen. Die Kovertierungsanweisungen haben die folgende Syntax:\\ % <Flags> <Breite> <.Präzision> Typ.\\ Jede Anweisung beginnt mit einem Prozentzeichen (%). Auf dieses Zeichen folgen:\\ 
-gibt zur Ausgabeinheit entsprechend dem in der String-Const angegebenen Format das Ergebnis des Ausdrucks aus. Wird keine Ausgabeeinheit angegeben, so erfolgt die Ausgabe auf dem Bildschirm. Wird der Gofolio-Bezeichner FILE als Ausgabeeinheit angegeben, so erfolgt die Ausgabe in eine zuvor mit der Gofolio-Funktion OPENOUT() geöffneten Datei.\\Wird der Gofolio-Bezeichner LPT als Ausgabeeinheit angegeben, so erfolgt die Ausgabe an den Drucker (parallele Schnittstelle). Die String-Constante wird auch als Format-String bezeichnet. Er kann normale Zeichen enthalten, die direkt ausgegeben werden. Z.B.: PRINT("Hallo Welt").\\Die String-Constante kann Konvertierungsanweisungen enthalten, die die Auswertung des als weiteres Argument vorhanden Ausdrucks bestimmen. Die Kovertierungsanweisungen haben die folgende Syntax:\\ +    * <Flags>, eine optionale Zeichenfolge, über die die Ausgabe bezüglich Vorzeichen, Dezimalpunkte, führende und folgende Nullen, rechts-/links-bündig festgelegt wird:\\ 
-  % <Flags> <Breite> <.Präzision> Typ. +      *  - bewirkt eine linksbündige Ausgabe; 
-Jede Anweisung beginnt mit einem Prozentzeichen (%). Auf dieses Zeichen folgen:\\ +      *  + bewirkt, daß numerische Werte mit ihrem entsprechenden Vorzeichen ausgegeben werden. 
-    <Flags>, eine optionale Zeichenfolge, über die die Ausgabe bezüglich Vorzeichen, Dezimalpunkte, führende und folgende Nullen, rechts-/links-bündig festgelegt wird:\\ +    * <Breite>, eine optionale Angabe über die minimal auszugebende Zeichenzahl.\\ 
-      - bewirkt eine linksbündige Ausgabe; +    * <.Präzision>, eine optionale Angabe über die maximal auszugebende Zeichenzahl.\\ 
-      + bewirkt, daß numerische Werte werden mit ihrem entsprechenden Vorzeichen ausgegeben werden.+    * Typ, die Angabe über den Typ des konvertierten Zeichen:\\
 \\ \\
-  * <Breite>, eine optionale Angabe über die minimal auszugebende Zeichenzahl.\\ +^  Typ  ^  Ausdruck  ^Ausgabe  ^ 
-\\ +|  i  |  Integer  |signed integer (dezimal)  | 
-  * <.Präzision>, eine optionale Angabe über die maximal auszugebende Zeichenzahl.\\ +|  o  |  Integer  |unsigned integer (oktal)  | 
-\\ +|  u  |  Integer  |unsigned integer (dezimal)  | 
-  * Typ, die Angabe über den Typ des konvertierten Zeichen:\\ +|  x  |  Integer  |unsigned integer (hexadezimal)  | 
-     +|  f  |  Real   |Gleitkommawert, die Anzahl der Nachkommastellen wird durch Präzision festgelegt  | 
-    Typ      Ausdruck         Ausgabe +|  e  |  Real   |Gleitkommawert, welcher mit Exponent ausgegeben wird  | 
-    ================================================== +|  c  |  Charakter  |Zeichen  | 
-    i        Integer          signed integer (dezimal) +|  s  |  String   |Zeichenkette.  |
-    o        Integer          unsigned integer (oktal) +
-    u        Integer          unsigned integer (dezimal) +
-    x        Integer          unsigned integer (hexadezimal) +
-    f        Real             Gleitkommawert, die Anzahl der Nach- +
-                              kommastellen wird durch Präzision festgelegt +
-    e        Real             Gleitkommawert, welcher mit +
-                              Exponent ausgegeben wird +
-    c        Charakter        Zeichen +
-    s        String           Zeichenkette.+
 \\ \\
 Beispiel: Beispiel:
 \\ \\
-    DEFINT(i); DEFREAL(r); DEFCHAR(ch[20]); +<code c> 
-    i:=-1234; +DEFINT(i); DEFREAL(r); DEFCHAR(ch[20]); 
-    r:=SIN(1.0/3.0); +i:=-1234; 
-    STRCPY(ADDR(ch),"Gofolio ist super"); +r:=SIN(1.0/3.0); 
-    print("signed integer: %i\n",i); +STRCPY(ADDR(ch),"Gofolio ist super"); 
-    print("unsigned integer: %u\n",i); +print("signed integer: %i\n",i); 
-    print("unsigned integer (oktal): %o\n",i); +print("unsigned integer: %u\n",i); 
-    print("unsigned integer (hexadezimal): %x\n",i); +print("unsigned integer (oktal): %o\n",i); 
-    print("Gleitkomma: %f\n",r); +print("unsigned integer (hexadezimal): %x\n",i); 
-    print("Gleitkomma: %2.3f\n",r); +print("Gleitkomma: %f\n",r); 
-    print("Gleitkomma: %e\n",r); +print("Gleitkomma: %2.3f\n",r); 
-    print("String: %s\n",ADDR(ch)); +print("Gleitkomma: %e\n",r); 
-    print("Zeichen: %c\,ch[3]).+print("String: %s\n",ADDR(ch)); 
 +print("Zeichen: %c\,ch[3]) 
 +</code>
 \\ \\
-Anzumerken sei - Kenner haben es sicherlich schon bemerkt - , daß die Gofolio-Funktion PRINT() weitgehend der C-Funktion printf() entspricht. PRINT() kann, im Unterschied zur C-Funktion, allerdings nur einen Ausdruck ausgeben. Weiterhin muß der Formatstring immer direkt zwischen den Anführungszeichen angegeben werden - er kann also nicht über ein Array vom Typ Charakter (String) übergeben werden.\\+<note> Kenner haben es sicherlich schon bemerkt - , daß die Gofolio-Funktion PRINT() weitgehend der C-Funktion printf() entspricht. PRINT() kann, im Unterschied zur C-Funktion, allerdings nur einen Ausdruck ausgeben. Weiterhin muß der Formatstring immer direkt zwischen den Anführungszeichen angegeben werden - er kann also nicht über ein Array vom Typ Charakter (String) übergeben werden. 
 +</note>
 \\ \\
-  * Real REAL(alle Typen),\\ +  * Real REAL(alle Typen),\\ wandelt den übergebene Typ in einen Wert vom Typ Real.\\
-wandelt den übergebene Typ in einen Wert vom Typ Real.\\+
 \\ \\
-  * Void RETURN(Alle Typen),\\ +  * 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.\\
-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),\\ +  * Integer RND(Void),\\ gibt eine Zufallszahl zwischen 0 und 30000 zurück.\\
-gibt eine Zufallszahl zwischen 0 und 30000 zurück.\\ +
-\\ +
-  * Void SCAN(<Eingabeeinheit>, String-Const, Variable),\\ +
-liest aus der Eingabeeinheit entsprechend dem in String-Const angegeben Format Daten und schreibt diese in die angegebe Variable. Wird keine Eingabeeinheit angegeben, so liest SCAN() die Daten von der Tastatur. Wird der Gofolio-Bezeichner FILE als Eingabeeinheit angegeben, so liest SCAN() aus einer zuvor mit der Gofolio-Funktion OPENIN() geöffneten Datei. Die String-Constante wird als Format-String bezeichnet. Über den Format-String wird festgelegt, nach welchem Format und Typ die Daten gelesen werden sollen. Es gilt die folgende Sytax:\\+
 \\ \\
 +  * Void SCAN(<Eingabeeinheit>, String-Const, Variable),\\ liest aus der Eingabeeinheit entsprechend dem in String-Const angegeben Format Daten und schreibt diese in die angegebe Variable. Wird keine Eingabeeinheit angegeben, so liest SCAN() die Daten von der Tastatur. Wird der Gofolio-Bezeichner FILE als Eingabeeinheit angegeben, so liest SCAN() aus einer zuvor mit der Gofolio-Funktion OPENIN() geöffneten Datei. Die String-Constante wird als Format-String bezeichnet. Über den Format-String wird festgelegt, nach welchem Format und Typ die Daten gelesen werden sollen. Es gilt die folgende Sytax:\\
   % <Breite> <[Eingabefeld]> Typ.   % <Breite> <[Eingabefeld]> Typ.
-\\ 
-  * <Breite> eine optionale Angabe über die maximal zu lesende Zeichenzahl.\\ 
  
 +  * <Breite> eine optionale Angabe über die maximal zu lesende Zeichenzahl.\\
   * <[Eingabefeld]> eine optionale Angabe, welche das Einlesen von Strings betrifft. Das Einlesen der Zeichen wird beendet, wenn ein Zeichen gelesen wurde, das nicht im Eingabefeld steht. Ist kein Eingabefeld angegeben, so werden alle Zeichen bis zum Lesen eines Whitespace-Zeichens gelesen. Whitespace-Zeichen sind das Leerzeichen, Zeilenvorschub (Return), Tabulator usw.\\   * <[Eingabefeld]> eine optionale Angabe, welche das Einlesen von Strings betrifft. Das Einlesen der Zeichen wird beendet, wenn ein Zeichen gelesen wurde, das nicht im Eingabefeld steht. Ist kein Eingabefeld angegeben, so werden alle Zeichen bis zum Lesen eines Whitespace-Zeichens gelesen. Whitespace-Zeichen sind das Leerzeichen, Zeilenvorschub (Return), Tabulator usw.\\
 \\ \\
-    Beispiele: +Beispiele:
-\\+
       * SCAN("%[abcde]s", ch), dieses Beispiel bewirkt, daß so lange in den String ch eingelesen wird, bis ein Zeichen gelesen wurde, das nicht a,b,c,d oder e war.\\       * SCAN("%[abcde]s", ch), dieses Beispiel bewirkt, daß so lange in den String ch eingelesen wird, bis ein Zeichen gelesen wurde, das nicht a,b,c,d oder e war.\\
 \\ \\
Zeile 863: Zeile 834:
   * Typ, legt fest nach welchen Typ die Daten eingelesen werden sollen:\\   * Typ, legt fest nach welchen Typ die Daten eingelesen werden sollen:\\
 \\ \\
-      Typ     Eingabe                     Variablen-Typ +^  Typ  ^  Eingabe  ^  Variablen-Typ  ^ 
-      ================================================== +|  i  |  Integer (dezimal)  |  Integer  | 
-      i       Integer (dezimal)           Integer +|  o  |  Integer (oktal)  |  Integer  | 
-      o       Integer (oktal)             Integer +|  x  |  Integer (hexadezimal)  |  Integer  | 
-      x       Integer (hexadezimal)       Integer +|  f  |  Real  |  Real  | 
-      f       Real                        Real +|  s  |  String  |  Array of Charakter  | 
-      s       String                      Array of Charakter +|  c  |  Zeichen  |  Charakter  | 
-      c       Zeichen                     Charakter +\\     
- \\     +
 Beispiel: Beispiel:
 \\ \\
-      DEFCHAR(ch[20]); DEFINT(i); DEFREAL(r); +<code c> 
-      PRINT("Bitte String eingeben: "); +DEFCHAR(ch[20]); DEFINT(i); DEFREAL(r); 
-      SCAN("%s",ch); +PRINT("Bitte String eingeben: "); 
-      PRINT("\nBitte Integerwert eingeben: "); +SCAN("%s",ch); 
-      SCAN("%i",i); +PRINT("\nBitte Integerwert eingeben: "); 
-      PRINT(\nBitte Realwert eingeben: "); +SCAN("%i",i); 
-      SCAN("%f",r); +PRINT(\nBitte Realwert eingeben: "); 
-      PRINT("%s\n",ADDR(ch)); +SCAN("%f",r); 
-      PRINT("%i\n",i); +PRINT("%s\n",ADDR(ch)); 
-      PRINT("%f\n",r).+PRINT("%i\n",i); 
 +PRINT("%f\n",r) 
 +</code>
 \\ \\
 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.\\ 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.\\
 \\ \\
-      Hinweis: Sollte es Probleme beim Einlesen eines Zeichens von der Tastatur nach dem Format "%c" geben, so verwenden Sie das Format "%s".\\+<note> Sollte es Probleme beim Einlesen eines Zeichens von der Tastatur nach dem Format "%c" geben, so verwenden Sie das Format "%s". 
 +</note>
 \\ \\
-  * Real SIN(Real),\\gibt den Sinus des Arguments (in Rad) zurück.\\+  * Real SIN(Real),\\ gibt den Sinus des Arguments (in Rad) zurück.\\
 \\ \\
-  * Void STRCPY(Integer, String-Const oder Integer),\\kopiert eine Zeichenkette deren Anfangsadresse als 2. Argument übergeben wird, in einen Speicherbereich, dessen Startadresse mit dem 1. Argument bestimmt wird. Beispiel:\\+  * Void STRCPY(Integer, String-Const oder Integer),\\ kopiert eine Zeichenkette deren Anfangsadresse als 2. Argument übergeben wird, in einen Speicherbereich, dessen Startadresse mit dem 1. Argument bestimmt wird. Beispiel:\\
 \\ \\
 +<code c>
   DEFCHAR(c1[20], c2[20]);   DEFCHAR(c1[20], c2[20]);
   STRCPY(ADDR(c1), "Hallo Welt");   STRCPY(ADDR(c1), "Hallo Welt");
   STRCPY(ADDR(c2), ADDR(c1));   STRCPY(ADDR(c2), ADDR(c1));
   PRINT("String c1: %s\n", ADDR(c1));   PRINT("String c1: %s\n", ADDR(c1));
-  PRINT("String c2: %s\n", ADDR(c2)).+  PRINT("String c2: %s\n", ADDR(c2)) 
 +</code>
 \\ \\
-  * Real TAN(Real),\\gibt den Tangens des Arguments (in Rad) zurück.\\+  * Real TAN(Real),\\ gibt den Tangens des Arguments (in Rad) zurück.\\
 \\ \\
-  * Real VAL(String),\\wandelt eine Zeichenkette in einen Real-Wert. Die Zeichenkette (String) wird als Argument übergeben. Beispiel:\\+  * Real VAL(String),\\ wandelt eine Zeichenkette in einen Real-Wert. Die Zeichenkette (String) wird als Argument übergeben. Beispiel:\\
 \\ \\
 +<code c>
   DEFCHAR(ch[10]); DEFREAL(r);   DEFCHAR(ch[10]); DEFREAL(r);
   STRCPY(ADDR(ch), "1.2345");   STRCPY(ADDR(ch), "1.2345");
   r:=VAL(ADDR(ch));   r:=VAL(ADDR(ch));
   r:=r-1.0;   r:=r-1.0;
-  PRINT("%f\n",r).+  PRINT("%f\n",r) 
 +</code>
 \\ \\
-  * Void WHILE(Bedingung, Anweisung),\\führt die Anweisung sooft aus, wie die Bedingung erfüllt ist, d.h. wahr (1) ist.\\+  * Void WHILE(Bedingung, Anweisung),\\ führt die Anweisung sooft aus, wie die Bedingung erfüllt ist, d.h. wahr (1) ist.\\
 \\ \\
 Beispiel:\\ Beispiel:\\
 \\ \\
 +<code c>
   DEFINT(n);   DEFINT(n);
   n:=0;   n:=0;
Zeile 918: Zeile 896:
     PRINT("%i\n",n),     PRINT("%i\n",n),
     INC(n))     INC(n))
-  ).+  ) 
 +</code>
 \\ \\
-  * Integer XORB(Integer, Integer),\\liefert den bitweisen Exclusiv-Oder-Vergleich der beiden Argumente zurück.\\+  * Integer XORB(Integer, Integer),\\ liefert den bitweisen Exclusiv-Oder-Vergleich der beiden Argumente zurück.\\
 \\ \\
  
Zeile 985: Zeile 964:
  
 ===== 8.0 Tips ===== ===== 8.0 Tips =====
 +
  
 ==== 8.1 Maschinenprogramme unter Gofolio ====  ==== 8.1 Maschinenprogramme unter Gofolio ==== 
Zeile 995: Zeile 975:
 Beispiel-Maschinenprogramm:\\ Beispiel-Maschinenprogramm:\\
 \\ \\
 +<code asm>
   PUSH AX   PUSH AX
   PUSH DX   PUSH DX
Zeile 1003: Zeile 984:
   POP AX   POP AX
   IRET   IRET
 +</code>
 \\               \\              
 Gofolio-Programm: Gofolio-Programm:
 \\ \\
 +<code c>
   defchar(ch[20]);   defchar(ch[20]);
   defint(off,seg);   defint(off,seg);
Zeile 1013: Zeile 996:
   _dx:=off;   _dx:=off;
   intr(0x21);   intr(0x21);
-  intr(0x63).+  intr(0x63) 
 +</code>
 \\ \\
-Mit dem Befehl intr(0x63) wird das Maschinenprogramm gestartet.\\Der Datenaustausch zwischen Maschinen- und Hauptprogramm kann über die Registervariablen _AX, _BX, _CX usw. erfolgen.\\+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 ==== ==== 8.2 Unterprogramme zur Stringbearbeitung ====
Zeile 1024: Zeile 1009:
 Beispiel: Beispiel:
 \\ \\
-<code> +<code c>
 defchar(c[50],ch); defchar(c[50],ch);
  
Zeile 1048: Zeile 1032:
 print("\nlen=%i",len(addr(c))); print("\nlen=%i",len(addr(c)));
 print("\npos=%i",pos(ch,addr(c))). print("\npos=%i",pos(ch,addr(c))).
- 
 </code> </code>
 \\ \\
software/diy/andere/gofolio.1232559377.txt.gz · Zuletzt geändert: 16/02/2024 17:02 (Externe Bearbeitung)