*******************************************************************************
*
*            GFA-BASIC - Das clevere BASIC aus deutschen Landen
*            ==================================================
*              Artikel von Thomas Antoni, 13.10.05 - 23.11.05
*
*                        V O R A B V E R S I O N
*
*******************************************************************************

Inhalt
===============================================================================
- Allgemeines zu GFA-BASIC
- GFA-BASIC für DOS
  . Preise und Lieferformen
  . Die Entwicklungsumgebung
  . Die Spracheigenschaften
  . Der Befehlssatz
  . Erstellung grafischer Bedienungsoberflächen
- GFA-BASIC 16 Bit für MS-Windows 3.x
  . Preise und Lieferformen
  . Die Entwicklungsumgebung
  . Die Spracheigenschaften
  . Der Befehlssatz ((FEHLT noch))
  . Erstellung grafischer Bedienungsoberflächen
- GFA-BASIC 32 Bit für MS-Windows 95...XP
  . Preise und Lieferformen
  . Die Entwicklungsumgebung
  . Die Spracheigenschaften


Allgemeines zu GFA-BASIC
===============================================================================
GFA-BASIC stammt von dem Mönchengladbacher Softwarehaus GFA Software 
Technologies GmbH (www.gfasoft.gfa.net/de/). Die kleine Entwicklungsmannschaft 
um Frank Qstrowski ist eine der wenigen deutschen Compilerschmieden. Ein sehr 
erfolgreiches GFA-Produkt war der äußerst beliebte und leistungsfähige Compiler 
GFA-BASIC für den Atari ST. Dieser kam 1986 auf den Markt. 1988 folgte eine 
nicht ganz so erfolgreiche Version für den Commodore Amiga. Die geringe 
Verbreitung der Amiga-Version lag vermutlich daran, dass der Amiga standardmäßig 
bereits über das leistungsfähige, wenn auch langsame AmigaBASIC verfügte.

Im November 1990 erschien der erste GFA-BASIC-Compiler für MS-DOS. Später 
folgten die Versionen "GFA-BASIC 16 Bit für Windows 3.x" und Ende 1999 
"GFA-BASIC 32 Bit für Windows 95/98/NT/Me/XP".

Es gab sogar Versionen für die Betriebssysteme OS/2 und SCO-Unix, die Ende 1990 
vorgestellt wurden, aber nicht über das Beta-Stadium hinauskamen.

Alle GFA-BASIC-Compiler sind untereinander sehr weitgehend kompatibel.

GFA-BASIC ist wie Q(uick)Basic ein modernes BASIC und dem alten Standard- BASIC 
weit überlegen. Die vielen Befehle zum Steuerung des Programmflusses wie 
IF..THEN...ELSE, DO...LOOP und SELECT...CASE...ENDSELECT machen den GOTO-Befehl 
überflüssig und ermöglichen einen professionellen, sauber strukturierten 
Programmierstil. Da ist es nur konsequent, dass Zeilennummern mehr erforderlich 
und auch nicht erlaubt sind. Mnemotechnische Sprungmarken (Labels) werden aber 
unterstützt, auch wenn diese bei einem gepflegten Programmierstil nicht mehr
erforderlich sind.

Traditionell sind alle GFA-BASIC Compiler (außer der 32-Bit-Version) zu 100% in 
Assembler programmiert und erzeugen hochoptimierten Code. Daher laufen alle 
Aktionen in der Entwicklungsumgebung, die Compiliervorgänge und auch die 
erzeugten Programme mit einer atemberaubenden Geschwindigkeit ab - in vielen 
Fällen sogar noch deutlich schneller als bei dem wegen seiner aberwitzigen 
Geschwindigkeit hochgelobten PowerBASIC. Die GFA-BASIC- Entwicklungsumgebung ist 
extrem schlank und benötigt nur wenig Resourcen. Selbst die 32-Bit-Version läuft 
noch problemlos auf einem alten 486er-PC.

Weitere Stärken von GFA-BASIC liegen
- im "Number Crunching" mit einer Vielzahl mathematischer Funktionen
- in der Grafik-Programmierung mit vielen mächtigen Befehlen
- in der extrem einfachen Erstellung grafischer, mausbedienbarer 
  Bedienungsoberfächen mit Menüs und Dialogboxen.

All das erfreut das Herz des Programmierers bereits bei der MS-DOS-Version von 
GFA-BASIC.

Der Haken an GFA-BASIC sind die für Hobby-Programmierer recht hohen Preise. Für 
die DOS-Version zahlt man 128 EUR, die Windows 32-Bit-Version kostet 536 EUR. 
Aber es gibt für alle GFA-BASIC-Varianten Trial-Versionen, die nur in der Anzahl 
der Quellsprachezeilen beschränkt sind und zum Hineinschnuppern in GFA-BASIC 
völlig ausreichen. Ein weiterer Nachteil liegt darin, dass GFA-BASIC heutzutage 
recht wenig verbreitet ist. Es gibt im Internet nur wenig Unterstüzung in Form 
von Tutorials, Foren und downloadbaren Beispielprogrammen.

Heute wird GFA-BASIC leider nicht mehr weiterentwickelt. Die GFA-Webseite 
www.gfasoft.gfa.net ist seit Anfang 2002 offensichtlich nicht mehr aktualisiert 
worden und viele Download-Dateien sind nicht mehr erreichbar. Bestellungen und 
Support- Anfragen werden oft nur sehr schleppend beantwortet. Schade!


GFA-BASIC für DOS
===============================================================================

Preise und Lieferformen
------------------------
- GFA-BASIC für DOS ist leider keine Freeware, sondern kostet happig Geld. Die
  neueste Version ist V4.55. Es gibt drei Lieferformen:
  . Der Interpreter kostet 92 EUR
  . Der Compiler kostet 46 EUR
  . Das Kombipaket mit Interpreter und Compiler kostet 128 EUR
  Außerdem gibt es noch ein dBase-Interface für 25 EUR (alle Preise gemäß der
  GFA-Preisliste von 07/2002)
- Die Firma GFA teilte mir im Jahr 2000 auf eine E-Mail-Anfrage mit, dass es auch
  stark im Preis reduzierte Schüler-Lizenzen gibt.
