PureBasic.png

Reines BASIC

PureBasic: Software für Linux, Windows und OS X entwickeln

09.07.2013
Die französische Softwareschmiede Fantaisie Software bietet mit PureBasic eine Entwicklungsumgebung an, mit der Sie Programme für Linux, Windows und OS X erstellen. Wir helfen bei den ersten Programmierprojekten mit dem modernen BASIC-Dialekt.

BASIC ist ein Urgestein unter den Programmiersprachen und darum auch heute noch beliebt: Das sieht man z. B. daran, dass die Skriptsprache in LibreOffice auch ein BASIC-Dialekt ist. Für Linux gibt es verschiedene BASIC-Versionen, die meist als freie Software erhältich sind – unter anderem den Compiler FreeBasic [5] und die Entwicklungsumgebung Gambas [6].

Als integrierte Entwicklungsumgebung bietet PureBasic [1] den Vorteil, dass alle fürs Programmieren wichtigen Funktionen unter einem Dach versammelt sind: Über die Projektverwaltung erzeugen Sie neue Projektdateien, geben diese – unterstützt durch Syntax Highlighting und Hilfestellungen zu Standardfunktionen – im Editorbereich ein und übersetzen und starten Ihr Programm auf Knopfdruck. Auch ein Debugger für die Fehlersuche ist dabei.

Wenn Sie bereits unter Windows programmiert haben, wird Ihnen dieser Ansatz vertraut sein; Microsofts Entwicklungsumgebung Visual Studio arbeitet auch so und unterstützt dabei zahlreiche Sprachen, u. a. Visual Basic, einen Verwandten von PureBasic.

Eine kostenlose Testversion, die nur in der Länge der Programmquelltexte beschränkt ist, findet sich im Downloadbereich des Herstellers; die Vollversion kostet 79 Euro – dafür gibt es eine lebenslange Lizenz: Fantaisie Software verspricht, dass jeder Käufer dauerhaft alle neuen Versionen gratis erhält, sogar für neue Plattformen, die eventuell künftig hinzukommen.

Demoversion installieren und starten

Laden Sie von der PureBasic-Webseite die Demoversion [2] herunter; Sie haben dort die Wahl zwischen einer 32-Bit- und einer 64-Bit-Variante. Wir gehen im Folgenden davon aus, dass Sie die 64-Bit-Version testen möchten. Die heruntergeladene Datei purebasic-demo_x64.tgz liegt nun im Ordner Downloads. Starten Sie den Dateimanager Dolphin, wechseln Sie in den Ordner Downloads, klicken Sie die neue Datei mit der rechten Maustaste an und wählen Sie aus dem Kontextmenü die Option Entpacken / Archiv hierher auspacken – dadurch entsteht ein neues Verzeichnis purebasic-demo, in dessen Unterordner compilers Sie hinein wechseln. Hier finden Sie eine Datei purebasic, die Sie anklicken: Dann startet das Programm und zeigt das in drei Bereiche unterteilte Fenster der Entwicklungsumgebung an (Abbildung 1).

Abbildung 1: Das Programmfenster von PureBasic ist dreigeteilt; links oben geben Sie Ihren BASIC-Code ein.

Erste Schritte

Links oben geben Sie den Programmcode ein, darunter erscheinen Informations- und Fehlermeldungen des Compilers, wenn Sie das Programm übersetzen und starten. Der rechte Bereich ist konfigurierbar, hier können Sie verschiedene Dinge einblenden, z. B. eine Übersicht aller Prozeduren, die Sie geschrieben haben.

Wir zeigen Ihnen hier nur Konsolenanwendungen, denn diese sind in PureBasic besonders schnell geschrieben. Für Interaktionen mit dem Benutzer bietet die Sprache u. a. die Befehle Print (Textausgabe), PrintN (mit Zeilenumbruch) und Input (Eingabe). Um Programme zu entwickeln, die in der Shell laufen, müssen Sie zunächst eine Einstellung ändern – denn standardmäßig will PureBasic eine grafische Anwendung erzeugen. Rufen Sie den Menüpunkt Compiler / Compiler-Optionen auf und wählen Sie unter Executable Format die Variante Console aus. Jetzt ist PureBasic bereit für Ihre ersten einfachen Programme.