- Es ist eine kostenlose Trial-Version des Interpreters verfügbar, die auf 333
  Quellsprachezeilen beschränkt ist, ansonsten aber den vollen Funktionsumfang
  hat.
- Beim Interpreter (auch bei der Trial-Version) ist der Compiler GFA2EXE.EXE
  enthalten, der über die Kommandozeile aufgerufen wird und keine eigene
  Bedienoberfläche hat. Damit lassen sich EXE-Dateien erstellen, die für den
  Ablauf allerdings das 96 KB große Runtime-Modul GFABA5IC.OVL benötigen.
- Beim Interpreter wird der "Run-Only-Interpreter" GFARO.EXE mitgeliefert, der
  lizenzfrei zusammen mit erstellten *.GFA-Quellspracheprogrammen an die
  Anwender weitergegeben werden kann und keinen Editor beinhaltet.
- Der Compiler beinhaltet auch einen Linker und hat eine eigene
  Bedienungsoberfläche. Er kann eigenständige EXE-Programme erzeigen, die
  keinerlei Runtime-Module benötigen.

Die Entwicklungsumgebung
------------------------
- Die Entwicklungsumgebung hat einen komfortablen Editor, unterstützt die
  Maus und verfügt über ein Direkt-Fenster. Das Arbeiten mit der Zwischenablage
  ist leider etwas unkomfortabel. Textpassagen lassen sich nicht direkt mit der
  Maus markieren, sondern nur mit "Block"-Befehlen.
- Die Editierfunktionen sind für Personen, die Windows gewohnt sind, etwas
  befremdlich. Will man etwa mitten in einer Zeile  einen Zeilenumbruch einfügen
  so muss man statt der Enter-Taste die Tastenfolge [Strg+P], [Enter], [Strg+O]
  eingeben. An diese Ecken und Kanten kann man sich aber schnell gewöhnen.
  Viele der Tastenbelegungen stammen wohl noch aus der Atari-Version von
  GFA-BASIC.
- Mehrere durch Doppelpunkte voneinander getrennte Befehle in einer Zeile sind
  nicht möglich. In einer Zeile können aber mehrere  Wertzuweisungen stehen, die
  durch Kommas voneinander getrennt sind, z.B. a = 3, b = 4 .
- Bei der Programeingabe im Editor erfolgt eine sofortige Syntax-Kontrolle.
  Ähnlich wie bei QBasic werden Schlüsselworte in Großbuchstaben umgewandelt.
  Bei Syntaxfehler ertönt im Editor bei der Zeilenfortschaltung ein Piepston
  und der Cursor wird auf die Fehlerstelle gesetzt. Aussagekräftige Fehlermelde-
  Texte wie bei QBasic vermisst man aber schmerzlich.
- Viele Befehle sind über Kürzel bequem eingebbar. "f i 1 10" wird z.B. nach
  Betätigen der Eingabetaste automatisch in "FOR i=1 TO 10" umgewandelt.
- Schleifenkörper, IF THEN /ELSE Zweige und SELECT CASE-Passagen werden vom
  Editor automatisch eingerückt. Das ist eine große Erleichterung für die
  Gestaltung gut lesbarer Programme.
- Standardmäßig verwendet GFA-BASIC für Quellspracheprogramme das spezielle  
 .GFA-Format. Mit "File | Write" kann man sein Programm aber auch als 
  normale ASCII-Textdatei abspeichern, die von beliebigen Editoren und 
  Textverarbeitungen lesbar ist. Mit "File | Merge..." lässt sich eine .LST-
  Datei wieder in den GFA-BASIC-Editor einlesen.
- Eine Online-Hilfe wird schmerzlich vermisst. Da wird einem erst klar, wie 
  nützlich die ausgezeichnete, kontextsensitive Online-Hilfe bei QBasic und 
  QuickBASIC ist. Ohne ein häufiges Nachschlagen in der ca. 800 Seiten
  umfassenden gedruckten Dokumentation ist die Erstellung anspruchsvoller
  Programme fast unmöglich. Die Dokumentation ist auch in deutscher Sprache
  erhältlich und wird in Form von zwei dicken Ringhanbüchern ausgeliefert,
  ein Referenzhandbuch und ein Lehrbuch für ausgesuchte Programmiertechniken.
  Wer die Handbücher nicht besitzt, weil er z.B. die Trial-Version verwendet,
  kann sich zur Not mit der Online-Hilfe der Windows 16 Bit Version behelfen,
  deren Befehle weitgehend identisch mit denjenigen der DOS-Version sind.

 Die Spracheigenschaften
 -----------------------
- Es gibt keine 64 KB-Grenze für Programmcode und Variablen. Für Programmcode
  und Daten stehen in Summe ca. 300 KB zur Verfügung. Ein String darf zwar
  wie in anderen BASICs nur 32 KB lang sein, die Gesamtgröße aller Strings
  wird aber nur durch die oben genannte 300-KB-Grenze beschränkt.
- Der erweiterte EMS-Speicher lässt sich zum schnellen Zwischenspeichern von
  Daten nutzen. Mit EVAIL kann man den verfügbaren Speicherplatz im MS-Bereich
  wie folgt abfragen:
    EAVAIL bloecke
    PRINT "Es sind "; bloecke * 16;" KB im EMS-verfuegbar"
  Ist kein EMS-Speicher verfügbar oder reicht seine Größe nicht aus, nährt
  sich GFA-BASIC von einer Auslagerungsdatei auf der Festplatte.
- Zusätzlich zu den gewohnten Datentypen 32-Bit-Gleitpunkt, 16-Bit- und 32-
  Bit- Ganzzahl mit Vorzeichen und String gibt es noch die Datentypen Bit/Bool,
  Byte und maximal 6-dimensionale Felder. Datenstrukturen bzw. Verbundfelder
  werden mit TYPE...END-TYPE unterstützt. Damit unterstützt GFA-BASIC die von
  Pascal als "Records" und von als C/C++ als 'Structures' bekannten Felder
  gemischten Datentyps, um zusammengehörige Datensätze zusammenzufassen.
- Die TYPE-Strukturen sind nicht so flexibel verwendbar wie bei QBasic.
  Insbesondere lässt sich ein Strukturelement nicht direkt in eine Datei
  schreiben. Das ist für Datenbank-Programmierer ein Riesen-Nachteil. So müssen
  Direktzugriffsdateien grundsätzlich mit dem altmodischen FIELD-Puffer
  realisiert werden.
- Kommentar wird mit Hochkomma ', REM oder mit zwei Schrägstrichen //
  eingeleitet. Das Hochkomma darf nicht in PRINT-Befehlen verwendet werden.
- GFA-BASIC kennt Subroutinen (PROCEDUREs) und Funktionen (FUNCTIONs). Die 
  Prozeduren werden mit PROCEDURE...RETURN definiert und mit GOSOB aufgerufen. 
  Funktionen werden mit FUNCTION...RETURN <Rückgabewert>...ENDFUNCTION 
  definiert und mit FN<Funktionsname> aufgerufen. Subroutinen und Funktionen 
  werden im Gegensatz zu QBasic nicht in eigenen Fenstern bearbeitet, lassen 
  sich aber durch die Tastenkombinationen [Alt + W] und [Alt + Q] in der 
  Bildschirmanzeige auf eine Zeile "zusammenfalten" und wieder auffalten. 
  Standardmäßig gelten sämtliche Variablen global, also sowohl im 
  Hauptprogramm als auch in allen Subroutinen und Funktionen. Bei Bedarf 
  können Variablen in einer Subroutine oder Funktion mit dem LOCAL-Befehl 
  gekapselt, also mit lokalem Geltungsbereich deklariert werden.
  
Der Befehlssatz
-------------------------
Der sehr mächtige Befehlssatz umfasst über 500 Befehle (!) und geht weit über
das von anderen BASIC-Dialekten gewohnte hinaus. So gibt es z.B.
- Bitmanipulations-Befehle
- Spezielle Befehle zum Sortieren, Vorbesetzen, Kopieren, Einfügen, Austauschen
  und Löschen von Feldern
- Schiebe- und Rotierbefehle
- Befehle für die Matrizenrechnung: Addition, Subtraktion, Multiplikation,
  Kopieren und Invertierung von Matritzen und Vektoren sind beispielsweise mit
  nur je einem Befehl möglich
- weitere vielfältige mathematische Funktionen wie hyperbolische
  Winkelfunktionen, Umrechnung Grad <-> Bogenmaß, Kombinatorik-Funktionen
  und vieles mehr 
- Mit Hilfe von SSORT und QSORT kann man Textfelder alfabetisch sortieren,
  sogar mit korrekter Behandlung der Umlaute.
- Über 50 Befehle zur Erzeugung eigener grafischer Bedienungsoberflächen
- GFA-BASIC verfügt über sehr leistungsfähige Grafik-Befehle - wohl in alter 
  Tradion der ATARI- und Commdore-Computer. Es gibt einen speziellen Befehl 
  CURVE zum Zeichnen krummer Kurven (Bezierkurven). Mit LOADFONT und FREEFONT 
  kann man bequem eigene Schriftarten erzeugen und laden. Die vorhandene 
  Grafikkarte wird automatisch erkannt und VGA-Modi bis zu einer Auflösung von 
  800 x 600 unterstützt.
- Mit DPEEK und DPOKE lassen sich 16-Bit-Worte direkt an beliebigen 
  Speicheradressen lesen und schreiben. Bei den meisten anderen DOS-BASICs ist 
  nur ein byteweises Lesen und Schreiben möglich. Außerdem gibt es LPEEK/LPOKE 
  und PEEK$/POKE$ zum Lesen und Schreiben von Doppelworten und Strings.


Erstellung grafischer Bedienungsoberflächen
-------------------------------------------
Eine große Stärke von GWA-BASIC liegt in der bequemen Erstellung grafischer 
Windows-ähnlicher Bedienungsoberflächen mit Mausbedienung, Menüs, Fenstern und 
Dialogboxen. All diese Dinge sind atemberaubend einfach und oft mit wenigen 
Befehlszeilen realisierbar. Hinsichtlich der Oberflächen-Programmierung ist GFA-
BASIC QuickBASIC weit überlegen und kommt fast an die Mächtigkeit von 
VisualBASIC für DOS heran. 
- Die Maus wird direkt durch spezielle Befehle unterstützt. Ein Maustest-
  programm kann man mit wenigen Befehlen hinschreiben:
     SCREEN 18
     DO
       LOCATE 4 ,4
       PRINT MOUSEX, MOUSEY, MOUSEK
                           // Mauskoordinaten und Maustastenstatus anzeigen
     LOOP UNTIL MOUSEK = 3 // Abbruch mit rechter+linker Maustaste gleichzeitig
  Für die Form des Mauszeigers gibt es 8 Varianten, die mit DEFMOUSE wählbar sind.
- Eine komfortable Dateiauswahl-Box wird durch den FILESELECT-Befehl
  unterstützt. Diese Funktion wird bei Q(uick)Basic und PowerBASIC von vielen
  Anwendern schmerzlich vermisst. Ein einfachen Textdatei-Viewer mit
  Dateiauswahldialog sieht in GFA-BASIC etwa so aus:
     FILESELECT "", "", datei$
     OPEN datei$ FOR INPUT AS #1
     DO
       LINE INPUT #1, zeile$
       PRINT zeile$
     LOOP
     CLOSE #1
- Der ALERT-Befehl gibt eine kleine Nachrichten- und Auswahlbox mit bis zu 5
  Klickbuttons auf den Bildschirm aus. Die folgende Programmpassage bietet z.B.
  dem Anwender bei einer nicht gefundenen Datei die Buttons "Wiederholen" oder
  "Abbrechen" zum Anklicken mit der Maus an :
     ALERT 3, "Die Datei existiert nicht", 1, "_Wiederholung |_Abbruch", wahl
     PRINT wahl //Anzeige "1" wenn Wiederholung, "2" wenn Abbruch geklickt
  ((Screenshot: siehe AlertBox.gif))
  Nach dem Mausklick wird die Nummer des Buttons in der Variablen wahl
  zurückgeliefert, die Nachrichtenbox gelöscht und der alte Bildschirminhalt
  wieder hergestellt.