Geben Sie im leeren Editorbereich die folgenden drei Zeilen ein:

OpenConsole()
PrintN ("Hallo Welt")
a$ = Input()

Dann drücken Sie [F5], um das Programm zu kompilieren und zu starten – es öffnet sich ein Terminalfenster, in dem "Hallo Welt" erscheint: Drücken Sie dort die Eingabetaste, um das Fenster zu schließen (und die Programmausführung zu beenden). Sollte sich kein Fenster öffnen, verwendet PureBasic das Terminalfenster, in dem Sie die Entwicklungsumgebung gestartet haben. Übrigens: Wenn Ihnen die Schrift im Editorbereich zu klein ist, lesen Sie im Kasten Editor-Schriftart nach, wie Sie Schriftart und -größe anpassen können.

Editor-Schriftart

Standardmäßig verwendet der PureBasic-Editor eine relativ kleine Schrift. Vor allem auf Notebooks mit hoch auflösendem Display und auf großen Desktop-Displays über 20 Zoll ist diese nur schwer lesbar. Über die Optionen können Sie die Schrift aber wechseln. Rufen Sie dazu den Menüpunkt Datei / Einstellungen auf und wechseln Sie im Einstellungsfenster links zum Punkt Editor / Bearbeiten.

Sie sehen rechts verschiedene Optionen für den Editor, hier interessiert uns der oberste Punkt Zeichensatz. Klicken Sie diese Schaltfläche an, erscheint ein Auswahlfenster für die Schrift. Sie können die Standardschrift (Fixed Misc) beibehalten und nur die Schriftgröße ändern, z. B. von 10 auf 13, oder gleich eine andere Schrift auswählen. Gut lesbar ist z. B. die Schrift DejaVu Sans Mono in Schriftgröße 12.

Abbildung 2: In den Einstellungen ändern Sie die Schrift, mit welcher der Editor den Quellcode anzeigt.

Um die BASIC-Datei zu speichern, drücken Sie [Strg]+[S]: Dann öffnet sich ein Dateiauswahldialog. Sie können einen Programmnamen ohne Dateiendung wählen (z. B. helloworld); PureBasic hängt dann automatisch die Endung .pb an diesen Namen an. Es ist hilfreich, für die Programmentwicklung ein eigenes Verzeichnis anzulegen, z. B. einen Ordner PureBasic in Ihrem Home-Verzeichnis.

Wollen Sie das Programm nicht nur testen, sondern eine ausführbare Datei erstellen, rufen Sie den Menüpunkt Compiler / Executable erstellen auf und wählen im Dateiauswahldialog einen Ort und Namen. Sie können denselben Ordner wie für den Quellcode verwenden und auch als Name im Beispiel wieder helloworld angeben – diesmal hängt PureBasic keine Endung an.

Das so generierte Programm können Sie nun in einem Terminalfenster starten, es arbeitet unabhängig von der Entwicklungsumgebung und benötigt auch keine speziellen Bibliotheken, so dass Sie es sogar auf andere Linux-Rechner kopieren und dort starten können.

Die Quellcode-Dateien sind übrigens normale Textdateien (mit UTF-8-Kodierung), die Sie bei Bedarf auch in anderen Editoren anschauen oder bearbeiten können: Wenn Sie eine solche pb-Datei im KDE-Editor Kate öffnen, aktiviert dieser sogar das Syntax Highlighting, weil er das Dateiformat kennt (Abbildung 3).

Abbildung 3: Der KDE-Editor Kate erkennt das Dateiformat der PureBasic-Quellcode-Dateien.

Eingabe und Ausgabe

Das kleine Beispielprogramm enthielt schon zwei wichtige Komponenten von Anwendungen: Ein- und Ausgabe. Den Input-Befehl am Ende haben wir nur eingebaut, damit sich das Programmfenster nicht direkt wieder schließt: Input() liest Ihre Eingabe von der Tastatur, und diese ist erst abgeschlossen, wenn Sie [Eingabe] drücken. Was Sie eingetippt haben, landet in der Stringvariable a$, die das kleine Beispielprogramm aber nicht mehr auswertet. Wenn Sie eine ausführbare Datei erstellen, benötigen Sie den abschließenden Input-Befehl nicht.