- Mausbedienbare Pulldownmenüs sind mit wenigen Befehlszeilen realisierbar.
  Das folgende Programm erzeugt z.B. ein Pulldown-Menü "Datei" mit den 3
  Optionen "Datei", "Oeffnen" und "Beenden". In der Subroutine "auswahl"
  werden Menüpunkte bearbeitet, die mit der Maus aktiviert sind.
     SCREEN 18      //VGA-Bildschirm
     DIM punkt$(5)  //Menue-Eintraege definieren
     punkt$(0)="Datei"
     punkt$(1)="_Oeffnen"
     punkt$(2)="_Konvertieren"
     punkt$(3)="_Beenden"
     punkt$(4)=""   //Ende-Kriterium = 2 Leerstrings
     punkt$(5)=""
     MENU punkt$()  //Menue anzeigen
     OPENW #0       //Menue schuetzen
     ON MENU GOSUB auswahl  //Menuebearbeitung ereignisgesteuert anspringen
     DO
       ON MENU      //Menue in Dauerschleife abfragen
     LOOP
     // Subroutine "auswahl" wird bei Auswahl eines Menuepunktes angesprungen
     //MENU(0) liefert die Nummer auswaehlten Menuepunktes
     // zurueck
     PROCEDURE auswahl
       PRINT MENU(0), punkt$(MENU(0)) //Aktivierten Menuepunkt anzeigen
       IF MENU(0) = 3 THEN END        //Beenden wenn 3.Menuepunkt aktiviert
     RETURN
  ((Screenshot: siehe Menux.gif))
- Fenster sind im Textmode mit TBOX bequem anzeigbar, wie das folgende
  Beispiel zeigt:
    SCREEN 3                 // Textscreen 80*25 Zeichen
    TCOLOR $17               // Textfarbe Weiss auf Blau
    TBOX 2,20,4,70,18        // Box mit Doppellinien (2) von (20|4) nach (70|18)
                             // Breite=50, Hoehe=10
    TCLIP 21,5 TO 69,17      // Clip-Bereich fuer Printausgabe definieren
    FOR i=1 TO 39
      PRINT "Thomas Antoni - ";
    NEXT i



GFA-BASIC 16 Bit für MS-Windows 3.x
===============================================================================

Preise und Lieferformen
------------------------
Alle Preise gemäß der GFA-Preisliste von 07/2002
- GFA-BASIC 16 Bit für Windows 3.0 und 3.1 und 3.11 für Workgroups gibt es in
  drei Lieferformen:
  . Der Interpreter kostet 153 EUR
  . Der Compiler kostet 61,50 EUR
  . Das Kombipaket mit Interpreter und Compiler kostet 200 EUR
  Die neueste Version ist V4.38.
- Zusätzlich gibt es eine Reihe von Add-Ons, Toolboxen und Büchern, z.B.:
  . dBase-Interface: 45 EUR
  . Bücher "GFA-BASIC Powerprogramming I und II": je 11 EUR
- Auf der GFA-Webseite steht eine kostenlose Trial-Version des GFA-BASIC 16 
  Bit Interpreters zur Verfügung, die auf 1000 Quellsprachezeilen beschränkt
  ist, aber ansonsten den vollen Funktionsumfang bietet. Mit dieser Funktion
  kann man schon durchaus anspruchsvolle Softwareprojekte realisieren.
- Der Interpreter, auch in der Trial-Version, kann EXE-Dateien erstellen, die
  zum Ablaufen allerdings das Runtime-Modul GFARUN10.DLL benötigen. GFARUN10.DLL
  muss also zusammen mit dem erstellten EXE-Programm im selben Verzeichnisan an
  den Anwender übergeben werden.
- Der Compiler kann außer EXE-Dateien auch DLLs und andere Libraries und
  Controls erzeugen. Die mit dem Compiler erzeugten Programme benötigen
  das Runtime-Modul GFARUN10.DLL nicht.
- Von Data Becker gab es übrigens 1992 einmal einenkostengünstigen Interpreter
  "GFA-BASIC für Windows 16 Bit" in der OEM-Version V4.10 (286er-Version.


Die Entwicklungsumgebung
------------------------
Die Installationsdateien für "GFA-BASIC für Windows 16" passen locker auf eine 
Diskette. Der Installationsvorgang beschränkt sich auf das Entpacken der 
Dateien; es werden dabei keine Systemdateien oder -Verzeichnisse verändert.

Die Bedienungsoberfläche ist im "Config"-Menü zwischen englisch und deutsch 
umschaltbar. Es ist eine deutsche Online-Hilfe mit einer alfabetischen 
Befehlsübersicht vorhanden.

Die Bedienung entspricht leider nicht immer den Windows-Konventionen. Markierter 
Text lässt sich z.B. nicht mit der Entf-Taste löschen, sondern über den 
Menüpunkt "Bearbeiten | Ausschneiden".

Im Gegensatz zur DOS-Version verfügt GFA-BASIC für Windows 16 Bit eine Online- 
Hilfe, die eine Referenz aller Befehle enthält. Mit Shift+F1] erhält man sogar 
eine kontextsensitive Hilfe zu dem Befehl, in dem der Cursor gerade steht!

Die Quellspraceprogramme werden in einem speziellen *.GFW-Format abgespeichert. 
Über den Menüpunkt "Datei | Text speichern unter..." kann man sein Programm aber 
auch als reinen ASCII-Text in einer Datei *.LST abspeichern, welche von allen 
Textverarbeitungen und Editoren gelesen werden kann. *.LST-Dateien kann man über 
den Menüpunkt "Datei | Hinzuladen..." in der Entwicklungsumgebung einfügen.

Noch ein Tipp für das Erstellen von EXE-Dateien: Die Icondatei *.ICO muss 
grundsätzlich immer denselben Namen haben wir die *.GFW- Quellsprachedatei. Das 
Icon wird in die EXE-datei "eingebettet".


Die Spracheigenschaften
-----------------------
"GFA-BASIC für Windows 16 Bit" ist weitgehend kompatibel mit der DOS-Version. Es 
lassen sich Programme im Windows 3.1 Stil erstellen, die auf alle von Windows 
angebotenen API-Funktionen zugreifen können. Trotzdem bleibt der gewohnte 
prozedurale Programmierstil. Aufsteiger von DOS-BASIC- Sprachen brauchen also 
kaum umzudenken und können den dornenreichen Umstieg auf eine objektorientierte 
Sprache noch etwas hinausschieben.

Obwohl es sich um eine reine 16-Bit-Sprache handelt, lassen sich mit gewissen 
Tricks Zugriffe auf die 32-Bit-Windows-API-Funktionen realisieren und lange 
Dateinamen verwenden.


Erstellung grafischer Bedienungsoberflächen
-------------------------------------------
Grafische Bedienelemente wie Dialogboxen, Buttons, Auswahllisten und Menüs im 
Windows 3.x-Look können entweder wie bei der DOS-Version "von Hand" 
ausprogrammiert oder mit dem Fomulardesigner RCS (Resource Construction System) 
visuell erstellt werden. 

Dabei sind die Befehle weitgehend kompatibel zur DOS-Version: Der folgende, mit 
der DOS- Version identische Code zeigt z.B. eine Alert-Box an:

SCREEN 18 // VGA-Bildschirm
ALERT 3, "Die Datei existiert nicht", 1, "_Wiederholung |_Abbruch", wahl
PRINT wahl

((Screenshot: siehe AlertBox.gif))

Und ein Textviewer mit komfortablem Dateiauswahldialog lässt sich in der von
GFA-BASIC für DOS gewohnten Weise von Hand so erzeugen:

FILESELECT "", "", datei$
OPEN "i", #1, datei$
DO
  LINE INPUT #1, zeile$
  PRINT zeile$
LOOP UNTIL eof
CLOSE #1

Die Befehle sind ebenfalls identisch mit der DOS-Version, mit Ausnahme des OPEN- 
Befehls, der eine etwas andere Syntax hat.

Und hier nun ein kleines Programm, das das Arbeiten mit dem Fomulardesigner RSC 
demonstrieren soll. In einem Dialogfenster wird ein Klickbutton angezeigt. Die 4 
Zeilen nach "Dialog #0" sind automatisch von RCS erzeugt und mit "Datei | LST 
senden" in den Editor eingefügt worden.

OPENW #1               //Programmfenster öffnen
PRINT "Anzeige und Abfrage eines Buttons. (c) Thomas Antoni"
// Fenster mit einem Button definieren:
DIALOG #0,350,250,300,100,"Thomas",$10000000
  CONTROL "Programm Beenden",100,"button",$10000000,50,20,180,40
ENDDIALOG
SHOWDIALOG #0          // Fenster anzeigen
DO
  PEEKEVENT            // Ereignisse abfragen
  IF MENU(1) = 30 THEN // Button betätigt?
    CLOSEDIALOG  #0    // Dialogfenster schließen
    CLOSEW #1          //Programmfenster schließen
    END                // Programm beenden
  ENDIF
LOOP

(( Screenshot: siehe Button.GIF in Pics/ ))


GFA-BASIC 32 Bit für MS-Windows 95...XP
===============================================================================
Preise und Lieferformen
------------------------
- GFA-BASIC 32 Bit für MS - Windows 95...XP
  . GFA-BASIC 32 auf CD-ROM: 536,50 EUR
  . GFA-BASIC 32, Upgrade von der 16-Bit-Version: 455,00 EUR
  . GFA-BASIC 32, Upgrade von anderen Versionen: 485,50 EUR
  Die Trial-Version 1.01 ist auf der GFA-Webseite leider nicht mehr verfügber.
  Mit ihr kann man keine EXE-Dateien erstellen....
- Kompilierte EXE-Programme benötigen als Ablaufunterstützung eine kleines
  Laufzeitmodul (Runtime Library).

- Mit der 32-Bit-Version von GFA-BASIC hat sich die Herstellerfirma wohl 
  etwas übernommen. Die Sprache ist ganz anders als die DOS und die 16-Bit-
  Version und soll wohl VisualBASIC das Wasser reichen. Schon nach kurzer Zeit 
  hat GFA Software Technologies die Weiterentwicklung dieser 
  Programmiersprache leider eingestellt. Aufgrund dessen und wegen des happigen 
  Preises fand die 32-Bit-Version nur wenig Verbreitung.


Die Entwicklungsumgebung (Unterschiede zur 16-Bit-Version)
-----------------------------------------------------------
- Abkürzungen: Im Gegensatz zum 16 Bit GFA-BASIC gibt es keine Abkürzungen 
  für Befehle (etwa Rep für Repeat). Diese Änderung ist insbesondere 
  erforderlich wegen des möglichen Verzichts auf Gosub und @ vor 
  Prozeduraufrufen und des Wegfalls von Klammern (Rep ist jetzt ein 
  Prozeduraufruf).
- String-Funktionen: Das Dollarzeichen kann bei (fast allen) String-
  Funktionen entfallen, wie bei Chr$(0) oder Chr(0). Im Unterschied zu VB 3/4 
  ist der Rückgabewert der Funktionen ohne $ kein Variant, es erfolgt aber ggf. 
  eine automatische Konvertierung.
- Stringkonstanten: Es gibt die Möglichkeit, durch ein doppeltes "" ein Chr(34) in eine 
  String-Konstante einzufügen. Außerdem gibt es, ähnlich wie in Pascal, die 
  Möglichkeit, mit #Zeichencode (#34#13#10#0) Zeichen in Strings zu verwenden, 
  die sonst über + Chr() + eingefügt werden müßten: so ist "Zeile1" #13#10 
  "Zeile2" #13#10 gleichbedeutend mit "Zeile1" + Chr(13) + Chr(10) + "Zeile2" + 
  Chr(13, 10).