Sinnvoller wird Input verwendet, um ein Programm interaktiv zu machen: Es kann dem Anwender damit Fragen stellen und die eingelesenen Daten auswerten und weiter verarbeiten. PrintN ist eine Variante des klassischen BASIC-Befehls Print (den es in PureBasic auch gibt): Während Print den übergebenen Text auf die Konsole schreibt, hängt PrintN noch einen Zeilenumbruch an.

Projekt: Mini-Shell

PureBasic bringt etliche eingebaute Funktionen mit, über die Sie z. B. auf Dateien zugreifen und andere Programme starten können. Im Rahmen dieses einführenden Artikels können wir nur eine kleine Auswahl der Sprach-Features vorstellen (und damit hoffentlich Lust auf mehr machen), wir beschränken uns hier auf die Befehle, die Sie brauchen, um eine kleine Shell (wie die Bash) zu entwickeln. Shells arbeiten im Wesentlichen wie folgt:

  • In einer Endlosschleife zeigen sie einen Shell-Prompt an, in der Bash sehen Sie z. B. immer Benutzer- und Rechnername, das aktuelle Verzeichnis und ein Dollar- ($) oder Raute-Zeichen (#) – dahinter geben Sie einen Befehl ein.
  • Die Shell muss dann einen neuen Prozess erzeugen, in dem das gewünschte Programm startet. Außerdem wartet sie, bis das neue Programm beendet wurde.
  • Danach springt die Shell an den Anfang der Endlosschleife zurück, und es erscheint wieder der Shell-Prompt.

In PureBasic gibt es für Endlosschleifen die Befehle Repeat (wiederhole) und ForEver (ewig): Alles, was Sie zwischen diese beiden Befehle packen, wird dauerhaft wiederholt. Um aus einer solchen Schleife "ausbrechen" zu können, steht der Befehl Break zur Verfügung. Die Mini-Shell soll sich bei Eingabe von exit beenden (wie es auch die Bash tut); dafür benötigen wir eine Fallunterscheidung.

PureBasic unterstützt die klassische If-Then-Else-Konstruktion (siehe Artikel Print "Hallo Welt" ab Seite 38) mit folgender Syntax:

If Bedingung
  ; Befehle
Else
  ; Befehle
EndIf

Den Else-Teil kann man auch weg lassen und hinter den Befehlen direkt EndIf schreiben. Das Semikolon ist in PureBasic das Zeichen, das Kommentare einleitet. Ein erster Ansatz für das Shell-Programm sieht damit wie folgt aus:

Repeat
  Print ("EasyShell: ")
  eingabe$ = Input()
  If eingabe$ = "exit"
    Break  ; Ende
  EndIf
  ; Programm ausführen
ForEver

Wenn Sie diesen Code eingeben und vor der ersten Zeile noch den für Terminalanwendungen zwingenden Befehl OpenConsole() ergänzen, können Sie das Programm bereits übersetzen und starten – es liest so lange neue Befehle ein, bis Sie exit eingeben.

Was noch fehlt, ist der Start der Programme. Dafür stellt PureBasic das Kommando RunProgram zur Verfügung. Sie könnten einfach den Befehl RunProgram (eingabe$) ergänzen, allerdings würde die Mini-Shell dann nicht auf das Ende der Programmausführung warten. RunProgram ist eine Funktion, die auch einen Rückgabewert hat: Den können Sie sich merken und in anderen PureBasic-Funktionen verwenden. Die korrekte Lösung für den Programmstart sieht folgendermaßen aus:

p = RunProgram (eingabe$, "", "", #PB_Program_Open)
WaitProgram (p)
CloseProgram (p)

Der Aufruf von RunProgram ist hier etwas komplexer – wenn Sie in der PureBasic-Dokumentation nachschlagen, finden Sie heraus, dass Sie beim Programmstart die Option #PB_Program_Open verwenden müssen: Die sorgt dafür, dass die Mini-Shell das gestartete Programm beobachten kann. Um auf das Ende des Programms zu warten, benutzen Sie dann den Befehl WaitProgram(p) – er braucht p als Argument, denn Sie können mit RunProgram beliebig viele Programme starten und müssen WaitProgram mitteilen, auf welches davon Sie warten möchten. Schließlich müssen Sie noch CloseProgram(p) aufrufen, um der Shell zu sagen, dass Sie das beendete Programm nicht weiter beobachten wollen.

Bauen Sie diese drei Befehle anstelle des Kommentars (; Programm ausführen) in das Programm ein, dann funktioniert es schon: Sie können die Mini-Shell mit [F5] kompilieren und starten und dann in Ihrem Shell-Programm z. B. ls oder ps eingeben. Ein Problem entsteht, wenn Sie ein falsches Kommando eingeben: Dann ist der Aufruf RunProgram (eingabe$, ...) nicht erfolgreich, und WaitProgram(p) führt zu einer Fehlermeldung, weil p nicht für ein gestartetes Programm steht (sondern den Fehlercode 0 enthält). Das Problem können Sie vermeiden, indem Sie mit IsProgram(p) testen, ob der Aufruf von RunProgram erfolgreich war:

p = RunProgram (eingabe$, "", "", #PB_Program_Open)
If IsProgram (p)
  WaitProgram (p)
  CloseProgram (p)
EndIf

Eine weitere Fehlfunktion Ihrer Mini-Shell entdecken Sie, wenn Sie in der Shell gar nichts eingeben und nur [Eingabe] drücken – dann schlägt schon der Aufruf von RunProgram fehl und verursacht einen Abbruch. Also müssen Sie noch den Fall einer leeren Eingabe abfangen. Dazu können Sie den PureBasic-Befehl Continue verwenden: Der führt in allen Schleifen dazu, dass die restlichen Befehle innerhalb der Schleife übersprungen werden und es direkt mit dem nächsten Schleifendurchlauf weitergeht. Wie das funktioniert, sehen Sie am leichtesten am folgenden Beispiel, das eine klassische BASIC-Zählschleife mit den Schlüsselwörtern For und Next verwendet: Sie zählt eine Variable von 1 bis 8 hoch und führt für jede der Zahlen die Befehle zwischen For und Next aus:

For i = 1 To 8
  If i = 5
    Continue
  EndIf
  Print (Str(i) + ",")
Next

Ohne die Fallunterscheidung würde dieser Code 1,2,3,4,5,6,7,8, ausgeben. Mit den zusätzlichen Befehlen prüft das Programm, ob i den Wert 5 hat: Wenn ja, dann sorgt Continue dafür, dass die restlichen Befehle in diesem Durchlauf übersprungen werden – also auch der Print-Befehl. Dadurch ist das Endergebnis 1,2,3,4,6,7,8, (ohne die "5").

Hätten Sie in diesem Beispiel statt Continue den Befehl Break verwendet, wäre die Ausgabe noch kürzer gewesen (nur 1,2,3,4,) – Continue ändert also nur das Verhalten eines Schleifendurchlaufs, während Break eine Schleife komplett abbricht.

Für die Mini-Shell brauchen Sie nach der Eingabe mit Input darum folgenden Code-Block:

If eingabe$ = ""
  Continue
EndIf

Wenn Sie das alles zusammen bauen, entsteht Code, der zunächst prüft, ob die Eingabe leer ist. Dann prüft er, ob die Eingabe exit ist. Wenn auch das nicht der Fall ist, wird der jeweilige Befehl ausgeführt. Das kann man in PureBasic schöner machen, denn es gibt die Befehle Select (Auswahl) und Case, mit denen sich verschiedene Fälle behandeln lassen.

Select-Befehl

Sie können Select auch verwenden, um neben exit noch weitere interne Kommandos zu unterstützen. Die Tests auf leere Eingabe, exit und ein neues Kommando ver, das Versionsinformationen über die Mini-Shell ausgeben soll, könnten mit Select wie folgt aussehen:

Select eingabe$
  Case ""
    Continue
  Case "exit"
    Break
  Case "ver"
    PrintN ("EasyLinux Mini-Shell 1.0")
  Default
    ; Programm starten
EndSelect

(Der Eintrag Default steht in der Select-Konstruktion für alle sonstigen Fälle.) Insgesamt entsteht auf diese Weise das Mini-Shell-Programm in Abbildung 4. Besonders nützlich ist es nicht: Es verarbeitet nur Befehle, die aus einem einzelnen Kommando bestehen – sobald Sie versuchen, z. B. ls -l einzugeben, erzeugt das eine Fehlermeldung, denn die Mini-Shell versucht, ein Programm mit dem Namen ls -l zu starten. Was hier also noch fehlt, ist die Zerlegung der Eingabe in einen Befehl und seine Argumente. Das wäre nun der Ausgangspunkt für Ihre ersten eigenen Experimente; dazu ein Tipp: Schauen Sie sich die Beschreibung des Befehls StringField an.

Abbildung 4: Die Mini-Shell funktioniert: Mit wenigen Befehlen bilden Sie bereits die elementaren Funktionen einer echten Shell nach.

Cleveres Syntax Highlighting

Bei der Eingabe (oder beim Betrachten der Screenshots) ist Ihnen sicher aufgefallen, dass der PureBasic-Editor Schlüsselworte wie Repeat und Case durch fette Schrift und eine andere Farbe hervorhebt. Das Programm bietet hier aber noch mehr: Springen Sie z. B. mit dem Cursor auf den Befehl Repeat am Programmanfang, dann wird dieser unterstrichen – und gleichzeitig auch der "schließende" ForEver-Befehl. Der Editor erkennt also Anfang und Ende von Blöcken. In diesem Beispiel markiert er außerdem die Befehle Continue und Break, die in der Schleife auftauchen, weil beide das Verhalten dieser Schleife beeinflussen. Das ist ein nützliches Feature, vor allem dann, wenn Sie mehrere Schleifen ineinander schachteln.

Auch bei der Eingabe des Programms kommt Ihnen der Editor entgegen: Er erkennt Anfänge von PureBasic-Befehlen und bietet automatisch Vervollständigungen an (Abbildung 5) – Sie wählen dann mit den Cursortasten den richtigen Treffer aus und übernehmen ihn mit [Tab].

Abbildung 5: Wenn der Editor Befehle vorschlägt, wählen Sie einen aus.

Sobald der Cursor in einem PureBasic-Befehl steht, blendet das Programm unten eine Kurzhilfe zum Kommando ein. Reicht Ihnen das nicht aus, drücken Sie [F1]: Dann öffnet sich die Onlinehilfe und zeigt die ausführliche deutschsprachige Beschreibung des Befehls an (Abbildung 6).

Abbildung 6: Die Onlinehilfe hält zu allen PureBasic-Befehlen eine Referenz bereit – und zwar in deutscher Sprache.

Mehr Informationen

Wenn Sie über ausreichende Englischkenntnisse verfügen, um sich die Lektüre eines BASIC-Buchs in dieser Sprache zuzutrauen, finden Sie auf der PureArea-Webseite ein 350 Seiten starkes PureBasic-Buch zum Gratisdownload [3]. Es behandelt zwar die ältere Version 4.0, ist aber trotzdem eine nützliche Informationsquelle. Es gibt auch eine unvollständige Übersetzung ins Deutsche [4].

Richtig interessant wird PureBasic, wenn Sie damit grafische Anwendungen entwickeln; es sind sogar alle nötigen Features vorhanden, um kleinere Spiele zu programmieren. Das erfordert aber eine ausführlichere Beschäftigung mit der Sprache.

Diesen Artikel als PDF kaufen

Express-Kauf als PDF

Umfang: 4 Heftseiten

Preis € 0,99
(inkl. 19% MwSt.)

LinuxCommunity kaufen

Einzelne Ausgabe
 
Abonnements
 

Related content

Kommentare