Die Spracheigenschaften
---------------------------------------------
"GFA-BASIC für Windows 32 Bit" ist weitgehend kompatibel mit der Version für 
Windows 16 Bit und auch mit der DOS-Version. Dabei gibt es natürlich 
Kompromisse, d.h. einige Teile weichen etwas von 16 Bit GFA-BASIC ab. Einige der 
implementierten Funktionen sind an die 32-Bit-VisualBASIC-Version 4.0 angelehnt. 
Auch die alten MS-DOS BASICs (GW-BASIC, QBASIC...) sind mit einigen Funktionen 
vertreten, so dass der Aufstieg von diesen Programmiersprachen zu GFA-BASIC 32-
Bi tnicht schwer fällt.. Einige Anleihen wurden von der Programmiersprache 'C' 
gemacht, so sind Hex- Konstanten mit 0x1234 gleichbedeutend mit $1234 oder 
&H1234.

Mit GFA-BASIC 32 lassen sich Programme im Windows 95 Stil erstellen, die auf 
alle von Windows angebotenen API-Funktionen zugreifen können. Trotzdem bleibt 
der gewohnte prozedurale Programmierstil erhalten.

GFA-BASIC 32 ist eine reine 32 Bit-Anwendung und besitzt keinen getrennten 
Interpreter und Compiler. In der Entwicklungsumgebung wird ein Programm stets 
unmittelbar als Maschinencode ausgeführt. Dadurch ergibt sich eine extrem hohe 
Ausführungsgeschwindigkeit.

GFA-BASIC 32 erzeugt intern direkt Assemblercode (Maschinencode). Deshalb ist 
ein Inline- Assembler überhaupt erst möglich. Ein wichtiger Vorteil ist die hohe 
Ausführungsgeschwindigkeit. Die Laufzeitbibliothek ist eine ganz normale Dll 
(ähnlich msvcrtxx.dll), es ist also kein verkappter Interpreter (Threaded- P-
Code-Interpreter) enthalten, sondern es werden nur die von jedem GFA-BASIC 32 
Programm gleichermaßen nutzbaren Routinen zusammengefaßt.

- Grenzen, Limits (64-KByte Limit): In GFA-BASIC 32 gibt es kaum 
  willkürlich gesetzte Grenzen. So ist die Prozedurgröße nicht auf 64 KByte 
  (oder gar 32 KByte) beschränkt. Die Zeilenlänge ist nicht begrenzt auf 256, 
  1022, 1023 oder 1024 Zeichen. Die Anzahl der Fortsetzungszeilen ( _ am 
  Zeilenende wie in VB) ist nicht auf neun oder 25 oder 256 oder ... 
  beschränkt. Auch für Stringlängen, Feldgrößen etc. entfällt die 64 Kbyte-
  Limitierung.

- Pointer: GFA-BASIC 32 verfügt über einen leistungsfähigen Pointer-
  Datentyp.. Die Verfügbarkeit von Pointer-Datentypen ist eine wichtige 
  Erweiterung des Sprachumfangs. Damit lassen sich oft Programmteile besonders 
  kompakt gestalten und einfacher aus C oder Pascal portieren. Die Verwendung 
  von Pointern kann ein Programm meist erheblich beschleunigen (insbesondere 
  Register Pointer To), birgt bei nicht sehr umsichtiger Programmierung aber 
  auch Gefahren [z.B.: Speicherleichen (Memory leaks)].



Der Befehlssatz, Unterschiede zur 16-Bit-Version
------------------------------------------------
- OPEN: Der Open-Befehl wird nur in der langen Form unterstützt, die 
  kurze Form (Open "O", #1, "Test.Dat") wird aber, wenn möglich und vollständig 
  angegeben, vom Editor konvertiert (Open "Test.Dat" for Output As # 1)
- GOTO, GOSUB, Zeilennummern, Mehrere Befehle pro Zeile: Im Gegensatz zum 
  16 Bit GFA-BASIC gibt es die Möglichkeit, mit " : " getrennt, mehrere 
  Befehle pro Zeile zu verwenden. (Erhöhung der Kompatibilität zu VB, GW-
  BASIC, ...). Zudem sind als Label (Sprungmarken) jetzt auch Zeilennummern 
  erlaubt. (100 GoTo 200). Darüber hinaus können wilde Sprünge benutzt werden 
  (aus For- Next Schleifen heraus usw.), es gibt sogar ein GoSub Label, für 
  Unterprogramme innerhalb von Prozeduren (dann mit Zugriff auf die lokalen 
  Variablen des Aufrufers, ohne eigene Locals). Dies soll insbesondere zur   
  Kompatibilitätserhöhung zu QBASIC usw. dienen.
- Die Stringaddition mit &: Das Kaufmanns-Und wird, wie in VB, als 
  Stringadditionsoperator aufgefaßt.
	"Anzahl" & 7    ==> "Anzahl 7"
	12 & 6          ==> " 12 6"
  Bei 16 Bit GFA-BASIC ist & ein And (ähnlich wie in 'C'), aber mit höherer 
  Priorität (spart Klammern), also 12 & 6 = 4 (%1100 & %0110 = %0100). Diesen 
  Operator gibt es auch noch, aber als %&. Das entsprechende Or gibt es als | 
  und als %|, und das entsprechende Xor jetzt auch als %^. In GFA-BASIC 32 also 
  12 %& 6 = 4 (%1100 And %0110 = %0100)
  Hier gibt es auch den Operator $, der wie der VB-Operator & eine 
  Stringverkettung durchführt.  12 $ 6 ==> " 12 6", dieses Zeichen hätte sich für 
  die String-Addition angeboten, aber VBA will es anders.
- Der Ähnlichkeitsvergleich: Im Gegensatz zum 16 Bit GFA-BASIC ist der 
  Ausdruck x == y jetzt gleichbedeutend mit x = y. Ähnlichkeitsvergleiche vom 
  16 Bit GFA-BASIC mit  ==  sind zu ersetzen durch NEAR oder den Vergleich mit 
  Single, also statt If a == 1 einfach If a = 1!.
- Funktionen des Win32 API: GFA-BASIC 32 erkennt selbstätig mehr als 1000 
  API-Funktionen, d.h. diese können direkt wie GFA-Befehle benutzt werden. 
  Dabei sind die Standard-API-Funktionen aus User, Kernel und GDI eingebunden 
  worden. Selten(er) benutzte API-Funktionen wie z.B. die WinSock-Funktionen 
  müssen weiterhin über Declare deklariert werden. Ein Teil der im 32 Bit-
  Windows nicht vorhandenen Funktionen wird entweder nachgebildet (MoveTo, 
  CreateWindow), emuliert (GetBitmapDimension ...) oder mit einer Fehlermeldung 
  während der Laufzeit abgewiesen (AllocSelector, GetTempDrive, die ProfXxx-
  Funktionen und die  Windows 2.x Sound-Funktionen wie StartSound usw., 
  letztere waren aber schon in Windows 3.0 nicht mehr von Microsoft 
  dokumentiert). Auch die etwa 1400 API-Konstanten der 16 Bit-Version sind 
  implementiert und können direkt genutzt werden. Dazu wurden mehr als 900 
  Konstanten des Win32-APIs eingebunden.
- Grafikbefehle: Die Grafikbefehle (Line usw.) erhalten Koordinaten als 
  Fließkommawerte, nach Skalierung werden entsprechende Integerwerte an das 
  GDI übergeben. Es gibt bei den meisten Graphikbefehlen die Möglichkeit, die 
  Parameter wie in VB zu übergeben: Line (x, y)-(z, t),, BF oder PBox x, y, z, 
  t. Der Color-Befehl arbeitet so wie in VB, also in etwa wie RgbColor im 
  16 Bit GFA-BASIC. Es gibt auch QBColor, etwa in Color QBColor(i) und auch 
  QBColor i.ch minimal schneller sind.
  

Erstellung grafischer Bedienungsoberflächen
------------------------------------------------
Hier gibt es die größte Neuerung gegenüber den älteren GFA-BASIC-Versionen: 
Alle Bedienelemente (Menüs, Dialogboxen usw.) sind jetzt als OCX-Controls 
ausgeführt. Zum Erzeugen von OCX-Controls gibt es den Befehl OCX. Der Befehl 
OCX erlaubt auch eine "relativ" einfache Konvertierung von GFA-BASIC 16 Bit 
Dialog- Befehlen.

Der Umgang mit den OCXen ist für Einsteiger ziemlich komplex. Das OCX-
Objektverzeichnis ist ein PDF-Dokument mit 757 Seiten!


Webseiten zu GFA-BASIC
===============================================================================
- www.gfasoft.gfa.net - Die offizielle Webseite von GFA Software Technologies
    GmbH mit Produktbeschreibungen, Trial-Versionen, Preislisten, Tools,
    Handbüchern und Kollektionen von Beispielprogrammen. Der HTTP-Server im
    Downloadbereich funktioniert offensichtlich nicht mehr. Dafür stehen im
    FTP-Bereich einige Downloads zur Verfügung (FTP-Client zum Durchführen des
    Downloads verwenden!). Die GFA32-Trial-Version ist leider nicht mehr verfügbar.
- www.rowalt.de - ...
- www.gfawhelp.gfa.net - Dale Bryants Website "GFA-Help ist eine Riesenseite mit 
   Tonnen von Downloads zu GFA-BASIC für Win 16 und 32 (nicht für DOS!) -
   Tools für Entwickler, Windows-Hilfedateien für GFA-BASIC, Beispielprogramme
- www.ilmiositoweb.it/gfa-basic/ - GFA-BASIC Dokumentation und Befehlsreferenz
   von Chris Fanucci
- www.heise.de/kiosk/archiv/ct/ - Der Kiosk für alte Zeitschriftenartikel der
    Computerzeitschrift c't mit einigen sehr interessanten Artikeln über
    GFA-BASIC, die man für ein paar Cent käuflich erwerben kann.
    
    
    
********************************************************************************
*
* Aus dem eBay-Angebot eines GFA-BASIC Interpreters für DOS  (25.12.2005)
* ==============================================================================
*
********************************************************************************

Ich biete hier eine komplette GFA-BASIC MS-DOS (16-Bit) Programmiersoftware an, 
einschließlich des Interpreters auf dem Upgrade-Stand 4.5, einschließlich des 
Compilers (zur Herstellung von selbstständig lauffähigen Programmen (.EXE und 
.COM) ohne Interpreter) und dem DBase-Datenbank-Interface.  Alle erforderlichen 
Original-Systemhandbücher und Original-Disketten mit zahlreichen 
Beispielroutinen liegen ebenso bei. Alle Inhalte der Original-System-Disketten, 
sowie Programmier-Beispiele und Hilfstexte und Internetquellen habe ich 
zusätzlich auf einen modernen CD-Datenträger gebrannt.

Als "Beginners All Purpose Instruction Code") hat Programmiersprache BASIC 
weltweit ihren Platz unter den Entwicklersystemen für Software.GFA-BASIC ist 
nach meiner Kenntnis seinerzeit eine der außerordentlich innovativse  
Programmiersprachen gewesen. Das Entstehungskonzept von GFA-BASIC hat seine ganz 
eigene bemerkenswrete Geschichte in Deutschland. GFA-BASIC hat ganz 
offensichtlich auch heute noch seinen Anwenderkreis, sowohl in Deutschland, aber 
wohl auch einen Schwerpunkt-Fangemeinde von Anwendern in den USA, UK´und anderen 
Ländern. 

In Erstaunen hat mich versetzt, dass GFA-BASIC jüngst mit einen Eintrag in der 
freie Internet-Enzyklopädie "WIKIPEDIA" gewürdigt wurde. Offensichtlich gibt es 
da noch immer einen enthusiastischen Nutzerstamm, der das "easy going" von GFA-
BASIC heute immer noch den Software-Dinosauriern vorzieht und als Handwerkszeug 
verwendet. Wenn Sie Laie sind sollten Sie sich undbeding auf den Internetseiten 
zum GFA-BASIC vorher informieren (Suchmaschinen benutzen, siehe auch "GFA-BASIC 
Community"). 

Es gibt GFA-BASIC für mehrere verschiedene Betriebsystemplattformen: 

GFA-Basic 32 (GB32) für 32 Bit-WINDOWS (wie z.B. WINDOS-XP) 
GFA-Basic 16 für Windows 3.x 
GFA-Basic für DOS (das ist das was Sie hier als komplettes Entwicklerpacket
   mit allem drum und dran ersteigern könnnen) 
GFA-BASIC für ATARI ST 
GFA-BASIC für AMIGA

Unter anderem steckte in der Vergangenheit in der Vielfalt der Verwendbarkeit 
von GFA-BASIC für die verschiedensten Plattformen (z.B bei Wissenschaftler 
wichtig, vielleicht bei Spezialanalysen für Unternehmen, zu denen es keine 
Lösung von der Stange gab, wichtig gewesen ...oder, naja ... vielleicht doch 
nicht???!!!) enorme Vorteile. Ich verwende noch heute fast unverändert eine 
Vielzahl von schnell aus der Hand und ohne große Umstände geschriebene  
Berechnungsprozeduren, die ich erst auf dem ATARI ST und später unter MS-DOS mit 
diesem Entwicklerpaket programmiert habe und die mittlerweile in's 32-Bit-
Windowszeitalter hinübergekommen sind (unter GFA-BASIC GB32 natürlich). Keine 
dicken Handbuch-Schwarten unter denen sich der Schreibtisch durchbiegt und die 
konkrete Ergebnisse bei komplexen Fragestellungen zur Massendatenverarbeitung 
als Praktikant schneller als die Softwareabteilung des Hauses mit dem  "geht 
nicht, gibt's nicht" und "hamm' wer nicht im Angebot"-Arbeitskonzept fertig 
vorlegen. GFA-BASIC-Trumpf ...noch im Jahr 2001!

GFA-BASIC ist schnell und ziemlich einfach in einem schlichten, aber ebenso 
schnellen Interpreter-Editor zu programmieren. Das Schöne ist, man kann's sofort 
ausprobieren ob's klappt. Wenn's um die reine Funktion und nicht um 
überbordenden Schnickschnack geht, keine "von der Stange"-Lösung vorhanden ist 

...schnell GFA-BASIC Progrämmchen geschrieben. GFA-BASIC arbeitet rasend schnell 
wenn's um Massendatenverarbeitung von den unendlich großen Festplatte geht. GFA-
BASIC erlaubt Addressierung von Systembereichen, die den typischen kontemporären 
Basic-Dialekten nicht so einfach zugänglich waren. Ich denke, GFA-BASIC unter 
MS-DOS kann auch heute noch seine Leistung unter Beweis stellen und wird seine 
Liebhaber bzw. Anwender finden, weltweit! ...zumal ich hier ein komplettes 
Systementwicklerwerkzeug anbiete (alles drin und dran ...und damals richtig 
teuer) ...vielleicht gibt's ja jemanden dem noch zum GFA-BASIC-ATARI, AMIGA-
System oder Windows-GFA-BASIC das MS-DOS-System zur Umsetzung der eigenen 
Softwareentwicklungen fehlt. Hier ist es! Komplett!

Und nun das Tollste an der ganzen Geschichte: Ich bezeichne mich nicht mal als 
Programmierer und bin auch sonst in meinen beruflichen Tätigkeiten völlig anders 
angesiedelt, als man vielleicht glauben mag. Gerade deshalb hat mir GFA-BASIC so 
manchen beruflichen Knüller erlaubt. 

..und warum biete ich dann das so geschätzte GFA-BASIC MS-DOS bei EBAY hier zur 
weltweiten Versteigerung an? 

...man setzt sich ergeizigere Ziele die nun tatsächlich die Leistungsfähigkeit 
von 16-Bit-Systemen überschreiten. Es geht tatsächlich in meinem Arbeitsfeld um 
digital darzustellende Genauigkeit, die über die 16-Bit von GFA-MS-DOS 
hinausgehen (aber für sowas hab' ich GFA-BASIC für 32-Bit Windows) 

...die Zeiten ändern sich ..."ich hab' noch einen Koffer in Berlin" wie früher 
oder heute "ich hab' noch einen Schuber GFA-Basic im Regal von anderen Leuten 
stehen lassen", das geht im Zeitalter der totalen Mobilität nicht mehr. Deshalb 
schweren Herzens ...GFA-BASIC MS-DOS Komplettpaket zum richtig Loslegen... mit 
allem drum und dran (also keineswegs nur die Handbücher) ... wie auf den Fotos 
... jetzt hier auf EBAY, weltweit zum mitbieten!.

... schauen Sie sich im Internet unter den einschlägigen Stichworten ein wenig 
um, und Sie werden feststellen, dass Sie auf einen fundierten Erfahrungsschatz 
langjähriger Programmierer (Profis und Enthusiasten) und zahlreiche zweckmäßige 
Programm-Quellcode-Routinen stoßen werden, die sie tatsächlich ziemlich einfach  
in eigenen Programmen einsetzen können. 

Was ist an GFA-BASIC so bemerkenswert?

Dazu ein anderes Zitat von Roland Walter, einem Entwickler, der sich auf 
schnelle und effiziente Applikationen, speziell in Bereichen wo andere 
Entwickler (und Entwicklungswerkzeuge) an Ihre Grenzen stoßen, spezialisiert hat 
(Zitat). Sie finden folgendes Zitat auch im Internet: 

"GFA-Basic (ich spreche über die 16-Bit-Version) ist eine wirklich verdammt gute 
Sprache. Die Programmierumgebung paßt auf eine Diskette, die erzeugten Programme 
(exe, dll, drv u.s.w.) sind extrem schnell und klein, und es ist alles 
zugelassen, was unter Windows geht. Ich nehme die 16-Bit-Version heute noch, 
wenn ich mal eben schnell ein kleines Tool schreiben muß oder eine Routine 
testen will. - Ein Windows-Programm mit Fenster kann in GFA-Basic nämlich 4 
Zeilen lang sein ..... Und vor allem der Editor hat es in sich: Neben den 
üblichen Features kann man Funktionen im Editor zu einer einzigen Zeile 
zusammenklappen. Das heißt im Klartext: Das gesamte Projekt kann in einer 
einzigen Datei bleiben. Was das für die Projekt-Übersichtlichkeit heißt, weiß 
nur derjenige, der schon mal mit dem GFA-Editor gearbeitet hat."