Yabasic
Yet another Basic for Unix/Linux and Windows

Version 2.66

Yabasic unter Unix / Linux

Yabasic unter Windows

Yabasic in Beispielen

Verzeichnisse

Über Yabasic

Copyright

Wähle zwischen der Artistic License und 
der Gnu General Public License.

Dieses Dokument beschreibt die Fähigkeiten von Yabasic. Kurz gesagt, Yabasic umfasst die bekanntesten (und einfachsten) Elemente der  BASIC-Programmiersprache mit einigen grafischen Möglichkeiten, die Jedem vertraut sein sollten, der schon einmal Basic-Programme geschrieben hat.

Diese Seite umfasst alle Fähigkeiten von Yabasic. Man braucht keinerlei weitere Literatur, um es zu lernen. Es gibt gar keine andere Literatur über Yabasic, weder eine Unix/Linux-man-page noch eine Windows-Helpdatei.

Dieser Text ist keine Basic-Einführung, sondern setzt Grundkenntnisse der BASIC-Programmierung voraus.


Unix / Linux

Programmstart

Es gibt drei Möglichkeiten Yabasic zu starten:

1.

Das BASIC-Programm als Text-Datei schreiben  (z.B. foo.yab) und Yabasic aufrufen mit dieser Datei als Argument:
yabasic foo.yab
Dadurch führt Yabasic das Programm aus.

2.

Yabasic ohne Argument (Dateiname) starten.
yabasic eingeben
Yabasic wird gestartet und zeigt ein Eingabe-Prompt. Nun schreibt man BASIC-Code.
Mit zweimal RETURN führt Yabasic das Programm aus. Dieses Verhalten ermöglicht es, Yabasic als nützlichen Desktop-Rechner einzusetzen.

3.

Das BASIC-Programm als Text-Datei schreiben und diese Textzeile als allererste Zeile eintragen. 
#!/usr/bin/yabasic
Dies ist nur ein Beispiel. Der Pfad /usr/bin/yabasic muss durch den vollständigen Pfad zu Yabasic auf ihrem Rechner ersetzt werden. Yabasic wird Zeilen, die mit #! beginnen als Kommentar ansehen, aber Unix / Linux wird Yabasic starten um das BASIC-Programm auszuführen.

Zurück zum Inhaltsverzeichnis ...


Startoptionen unter Unix / Linux

-h
Druckt ein kurze Hilfe aus; -help oder -? genauso.
-fg Vordergrundfarbe (Nur bei grafischem Bildschirm)
Setzt die Vordergrundfarbe in Grafiken. Die üblichen X Farbnamen wie red, green sind möglich.
-bg Hintergrundfarbe (Nur bei grafischem Bildschirm)
Setzt die Hintergrundfarbe.
-geometry Koordinaten-String (Nur bei grafischem Bildschirm)
Der übliche XY-Koordinatenstring funktioniert (z.B. +10+10), Fenstergrößen bleiben unbeachtet.
-display Ausgabegerät
Name des Ausgabegerätes, auf dem das Fenster erscheinen soll.
-font Schriftart (Nur bei grafischem Bildschirm)
Name der Schriftart, die in Grafik-Texten benutzt werden soll.
-i Informationsstufe
Setzt die Anfangs-Info-Stufe. Dies steuert die Informations-Menge, die man über die Programmausführung erhält.  Jede Stufe enthält auch alle niedrigeren Stufen (z.B. w enthält f und e) und noch:
 
dSetzt die Info-Stufe auf debug : Dies ergibt detaillierte Fehlersuch-Informationen, weit mehr Angaben als Sie es lesen möchten.
n
note : Nützliche Informationen; z.B. über Ausführungszeit und Speicherbelegung.
w
warning : Erzeugt Warnungen, wenn etwas falsch läuft (z.B. teilen durch Null); trotzdem geht die Ausführung weiter.
e
error : Ein schwerwiegender Fehler trat auf (z.B. eine Array-Grenz-Überschreitung). Das Programm wurde angehalten.
f
fatal : Etwas war fehlerhaft und kann nicht behoben werden; Der Interpreter beendet sich. Dies passiert meistens bei einem arithmetischen Rechenfehler (Fließkomma Ausnahmefehler) aber es kann auch durch einen Internen Fehler in Yabasic ausgelöst sein.
Die vorgeingestellte Info-Stufe ist w.
-licence
Hierdurch druckt Yabasic sein Copyright aus. Lesen und erkennen, dass fast alles erlaubt ist.
-doc name
Druckt die enthaltene Dokumentation des jeweiligen Yabasic-Programms oder der Library
-librarypath path
Gibt das Verzeichnis an in dem Libraries gesucht werden, die nicht im aktuellen Verzeichnis liegen.
 
 
Zurück zum Inhaltsverzeichnis ...

Vorgaben setzen unter Unix / Linux (Nur für grafischem Bildschirm)

Die Farben, Schriftart und die Fensterposition sollte mit der Kommandozeile  gesetzt werden,
oder in der Benutzereinstellungs-Datei (Das ist meist die Datei .Xresources im Stammverzeichnis) angegeben werden; z.B.:

yabasic*foreground: blue
yabasic*background: gold
yabasic*geometry: +10+10
yabasic*font: 9x15

Dies setzt den Vordergrund des Grafik-Fensters auf blau, den Hintergrund auf gold,
das Fenster wird bei Position 10,10 (Pixel) positioniert und die Schrift wird 9x15 (Pixel) sein.

Zurück zum Inhaltsverzeichnis ...


Windows

Programmstart

Nach Durchlaufen des Setup-Programms gibt es drei Möglichkeiten Yabasic zu starten::

1.

Wähle "yabasic" im Start-Menü: Yabasic wird in einem Fenster geöffnet, in dem der Basic-Programmname einfach eingegeben werden kann. 

2.

Klicke mit der rechten Maustaste auf den Desktop. Wähle "new" im aufklappenden Kontext-Menü. Dies erzeugt ein neues Icon auf dem Desktop. Das Kontext-Menü dieses Icons hat drei Einträge "Execute", "Edit" und "View docu" (was die verknüpfte Dokumentation zeigt, falls vorhanden).
Ein Doppelklick startet das Programm.

3.

Erzeuge eine Datei mit dem Yabasic-Programm. Diese Datei soll die Erweiterung ".yab" haben. 
Doppel-Klick auf diesen Dateinamen startet Yabasic um das Programm auszuführen. 

Zurück zum Inhaltsverzeichnis ...


Startoptionen unter Windows

-h
Druckt ein kurze Hilfe aus. -help oder -? genauso.
-geometry Koordinaten
z.B. +20+10 wird das grafische Fenster 20 Pixel rechts und 10 Pixel unter der oberen linken Ecke des Bildschirms setzen.
-font Schriftart
Schriftart für Text in der Grafik. Auswahl:
decorative, dontcare, modern, roman, script, swiss
Man kann, ohne Leerzeichen, die Schriftgröße anhängen. z.B. swiss30 wählt einen swiss font, 30 Pixel hoch.
-i   Info-Level
Setzt den Anfangs-Info-Stufe. Dies steuert die Informations-Menge, die man über den Stand der Programmausführung erhält.
Jede Stufe enhält alle niedrigeren Stufen (z.B. w enthält f und e):
d
Setzt die Info-Stufe auf debug : Dies ergibt detaillierte Fehlersuch-Information. Viel mehr Angaben als Sie es lesen möchten.
n
note : Nützliche Informationen,  z.B. über Laufzeit und Speicherbelegung.
w
warning : Erzeugt Warnungen, wenn etwas falsch läuft (z.B. teilen durch Null). Ttrotzdem geht die Ausführung weiter.
e
error : Ein schwerwiegender Fehler trat auf (z.B. eine Array-Grenz-Überschreitung). Das Programm wurde angehalten.
f
fatal : Etwas war fehlerhaft und kann nicht behoben werden. Der Interpreter beendet sich. Dies passiert meistens bei einem arithmetischen Rechenfehler (Fließkomma-Ausnahmefehler) aber es kann auch durch einen internen Fehler in Yabasic ausgelöst sein.
Die vorgegebene Info-Stufe ist w.
-licence
Hierdurch druckt Yabasic sein Copyright aus. Schauen Sie sichs an und erkenne Sie, dass fast alles erlaubt ist.
-doc name
Druckt die enthaltene Dokumentation des jeweiligen Yabasic- Programms oder der Library.
-librarypath path
Gibt das Verzeichnis an in dem Libraries gesucht werden, die nicht im aktuellen Verzeichnis liegen.
 

Zurück zum Inhaltsverzeichnis ...


Vorgaben setzen unter Windows

Um die Vorgaben für Grafik-Schrift, Schriftgröße und Fenster-Position zu setzen, muss man die Registry bearbeiten.

Yabasic speichert die Vorgaben unter:

HKEY_LOCAL_MACHINE/SOFTWARE/Yabasic

Man kann die Unterschalter "font" und "geometry" bearbeiten. Diese Unterschalter akzeptieren dieselben Werte wie die entsprechende Kommandozeilen-Optionen-font und -geometry. Kommandozeilen haben Vorrang vor Registry-Einstellungen.

Zurück zum Inhaltsverzeichnis ...


Yabasic in Beispielen erklärt

Ein einfaches Programm

Dies ist das erste Beispiel:

REM Dies ist das erste Yabasic-Programm
input "Gib zwei Zahlen ein:" a,b
print a,"+",b,"=",a+b
print "Gib bitte deinen Namen ein:";
INPUT a$
print "Hallo ",a$," !"

Dieses Programm erzeugt die folgende Ausgabe
Benutzereingabe wird  so angezeigt):

Gib zwei Zahlen ein: 2 3
2+3=5
Gib bitte deinen Namen ein: Bill
          Hallo Bill !

Diese einfachen Programme enthalten drei Kommandos:

REM
Das REM-Kommando leitet Kommentare ein. Alles nach REM bis zum Ende der Zeile wird vom Interpreter nicht beachtet.
input
Dieser Befehl liest eine oder mehrere  vom Benutzer eingegebene Variablen ein. Der wahlweise Promptstring nach dem input-Befehl ("Gib eine Zahl ein:") erscheint auf dem Bildschirm, bevor eine Eingabe gelesen wird. Beachten Sie, dass hinter dem Promptstring kein Semikolon  steht! Um mehr darüber zu erfahren,  wie input eine Zeile in Teile zerschneidet, lesen Sie den Abschnitt Mehr über Input. Um zu wissen, wie input von der Tastatur verzugslos gelesen wird, siehe Einlesen einers Tastendrucks von der Tastatur.
print
Der Print-Befehl schreibt alle seine Argumente auf den Bildschirm. Nach dem Schreiben des letzten Arguments springt printzur nächsten Zeile (wie bei print "Hallo ",a$," !"). Um diesen automatischen Zeilensprung zu verhindern, setzt man ein Semikolon (;)hinter das letzte Argument (wie bei print "Gib bitte deinen Namen ein:";). Um einen Tabulatorsprung zu erhalten, füge man ein Komma an(,), z.B. print "Gib bitte deinen Namen ein:". Beachte,  dass print durch ein Fragezeichen (?) ersetzt werden kann. Wenn Sie die Schrift (oder die Eingabe) an einer bestimmten Stelle zeigen wollen, dann lesen Sie den Abschnitt Ausgabe auf dem Bildschirm.

Weiterhin sollten einige allgemeine Eigenschaften von Yabasic beachtet werden:

Schreibweise (Case)
Befehle können in beliebiger Schreibweise eingegeben werden:
input ist gleichbedeutend mit INPUT und sogar mit InPUt.
Dies gilt für jeden Befehl in Yabasic, jedoch nicht für Variable, z.B. sind a$ und A$ unterschiedliche Variable!
Variable
Variablennamen sind groß/klein-empfindlich (z.B. sind die Variablen: a$ und A$ zwei unterschiedliche) aber können beliebig lang sein.
Es gibt zwei Arten von Variablen:
 
Stringvariable
z.B. a$, b12$ oder VeryLongName$ dürfen Strings beliebiger Länge beinhalten.
Stringvariable haben immer ein Dollar-Zeichen ($) am Ende ihres Namens.
Numerische Variable
z.B. a, c3po oder Dies_ist_ein_sehr_langer_Name stehen für reale Zahlen wie 2, -1.3, 15.3e44 oder 0.
Variable (mit Ausnahme von Arrays) brauchen nicht deklariert zu werden.
Ihr Anfangswert ist "" (bei Stringvariablen) und 0.0 (bei numerischen Variablen).

Zurück zum Inhaltsverzeichnis ...


Rechnen

Rechenarten (Operanden)

Yabasic kennt fünf Rechenarten: + (Addition), - (Subtraction), * (Multiplikation), / (Division) und ^ (Potenzieren (hoch...)).
Sie verhalten sich wie üblich, z.B. die Programmzeile

print 1+2,2*3,4/2,2^3

erzeugt diese Ausgabenzeile:

3 6 2 8

Hinweis: Der Potenzieren-Operand (^) darf auch Potenzbrüche enthalten: 8^(1/3) ergibt 2 als Resultat.

Funktionen

Dieser Abschnitt beschreibt und erklärt die Rechenfunktionen von Yabasic.

Trigonometrische Funktionen:
Es gibt 6 trigonometrische Funktionen:
print sin(1.0),cos(pi),tan(3)
print asin(0.5),acos(0.7)

    print atan(2),atan(1,2)

Diese Zeilen erzeugen diese Ausgaben:
Wie sie sehen, kann Yabasic mit Sinus, Cosinus, Tangens und ihren Kehrwerten rechnen. Und wenn Sie ein Auge für Trigonometrie haben, wird ihnen aufgefallen sein, dass alle Funktionen das Argument im Bogenmaß erwarten.
Um die Umrechnung von Grad in Bogenmaß zu ermöglichen (Bogenmaß=Grad*pi/180), gibt es die reservierte Variable  pi (oder PI), mit dem festen Wert 3.14159.
Beachten Sie auch, dass die atan()-Function in zwei Arten erscheint.
Mit einem Argument (z.B. atan(2)) atan() ergeben sich ein Werte zwischen  -pi/2 ... +pi/2.
Aufgerufen mit zwei Argumenten (z.B. atan(2,-1)) atan() ergeben sich Werte zwischen -pi und +pi.
(Dies kann hilfreich sein z.B. zur Transformation von kartesischen in polare Koordinaten).
Exponenten:
Die exp() Funktion erscheint als ihre inverse Funktion, der log()-Funktion:
Integer-/Ganzzahlen und Bruchteile:
Die Funktionen int() und frac() zerlegen das Argument am Dezimalpunkt:
Absolute Zahlen und Vorzeichen
Die abs() und die  sig() Funktion geben den absoluten Wert (ohne Vorzeichen) und das Vorzeichen des Arguments wieder:  abs(-2.34),abs(2.34),sig(-2.34),sig(0),sig(2.34) ergibt: 2.34 2.34 -1 0 1
Rest einer Division
Um den Rest einer Division zu erhalten, ist die Modula-Funktion mod()anzuwenden. Z.B. mod(11,4) erzeugt 3,
Minimum und Maximum:
Ergibt den niedrigsten bzw. den höchsten Wert von zwei Argumenten:
Quadratwurzel und Quadratzahl:
Die Quadratwurzel wird berechnet von  sqrt(), die Quadratzahl mit sqr( ):
Hexadezimale Zahlen:
Um eine Dezimalzahl in eine Hexdezimalzahl umzuwandeln und umgekehrt, benutzt man hex$() und dec():

Ganz ähnlich funktioniert die Umwandlung in binäre Zahlen: So ergibt bin$(8) den Wert "100" und umgekehrt hex("100",2) den Wert 8; dabei verlangt die funktion dec() als zweites Argument die Basis (hier: 2), wenn sie vom Standardwert 16 abweicht.

Zufallszahlen:
werden erzeugt mit der ran()-Funktion. Diese Funktion kennt zwei Arten: Aufgerufen ohne Argument (z.B. print ran()) erhält man eine Zufallszahl zwischen 0 und 1. Aufgerufen mit einem Argument (z.B. print ran(2)) erhält man eine Zufallszahl zwischen 0 und dem vorgegebenen Argument.

Bitmanipulation:

Sie können die bitweisen Operationen and(), or(), eor(), die auch als xor() geschrieben werden können, benutzen wie z.B. hier:
print and(10,7),or(9,3),eor(15,4)

Dies ergibt 2 11 11 als Resultate.
Beachten Sie aber immer, dass Yabasic keine no not() Operation kennt.

Zurück zum Inhaltsverzeichnis ...


Verzweigungen: Der if-Befehl

Um zu verzweigen, muss der if-Befehl benutzt werden:

input "Gib bitte eine Zahl ein" a
if (a>10) then 
       print "Die Zahl ist größer als 10" 
   elsif (a>5) then 
       print "Die Zahl ist gößer als 5, aber kleiner oder gleich 10" 
   else
       print "Die Zahl ist kleiner als oder gleich 5" 
endif

Wie Sie hier sehen, muss die Verzweigungsbedingung in runden Klammern eingeschlossen sein (...).
Der else und der elsif-Teil der if-Anweisung sind beliebig ound können auch weggelassen werden, so wie im folgenden Beispiel:

input "Bitte gib eine Zahl ein" a 
if (a>10 and a<20) print "größer als 10":print "aber kleiner als  20" 
fi

Beachten Sie, dass endif auch als fi geschrieben werden kann!

Falls Sie noch weniger schreiben wollen, dann versuchen Sie mal:

input "Bitte eine Zahl eingeben" a
if (a>10 and a<20) print "größer als  10 aber weniger als 20"

Beachten Sie, dass then und endif (oder fi) weggelassen wurden.
Obwohl eine einfache Anweisung der folgenden Art ausführbar ist, z.B.
if (a>10 and a<20) print "größer als 10":print "aber weniger als 20"  (Zwei print-Anweisungen)
wird nicht das gewünschte Ergebnis ausgeben: Der Satzteil "aber weniger als  20" wird, unabhängig vom Wert a, immer ausgegeben.

Nun wollen wir uns die Bedingungen (a>10 and a<20) der if-Anweisung genauer ansehen:

Logische Operatoren, Vergleiche:
Zahlen oder Rechen-Ausdrücke können mit den bekannten Operatoren: = (gleich), <> (ungleich), < (kleiner als), <= (kleiner als oder gleich), > (größer als) und >= (größer als oder gleich) benutzt werden.
Mehrere Befehle in einer Zeile
Eine Zeile kann mehrere Befehle enthalten:

Zurück zum Inhaltsverzeichnis ...


Strings (Zeichenfolgen)und Schleifen (loops)

Basic war immer einfach und stark in der String-Verarbeitung. Und auch Yabasic versucht, diese Tradition fortzusetzen:

Wenn Sie dieses Programm ausprobieren, werden Sie diese Ausgabe erhalten:

Gib bitte ein Wort ein: Hallo
for-next-Schleifen (loops)
Das Herz des obigen Programms ist die for-loop-Schleife: Alles von for bis next wird solange wiederholt, bis die Variable a vom Startwert len(a$) zum Endwert 1 gelangt ist. Wie Sie sicherlich schon ahnen, gibt  len(a$) die Länge des Strings an.
repeat-until-Schleifen (loops) und while-wend Schleifen (loops)
Natürlich kann die for-loop-Schleife auch als repeat-until Schleife oder als  while-wend Schleife verwendet werden:

Innerhalb der obigen for-next-loop- Schleife werden die String-Funktionen len() und mid$() angewandt,
aber es gibt noch viele andere String-Funktionen:

Strings in Teilstücke zerlegen:
Es gibt drei Funktionen, die Stringteile erzeugen:

    a$="123456"
    print left$(a$,2),"-",mid$(a$,2,3),"-",right$(a$,3)
    erzeugt folgende Ausgabe: 12-234-456

    Wie Sie sehen, schneidet left$() so viele Buchstaben von links ab, wie es im zweiten Argument angegeben ist.
    right$() schneidet von rechts und mid$() schneidet aus der Mitte,
    wobei das zweite Argument die Startstelle und das dritte Argument die Anzahl der auszuschneidenden Zeichen angibt. Wenn man das dritte Argument wegläßt erhält man den string von der angegebenen Position bis zum Ende: mid$("Hallo",2) gibt also "allo" zurück.
    Darüber hinaus kann mid$() und seine 'Verwandten' sogar benutzt werden, um ausgewählte Teile eines Strings zu ersetzen:
    a$="123456":left$(a$,2)="abcd":print a$
    ergibt ab3456
    Wie Sie sehen wurden nur die beiden linken Buchstaben ausgetauscht (obwohl der String "abcd" vier Buchstaben enthält).
    Dasselbe kann mit mid$() oderr right$() erzielt werden. Schließlich ist noch zu erwähnen, daß die Zuweisung an left$()/mid$()/right$() nie die Länge des Strings ändert.

Strings(Text) in Zahlen verwandeln und umgekehrt:
Die Funktion str$() wandelt das numerische Argument in einen String:

    print str$(12) ergibt den String (Text) "12" als Resultat.
    Die Formatierung der Zahl kann durch ein wahlweises weiteres Argument bestimmt werden:
    print str$(12.123455,"##.##") ergibt den String 12.12.
    Das zweite Argument hat denselben Effekt wie der Formatstring des print using Befehls.
    Genau das Umgekehrte macht die Funktion val():
    print 2+val("23") ergibt 25 als Resultat, während print val("e2") eine 0 liefert, weil "e2" keine gültige Zahl ist.

Zeichensätze:
Yabasic bietet zwei Funktionen an, um mit einem Zeichensatz zu arbeiten.

asc() ergibt die Nummer eines Zeichens im aktiven Zeichensatz:
print asc("e") ergibt 101 als Ergebnis, weil das Zeichen "e" die Nummer 101 im Zeichensatz hat.

Umgekehrt ergibt die Funktion chr$() das Zeichen der entsprechenden Nummer im Zeichensatz:

Sonderzeichen

ä

ö

ü

Ä

Ö

Ü

ß

§

¦

©

é

@

#

€ Euro

®

ASCII-Nummer

132

148

129

142

153

154

225

21

 

 

130

64

35

(238)

 

Latin1-Nummer

228

246

252

196

214

220

223

167

166

169

233

64

35

128

174

PC850-Nummer

132

148

129

142

153

154

226

245

221

184

130

64

35

128?

169

Windows-Nummer

228

246

252

196

214

220

223

167

166

169

233

64

35

128

174

Mit dem folgenden Programm sehen Sie alle Bildschirmzeichen und ihre Nummern

clear screen:i=0
while (i<256)
   print chr$(i),"=",i,
   i=i+1
wend
Escape-Folgen
Trotzdem brauchen Sie chr$() nicht so häufig zu verwenden wie Sie vielleicht vermuten. Ud zwar weil die wichtigsten nichdruckbaren Zeichen auch erreicht werden, wenn Sie mit dem Backslash-Zeichen(\) Escape-Folgen bilden.

    Sie können \n benutzen statt chr$(10), sobald Sie einen Zeilenvorschub brauchen.

Die folgende Tabelle zeigt  alle Escape-Folgen von Yabasic

    (Natürlich sind nur solche Escape-Folgen verfügbar, die auch in der C-Sprache vorhanden sind):

 

Escape-Folgen

ASCII-Zeichen

\n

Zeilenvorschub

\t

Tabulatorsprung

\v

vertikalerTabulator

\b

Rückschritt

\r

Wagenrücklauf

\f

Seitenvorschub

\a

Glocke

\\

Backslash

\`

Einf. AnfStrich

\"

Dopp. AnfStrich

Escape-Folgen stehen immer zwischen doppelten Anführungsstrichen (""), z.B. innerhalb von Strings. Benutzereingaben über die  input-Anweisung ist in keiner Weise hiervon betroffen.

Jedoch beachten Sie, dass   Windows-Pfadangaben  Zeichenfolgen beinhalten, die leider ebenfalls als  Escape-Folgen erkannt werden.

 

Hier ein weiteres Beispiel, das in die übrigen String-Funktionen von Yabasic einführt:

label schleife
  print "Bitte geben Sie eine String ein, der
das Wort \"Yabasic\"  enthält"
  input a$
  if (instr(lower$(a$),"yabasic")<>0) then  (Kleinschreibung)
    gosub danke
  else
    print "Nein, bitte noch einmal!"
  endif
goto schleife
label danke
print "Vielen Dank!"
return

Wenn Sie dieses Programm starten, werden Sie folgende Ausgabe erhalten:

Bitte geben Sie eine String ein, der das Wort "Yabasic"  enthält
?thequickbrownfox    (Eingabe)
Nein, bitte noch einmal!
Bitte geben Sie eine String ein, der das Wort "Yabasic"  enthält 
?jumpedyabasicoverthelazydog    (Eingabe)
Vielen Dank!
Sprungziele in einem Programm markieren
Die erste Zeile des obigen Beispiel-Programms (label schleife) ist eine Sprungmarke (label).
Da Yabasic keine Zeilennummern benutzt, nimmt man Label, um Sprungziele im Programm zu markieren.
Sie können Labels mit Buchstaben und Ziffern bilden.
Das Schlüsselwort label ist erforderlich und jeder Label darf in einem Programm nur einmal verwendet werden.
Dennoch erlaubt Yabasic auch Zeilennummern .
Im Programm umherpringen
Der Label selbst bewirkt keine Aktion. Nur in Verbindung mit dem goto-Befehl (oder gosub oder restore) bewirkt ein Label eine Funktion. Wenn Yabasic auf einen goto-Befehl trifft  (hier: goto schleife) dann sucht es den angegebenen Label (hier: label schleife) und setzt die Ausführung an der Stelle des Labels fort.
Strings in Strings suchen
Das Beispielprogramm oben prüft, ob die Benutzereingabe den String "yabasic" enthält. Dies wird erreicht mit Hilfe der instr()-Funktion. instr() gibt die Position des zweiten String-Arguments innerhalb des ersten String-Arguments oder 0 wieder, falls nichts gefunden wird. Z.B. instr("Hallo","al") gibt 2 zurück, weil "al" bei Position 2 erscheint, innerhalb von "Hallo".  Aber instr("Hallo","Al") gibt 0 zurü, weil "Al" nicht in "Hallo" enthalten ist (Die Schreibweise stimmt nicht).
Außerdem akzeptiert instr() ein drittes Argument, das die Position angibt, ab der der Teilstring gesucht wird: instr("aloha","a") gibt 1 zurück, instr("aloha","a",2) dagegen 5, weil die Suche nach einem "a" ab der zweiten Stelle in "aloha" erst an der fünften Stelle fündig wird.
Schließlich: Es gibt eine rinstr()-Funktion, die ihre Suche von rechts her beginnt und nach links fortschreitet; auch die rinstr()-Funktion hat eine Form mit drei Argumenten.
Wechsel zwischen Groß- und Kleinschreibung
Das Beispiel-Programm enthält einige weitere String-Funktionen:
lower$() und sein Gegenstück upper$() wandeln ein String-Argument jeweils in groß- oder kleingeschriebene Zeichen,
z.B. lower$("aBcD12fG") ergibt "abcd12fg".
Leerzeichen entfernen
ltrim$() und rtrim$() sind zwei Funktionen, um führende oder nachgehende Leerzeichen aus einem String zu entfernen,
z.B. ltrim$(" foo ") ergibt "foo " und rtrim$(" foo ") ergibt " foo".
Und trim$() ist gleichbedeutend mit rtrim$(ltrime$()).
Zerlegen eines Strings in Token (Teilstrings)
Es gibt zwei hilfreiche Funktionen um einen String in Teilstrings (Token) zu zerlegen; beide erwarten folgende Parameter: Einen String, der in Token zerlegt werden soll und ein Array, in dem die Token abgelegt werden. Ein Beispiel:
Das Programms erzeugt folgende Ausgabe:
eins
zwei
drei
Man sieht, daß token() das Array words$() nach Bedarf vergrößert; der alte Inhalt des Arrays wird dabei verworfen. Weiter darf man beim übergebenen Array keine Indices mitgeben (i.e. a$(2) ist falsch, a$() dagegen richtig). Wenn man schließlich noch ein drittes Argument übergibt (e.g. token(a$,words$(),":;")), wird der String an den Zeichen zerlegt, die in diesem Argument vorkommen.
Eng verwandt mit token() ist die split() Funktion:
wird diese Ausgabe erzeugen:
Token:
Token:
Token: eins
Token:
Token: zwei
Token: drei
Token:
Token: vier
split() achtet auf Trennzeichen (":" im Beispiel); wenn der String n Trennzeichen enthält, wird split() genau n+1 Token zurückgeben (wenn der String allerdings leer ist, bekommt man gar keine Token). split() gibt als Token zurück, was zwischen zwei Trennzeichen steht, selbst wenn die Token leer sein sollten.
token() andererseits achtet auf die erzeugten Tokens und überspringt ein oder mehrere Trennzeichen, wenn sie direkt aufeinander folgen. token() gibt keine leeren Tokens zurück.
Globbing, Stringvergleiche mittels Platzhaltern (Wildcards)
glob() prüft, ob das erste String-Argument  mit dem zweiten String-Argument, dem Prüfstring, übereinstimmt.
Das Ergebnis ist WAHR oder FALSCH
Dieses zweite String-Argument darf die Platzhalter ?und * enthalten,
wobei ? ein beliebiges Zeichen representiert  und * für eine beliebige Anzahl beliebiger Zeichen steht.
Glob kann nur in Verzweigungen verwendet werden
(z.B. nach if, while oder until) wie in if (glob("Hallo","H*o")) print "Es passt !".
Nun einige Beispiele:

glob-Bedingung

WAHR/FALSCH ?

glob("abcd","abc?")

WAHR

glob("abab","*")

WAHR

glob("abc","ab??")

FALSCH

glob("abcdabab","ab*ab")

WAHR

glob("abcd","*a")

FALSCH

 

Zurück zum Inhaltsverzeichnis ...


Benutzerdefinierte Unterprogramme

Eines Tages werden Sie sich nicht mehr mit Yabasic's eingebauten Funktionen und Befehlen zufrieden geben.
Dies wird der Zeitpunkt sein,  die erste Subroutine  zu schreiben und zu nutzen:

print vielfach$("Hallo",3)
 
   sub vielfach$(a$,a)
 
      local b$,b
      for b=1 to a:b$=b$+a$:next b
      return b$
 
   end sub

Dieses Programm gibt einfach den String HalloHalloHallo aus bestehend aus Hallo, verdreifacht. Da es aber in Yabasic keine Funktion zum "Verdreifachen" von Strings gibt, definiert das Programm selbst eine eigene Funktion vielfach$() (beginnend mit sub vielfach$(a$,a)).
vielfach$() ist eine Benutzerdefinierte String-Funktion. Aufgrund des $-Zeichens in vielfach$() kann man ableiten, dass die Funktion einen String zurückgibt.
vielfach$() braucht zwei Argumente, einen String und eine Zahl, die der Funktion durch die Variablen a$ und a übergeben werden. Diese Variablen, und genauso b$ und b (definiert in local b$,b), gelten nur innerhalb der Funktion. Sie werden bei Eintritt in die Subroutine angelegt und sie halten ihren Wert nur so lange, wie die Subroutine ausgeführt wird. Die Berechnung innerhalb der Subroutine ist unverzweigt und das Resultat wird mit dem Befehl return b$ zurückgegeben.

Anstelle von return b$ können Sie auch einfach return schreiben oder return ganz weglassen. In diesem Fall wird ein leerer String zurückgegeben (oder 0.0 bei numerischen Funktionen) . Das wäre aber nicht besonders sinnvoll bei einer Subroutine.

Hier sind einige Beispiele, die zeigen, dass Yabasic ziemlich tolerant mit benutzerdefinierten Subroutines umgeht:

print sum(1,4),sum(2),sum(),sum(2,3)
 
   sub sum(a,b)
      if (numparams<2) b=1
      return a+b
   end sub
 

sub() ist eine numerische Subroutine (weil sub() kein $-Zeichen enthält) und gibt einfach die Summe seiner beiden numerischen Argumente zurück. Dieses Programm gibt die Zeile "5 3 1" aus. Dies sind die drei Werte,  die durch die drei Aufrufe  von  sum() zurückgegeben werden.

Wie Sie sehen, kann die Funktion sum() mit weniger als zwei Argumenten aufgerufen werden. In diesem Fall wird 0.0 eingesezt für ein fehlendes numerisches Argument und der Leersting "" für ein fehlendes Stringargument. Dennoch lassen sich die lokalen Variablen abfragen.

numparams  ist eine von Yabasic reservierte Variable, um die Anzahl der durch den Subroutinen-Aufruf ausgegebenen Parameter anzugeben.. Wenn Sie ein Array-Argument weglassen, wird Yabasic ein lokales Ersatz-Array einrichten. Trotzdem, sobald Sie versuchen, das Array anzusprechen, werden Sie eine Fehlermeldung erhalten.
Deshalb ist es gute Praxis, numparams zu prüfen, bevor man auf einen Array-Parameter zugreift.

Des weiteren können Sie eine Subroutine  aufrufen (im Beispiel sub(2,3)), ohne sich um den zurückgegebenen Wert zu kümmern.
(Technisch gesehen gibt es in Yabasic keine Unterschied zwischen Funktionen und Proceduren).

Lokale Variable existieren außerhalb der Subroutine nicht. Sie werden jedesmal neu angelegt, wenn die Subroutine aufgerufen wird.
Aber manchmal möchten Sie vielleicht die Werte der Variablen in der Subroutine halten. I
In diesem Fall können Sie
static-Variable benutzen wie hier:

for a=1 to 4:stars():next a
 
   sub stars()
       static a$       (a$ bleibt für den nächsten Aufruf erhalten)
       local b$
       a$=a$+"*"
       b$=b$+"*"
       print a$," ",b$
   end sub

Der Programmlauf erzeugt folgendes Muster:

* *
** *
*** *
**** *

Wie Sie sehen,  hält die static-Variable a$ ihren Wert über Aufrufe von stars() hinweg, während b$ jedesmal zurückgesetzt wird.

Und merke, dass Subroutinen leicht Arrays in Subroutinen als Parameters, local- oder static-Variable benutzen können.
Hier ist ein Beispiel.

Zurück zum Inhaltsverzeichnis ...


Unterroutinen zur Laufzeit definieren

Hin und wieder möchte ein Programm während seiner Ausführung Unterroutinen definieren: Z.B. möchte ein Benutzer einen beliebiegen arithmetischen Ausdruck eingeben, den das Programm dann plotten soll:

Dieses Programm liest einen arithmetischen Ausdruck in die Variable f$; mögliche Werte wären z.B. "sin(x)" oder "x*x". Mit diesem Ausdruck wird dann die Definition einer einfachen Unterroutine zusammengesetzt und an das compile-Kommando übergeben, das sein string-argument in normalen yabasic-code umwandelt. Danach kann man die neu definierte Funktion f(x) ganz normal benutzen; wie in der dritten Zeile, die die Funktion grafisch darstellt.

Ein anderes Feature (das aber auch mit Unterroutinen zu tun hat) ist die Fähigkeit eine Funktion über Namen und Argumente auszuführen: execute("f",x) ist genau dasselbe wie f(x); Natürlich is execute("f",x) häßlich, aber mit diesem Feature kann genutzt werden, um eine Funktion zu plotten deren Name spezifiziert ist:

Mit dieser praktischen plot-Funktion ist es möglich plot("f") zu sagen, um einen Plot der Funktion f zu erhalten. Allerdings würde plot("x*x") einen Fehler liefern, weil versuch würde eine Funktion mit Namen "x*x" auszuführen, die es natürlich nicht gibt.

Je nachdem, ob Sie den Wert, den execute zurückgibt werwenden wollen (oder ob die per execute ausgeführte Funktion überhaupt einen Wert zurückliefert), können sie execute in einer Zuweisung oder als eigene Befehl verwenden: execute("f",x) und y=execute("f",x) sind beide gültig.

Schließlich sollten Sie noch execute$ für Funktionen verwenden, die eine Zeichenkette zurückgeben.

Zurück zum Inhaltsverzeichnis ...


Libraries (Bibliotheken)

Eine Library ist eine besondere Datei, die "fertige Subroutinen" enthält. Libraries sind nützlich, wenn Sie mehrere Subroutinen geschrieben haben, die Sie in mehr als einem Yabasic-Programm verwenden wollen. Noch besser ist es, wenn jemand anderes eine Library geschrieben hat, die Sie ohne eigene Anstrengung nutzen können.

Machen wir weiter und versuchen wir ein Beispiel (weil Libraries meistens  Subroutinen enthalten, können Sie abzweigen und zuerst über sie lesen). Dies benutzt einfach eine Library:

import ufirst
print uf$("foO")

Wenn Sie dieses Programm ablaufen lassen, gibt es "Foo" aus. Das entspricht "foO" mit dem ersten Buchstaben groß geschrieben ("f") und der Rest ("oO") verändert in Kleinschreibung. Der Name dieser Subroutine ("uf") ist einfach eine Abkürzung von "upper-first".

Die Subroutine uf$() ist  definiert in der Library ufirst,  die aktiviert wird mit dem Befehl import ufirst. Die Library ucfirst ist ziemlich einfach:

rem Hier ist die eingebettete Dokumentation:
docu 
docu   Diese Llibrary ufirst stellt eine einzige Funktion zur Verfügung: uf$(),
doc   Sie gibt das String-Argument in Kleinschreibung zurück, mit Ausnahme
doc   des Ersten Buchstabens. Der wird groß geschrieben.
doc 
docu   Z.B. uf$("foo") ergibt "Foo" und uf$("bAr") ergibt "Bar"
docu 
a=2: rem  Dieser Befehl ist zwecklos !
 
   export sub uf$(a$) : rem uf$() exportieren
      return upper$(left$(a$,1))+lower$(butfirst$(a$))
   end sub
 
   sub butfirst$(a$) : rem butfirst$() ist nur lokal sichtbar
      return right$(a$,len(a$)-1)
   end sub
 

Wenn Sie diese Library mit import ufirst in ihr Yabasic-Programm importieren, liest Yabasic in der Library und fügt sie in ihr Programm ein: Jeder Befehl in der Library (z.B. a=2 im Beispiel)  wird ausgeführt und jede Subroutine (uf$() und butfirst$()) ist definiert. Nach diesem Import sind die Variable a und die Funktionen uf$() und butfirst$() definiert in ihrem Programm. Um Konflikte zu vermeiden zwischen den Variablen und Subroutinen, die im Programm definiert sind und denen der Library, werden all diese Variablen und Subroutinen verbunden mit dem Namen der Library.  Z.B.  wird a importiert als ufirst.a, uf$(), wird importiert als ufirst.uf$() und butfirst$() wird importiert als ufirst.butfirst$(). Sie können prüfen, dass das a der Library ufirst unabhängig ist von jedem anderen a in ihrem Progamm:

import ufirst
a=1
print a,ufirst.a

Dies gibt einfach "12" aus. Es zeigt, dass "a" in ihrem Program und "a" in der Library ufirst  nicht durcheinander geraten.

Andererseits möchten Sie einige spezielle Subroutinen der Library benutzen, ohne sie mit dem Library-Namen zu verknüpfen, Dies kann erreicht werden, indem der Definition der Routine das Schlüsselwort export  hinzugefügt wird.  (im Beispiel: export sub uf$(a$)). So eine exportierte Subroutine kann ohne Verknüpfung mit dem Library Namen benutzt werden. (wie in print uf$("foO")).

Die Library beginnt mit einer Folge von docu (oder doc) Befehlen, die die eingebettete Dokumentation der Library enthält. Diese eingebettete Dokumentation kann gelesen werden, indem  man Yabasic mit der Option  "-lib" aufruft.  Benutzen Sie yabasic -lib ufirst um den Text der docu Befehle zu lesen. Deshalb ist es stets eine lobenswerte Idee, die Library mit einigen Kommentaren Auszustatten, die erklären, welche Subroutinen die Library bietet . Des weiteren sollten Sie der Library zusammen mit einem kleinen eingebetteten Beispielprogramm bereitstellen, das die Benutzung aufzeigt. Wenn sie das Beispielprogramm in if (peek$("library"="main")) then ... endif verpacken, wird ihr eingebettetes Beispielprogramm nur ausgeführt, wenn die Library als Programm ausgeführt wird, jedoch nicht, wenn andere Programme Ihre Library importieren.


Sobald Sie einige eingebettete Dokumentationen geschrieben haben, können Sie darauf auch von ihrem Programm aus zugreifen.
Fragen Sie einfach das Array mit
docu$() ab, das automatisch den Text aller docu-Befehle enthält.

Nachdem  Sie eine Library geschrieben oder erhalten haben, müssen Sie sie installieren. Das ist einfach: Der Dateiname, der die Library enthält, sollte auf  ".yab" (z.B. ucfirst.yab) enden. Diese Datei soll in ein eigenes Verzeichnis kopiert werden. Dieses besondere Verzeichnis  (z.B. c:\yabasic\libunter Windows oder \usr\lib\yabasic unter Unix /Linux) erscheint (zusammen mit der Erklärung der -lib Option), wenn Sie Yabasic mit der Option -help aufrufen (z.B. yabasic -help). Nachdem Sie die Datei in das richtige Verzeichnis kopiert haben, haben Sie's geschafft! Von jetzt ab können Sie die Library in Ihren Yabasic-Programmen benutzen, z.B. um import ucfirst zu schreiben. Des weiteren findet Yabasic eine Library sogar, wenn sie sich im aktuellen Verzeichnis befindet,z.B. im Verzeichnis, in dem sich das Yabasic-Programm befindet (mit dem import-Befehl) . Dies ist sehr bequem, um eine Library zu Bearbeiten und zu erproben.

Beachten Sie, dass der Dateiname des Programms und der Name der Library,  der im import-Befehl erscheint, immer gleich sein müssen.

Nachdem Sie all dieses nun über Libraries gelesen haben, werde Sie sich fragen, wie Sie an  Libraries kommen können.
Eine Lösung wird sein, selbst welche zu schreiben. Aber es wird bestimmt viel leichter sein, weil es weniger Arbeit bedeutet, Libraries zu benutzen, die schon von anderen Leute geschrieben wurden.
Libraries sind eine neue Fähigkeit in Yabasic, deshalb gibt es bisher keine Standard-Llibraries, aber ich hoffe, dass Benutzer nützliche Libraries entwickeln und veröffentlichen werden. Legen Sie los!!

Zurück zum Inhaltsverzeichnis ...


Grafiken (Grafischer Bildschirm) und Druckerausgaben

Yabasic bringt einige einfache, allgemein brauchbare Grafik-Befehle mit:

open window 400,400
line 0,0 to 400,400
circle 200,200,150
clear fill circle 200,200,130
clear line 0,400 to 400,0
dot 200,200
a$=inkey$
clear window
text 100,200,"Hallo !"
print "Drücke eine Taste, um das Fenster zu schließen!" 
inkey$
close window
Zeichnen
Wenn Sie dieses Programm starten, werden Sie ein Fenster der Größe von  400 Pixeln in x- und y-Richtung sehen (Die Fenstergröße wird dem open window-Befehl mitgegeben). Um eine bestimmte Schrift  für den Text anzugeben, können Sie ein drittes Argument hinzufügen, z.B. open window400,400,"swiss".
Nicht überraschend: Der line-Befehl zeichnet eine gerade Linie, der circle-Befehl zeichnet einen Kreis (Die Argumente bestimmen die  x- und y-Position des Mittelpunkts und den Radius des Kreises) und der dot-Befehl zeichnet einen Punkt am angegebenen Ort.

    Wenn Sie wollen, dann können Sie diese Befehle noch erweitern um die Schlüsselwörter clear und fill: Z.B. löscht clear line die angegebene Linie.  fill circle zeichnet einen schwarz gefüllten Kreis, während clear fill circle einen Kreis und seine Innenfläche löscht.

    Nachdem der Benutzer eine Taste gedrückt hat (siehe unten) wird der Fensterinhalt gelöscht mit dem clear window-Befehl. Wenn Sie ihren Drucker geöffnet haben (z.B. wenn Sie den open printer-Befehl gesendet haben) beendet clear window die aktuelle Seite, sendet es an den Drucker und beginnt eine neue Seite.

    Der nächste Befehl im Beispiel ist der text-Befehl, der seinen Text an die angegebene Stelle schreibt. Die Position gibt die linke untere Ecke des Textes an. Um die Ausrichtung zu ändern, können Sie als drittes Argument bestimmte Zwei-Zeichen-Strings angeben. Der erste gibt die horizontale Ausrichtung an, mit "l" (Text ist linksbündig, "r"(rechtsbündig) oder "c" (zentriert). Das zweite Zeichen gibt die senkrechte Ausrichtung an, mit  "t"(top, oben), "b" (bottom, unten) oder "c" (zentriert).
    Gültige Argumente sind
    "ct", "rb", "lc", ... Übrigens: Textausrichtung kann auch durch pokingin "textalign" erzielt werden.

    Schließlich: close window schließt das Grafik-Fenster.

Auswerten von Tastatureingaben

Aber bevor das Fenster geschlossen ist, wartet der inkey$-Befehl bis der Benutzer eine beliebige Taste drückt (in der Tastatur oder im grafischen Fenster) und dann gibt diese Taste einen String zurück. In diesem Beispiel ist nicht wichtig, welche Taste gedrückt wurde. Deshal brauchen Sie nur inkey$ (ohne Zuordnung) zu schreiben.

Einige wichtige, nicht druckfähige Tasten (z.B. die Funktions- oder Cursortasten) geben folgende längere Strings aus: up, down, left, right, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, esc, ins, del, home, end, scrnup, scrndown, enter, tab, backspace. Wenn ihre Tastatur andere  Tastaturcodes ausgibt als meines, oder wenn Sie eine Taste drücken, die Yabasic nicht erkennt, werden Sie einen ziemlich langen String erhalten (z.B. key1b5b31317e).

Normalerweise wartet Yabasic's inkey$ bis der Benutzer eine Taste drückt; aber wenn die inkey$-Funktion einen String ausgeben soll, obwohl keine Taste gedrückt wurde, können Sie ein Zeit-Aus-Argument  hinzufügen  (in Sekunden) .
Z.B.
inkey$(9) gibt ein Zeichen aus, wenn der Benutzer sofort eine Taste drückt, aber in jedem Fall automatisch nach 9 Sekunden. Dann wird ein 'leerer' String ausgegeben. Beachten Sie, dass auch ein Zeit-Aus von 0 Sekunden möglich ist, ein üblicher Wert in anderen BASICs. (Was aber nicht immer sinnvoll ist!)

Wenn Sie eine Maustaste in einem Grafik-Fenster drücken, werden Sie einen String wie "MB1d+1:0100,0200" erhalten, was für "Maustaste 1 wurde mit gedrückter shift-Taste bei x=100, y=200 gedrückt" steht. Genauso steht "MB2u+0:0300,0400" für "Maustaste 2  wurde ohne shift oder control-Taste bei x=300, y=400 gedrückt".

Die Funktionen mousex(), mousey(), mousemod() und mouseb() können benutzt werden, um die Angaben aus dem String auszuwerten, der von inkey$ geliefert wird:
a$=inkey$:if (left$(a$,2)="MB") print mousex(a$),mousey(a$),mousemod(a$),mouseb(a$)

Wenn Sie das Argument weglassen (z.B. print mousex) erhalten Sie die Werte des letzten Maus-Ereignisses durch  inkey$ zurück. Dies bedeutet, dass Sie mousex nicht benutzen können, um die Position der Maus zu verfolgen, weil sein Wert nur vom inkey$-Befehl erneuert wird. Schließlich ergibt mouseb einen positiven Wert, wenn die Taste gedrückt wurde und einen negativen Wert, wenn die Taste losgelassen wurde.

Drucker-Ausgabe und Umleitung in eine Datei
Um einen Ausdruck Ihrer Grafik zu erhalten dedarf es zweier neuer Befehle:
open window 200,200
open printer 
circle 100,100,80 
close printer 
close window
Alles zwischen open printer und close printer erscheint auf Papier. Wenn Sie den Ausdruck lieber in einer Datei speichern möchten, müssen Sie einen Dateinamen angeben, z.B. open printer "foo" leitet die Ausgabe in die Datei foo.
Beachten Sie, dass der open printer Befehl kommen muss, nachdem das Fenster geöffnet worden ist.
close printer kann weggelassen werden. Das wird automatisch mit dem Schließen des Fensters erledigt.
Neben Grafiken möchten Sie vielleicht auch unformatierten Text auf Ihrem Drucker drucken:
open #1,printer
print #1 "Hallo Welt !"
close #1
Diese Programm druckt den Text "Hallo Welt !" auf ihrem Drucker aus.

Zurück zum Inhaltsverzeichnis ...


Weitere Grafiken (Nur für Grafik-Bildschirm)

Das folgende Programm zeigt einige weitere Zeichenbefehle:
open window 600,400
window origin "lb"
new curve
   for x=-3 to 3 step 0.1: rem Diese Schleife zeichnet eine sinus-Funktion
      y=sin(x)
      line to 300+90*x,200+150*y
   next x
 
rectangle 10,10 to 110,60: rem zeichne die Legende
text 55,35,"Sinus-Funktion","cc"
inkey$
close window
Dieses Programm zeichnet eine einfache Sinus-Funktion.
window origin "lb" (Fenster-Ursprung)
Normalerweise liegt der Koordinaten-Ursprung (z.B. der Punkt 0,0) von Fenstern in der oberen linken Ecke. Der Befehl window origin kann den Ursprung an jede der vier Ecken eines Fensters verlagern. Das String-Argument ("lb" im Beispiel) besteht aus zwei Buchstaben.  Der Erste kann "l" (für links) oder "r" (für rechts). Der Zweite Buchstabe kann "t" (für top, oben) oder "b" (für bottom, unten) sein. Dies ermöglicht vier Varianten "lb", "lt", "rb" und "rt", die zu den vier Ecken eines Fensters gehören.

    Sobald der Ursprung verändert wurde, gilt er für jede grafische Operation.

rectangle 10,10 to 590,390
Dieser Befehl zeichnet einfach ein Rechteck, definiert durch beliebig gegenüberliegende Ecken und löscht die Innenfläche. Sie können den rectangle (rect als Abkürzung) Befehl ergänzen mit clear und/oder fill um das Rechteck zu löschen oder zu füllen.
new curve und line to x,y
Diese Funktionen helfen, eine Kurven als Folge vieler Geraden zu zeichnen . Jeder line to-Befehl zieht eine Linie von dem Punkt, den der vorhergehende line to-Befehl enthielt, bis zu dem Punkt im aktuellen Befehl.  Sie brauchen nur weitere line to-Befehle aneinanderzureihen. Wenn Sie eine neue Kurve beginnen möchten (d.h. eine neue Folge von Geraden) geben Sie einfach den new curve-Befehl.

Zurück zum Inhaltsverzeichnis ...


Bitmaps

Yabasic erlaubt es,  rechteckige Bereiche auf dem Bilschirm mit einfachen Befehlen zu erzeugen und zu ändern ...:

Dieses Programm bewegt einen kleinen Stern über das Fenster. Yabasic speichert Bitmaps in üblichen Strings, z.B. die Stern-Bitmap ist in der Variablen star$ enthalten.
Die
getbit$()-Funktion gibt so einen Bitmap-String zurück, wenn sie mit den Koordinaten eines Rechtecks aufgerufen wird. Im Beispiel speichert die Zeile saved$=getbit$(a,150,a+24,150+24) den Inhalt eines  24x24 ixel-Rechtecks mit den Ecken (a,150) und (a+24,150+24) in der Variablen saved$.

Sobald Sie einen Bitmap-String haben, können Sie ihn mit dem putbit-Befehl im Fenster darstellen.
Z.B. zeigt
putbit star$ to a,150,"or" die Bitmap, die in star$ enthalten ist, auf dem Bildschirm auf Position (a,150).
Das vierte  mögliche Argument ("or" imBeispiel) gibt an, wie die Pixel des Fensters mit denen der Bitmap verknüpft werden sollen:

Verknüpfung

Ergebnis

"and"

Das Pixel wird gesetzt, wenn das Fenster- und das Bitmap-Pixel gesetzt ist.

"or"

Das Pixel wird gesetzt, wenn das Fenster- und/oderdas Bitmap-Pixel gesetzt ist.

"replace"

Das Pixel wird gesetzt, wenn das Bitmap-Pixel gesetzt ist. Dies ist die Vorgabe.

"xor"

Das Pixel wird gesetzt,  wenn entweder ein Fenster- oder ein Bitmap-Pixel gesetzt ist.

"nand"

Das Pixel wird gesetzt,  wenn nicht beide, Fenster- und Bitmap-pixel, gesetzt sind.

"clear"

Wenn das Bitmap-Pixel gesetzt ist, wird das entsprechende Fenster-Pixel gelöscht

"1"

Das Fenster-Pixel wird gesetzt, ohne Beachtung des Bitmap-Pixels

"0"

Das Fenster-Pixel wird gelöscht, ohne Beachtung des Bitmap-Pixels

Wenn Sie das Verknüpfungsargument weglassen, wird "replace" angenommen.

Aber es gibt eine wichtige Einschränkung: Sie können zwar Bitmaps im Fenster erzeugen, jedoch nicht drucken!

Zurück zum Inhaltsverzeichnis ...


Data und Arrays (Felder)

Ab und zu ist es erforderlich, einem Programm Anfangswerte anzugeben.

Das folgende Beispielprogramm wandelt Zahlen in Strings:
restore namen
read maxnum
dim namen$(maxnum)
for a=1 to maxnum:read namen$(a):next a
 
label schleife
input "Bitte gib eine Zahl ein: " nummer:nummer=int(nummer)
if (nummer>=1 and nummer<=maxnum) then
       print nummer,"=",namen$(nummer)
       goto schleife
endif
print "Schade, kann "; nummer; " nicht wandeln "
 
label namen
data 9,"eins","zwei","drei","vier","fünf","sechs"
data "sieben","acht","neun"

Wenn Sie dieses Programm starten, erhalten Sie folgende Ausgaben:

Data einlesen
Wie Sie sehen, wandelt das Programm Zahlen in entsprechenden Text um.  Zu diesem Zweck muss man den Text für die Zahlen 1 bis 9 kennen. Diese Information ist in den data-Zeilen am Ende des Programms abgelegt.
Mit dem
read-Befehl holt sich das Programm nach und nach alle Daten.

    Wenn Sie von der zeilenweisen Reihenfolge abweichen möchten, um die data-Inhalte zu lesen, können Sie den restore-Befehl benutzen. Im obigen Beispiel  bewirkt restore namen, dass der nächste read-Befehl die Daten ab dem Label namen liest.

Arrays
Im obigen Beispiel sind die Wörter "eins" ... "neun"in einem String-Array namen$() abgelegt. Sie können Arrays benutzen, um große Mengen von Daten zu bearbeiten. Es gibt sowohl numerische Arrays als auch String-Arrays, aber beide Array-Arten müssen vor Gebrauch deklariert (eingerichtet) sein. Dies ist notwendig, weil Yabasic wissen muss, wieviel Arbeitsspeicher für das Array reserviert werden muss. Das Beispiel benutzt dim namen$(maxnum), um ein String-Array einzurichten.
Ein weiteres Beispiel kann
dim nummern(200) sein, um ein numerisches Array mit 200 Elementen einzurichten.

    Komplexere Aufgaben können sogar multidimensionale Arrays erfordern, mit mehr als einem Index.
    dim matrix(10,10) richtet ein zweidimensionales Array ein. Es kann bis zu zehn Array-Dimensionen geben, falls erforderlich.

    Arrays bieten mehr Funktionsumfang als in diesem einfachen Beispiel gezeigt wurde.
    Darüber können Sie mehr erfahren im Abschnitt
    Erweiterter Einsatz von Arrays.


Es sollte erwähnt werden, dass die Funktion des obigen Beispiels auch durch völlig anderen Programmaufbau erzielt werden kann:
 

label schleife
input "Bitte gib eine Zahl ein: " nummer:nummer=int(nummer)
on nummer+1 gosub schade,eins,zwei,drei,vier,fuenf,schade
goto schleife
 
label schade:print "Schade, kann "; nummer; " nicht wandeln ":end
label eins:print "1=eins":return
label zwei:print "2=zwei":return
label drei:print "3=drei":return
label vier:print "4=vier":return
label fuenf:print "5=fünf":return

Diese Programm erzeugt dieselbe Ausgabe wie das Beispiel darüber.

on gosub, on goto
Das Herz dieses Beispiels ist der on gosub-Befehl, auf den eine Label-Liste folgt (schade,eins,zwei,...).
Abhängig vom Wert des Ausdrucks (
nummer+1) wird der entsprechende Label aus der Liste gewählt:
Z.B. wenn (
nummer+1) eine 3 ergibt, ist der dritte Label (drei) bestimmt und ein gosub zu diesem Label wird ausgeführt.
Ein gosub wird immer ausgeführt, unabhängig vom Wert des Ausdrucks.
Insbesondere, wenn
nummer+1 irgend etwas kleiner oder gleich 1 ergibt, wird der erste Label (schade) gewählt.
Wenn
nummer+1 irgend etwas größer oder gleich der Anzahl der Elemente der Liste ergibt (Das ist 7 im Beispiel), dann wird der letzte Label (schade) gewählt.
Deshalb wird der Label
schade stets genommen, wenn das Programm die gegeben Zahl nicht wandeln kann.

     
    Und beachtenSie, dass das
    on-Konstrukt auch als on goto benutzt werden kann.

Ihr Programm beenden
Eine weitere neuer Befehl im obigen Beispiel ist derend-Befehl, der Ihr Programm sofort beendet.
Der 
exit- Befehl ist dem end-Befehl vergleichbar, aber Sie können ein Argument hinzufügen (z.B. exit(2)), das dem zugrundeliegenden Betriebssystem mitgeteilt wird. Desweiteren beendet exitIhr Programm sofort, sogar wenn ein grafisches Fenster geöffnet ist.
Der dritte Weg, ein Programm zu beenden,  ist der
error-Befehl, der mit einem String-Argument versehen werden kann.
Z.B. beendet
error "nicht gut" das Yabasic-Program und gibt "nicht gut" zurück in der Art der Yabasic-Fehlermeldungen.

Zurück zum Inhaltsverzeichnis ...


Mehr über Arrays

Sehen Sie sich diese Programm an:

dim a$(3,4)
for a=1 to 3:for b=1 to 4
   a$(a,b)=str$(a)+","+str$(b)
next b:next a
print_array(a$())
dim a$(5,6)
print_array(a$())
   sub print_array(b$())
       local x,y,a,b
       x=arraysize(b$(),1)
       y=arraysize(b$(),2)
       for a=1 to x
          for b=1 to y
             b$(a,b)="("+b$(a,b)+")"
             print left$(b$(a,b)+"           ",10);
          next b
          print
       next a
       print
   end sub

Wenn Sie diese Programm ablaufen lassen, werden Sie etwa dieses sehen:

(1,1)     (1,2)     (1,3)     (1,4)
 
(2,1)     (2,2)     (2,3)     (2,4)
 
(3,1)     (3,2)     (3,3)     (3,4)
 
((1,1))   ((1,2))   ((1,3))   ((1,4))   ()        ()
 
((2,1))   ((2,2))   ((2,3))   ((2,4))   ()        ()
 
((3,1))   ((3,2))   ((3,3))   ((3,4))   ()        ()
 
()        ()        ()        ()        ()        ()
 
()        ()        ()        ()        ()        ()

Zuerst richtet dieses Programm das String-Array a$(4,3)  ein und ordnet jedem Element einen String zu, der aus den Indizes der einzelnen Elemente besteht. Dann ruft das Programm die Subroutine print_array() auf, die das Array ausgibt.

print_array() akzeptiert ein Array als Parameter. Wenn die Subroutine aufgerufen wird (z.B. print_array(a$())), wird das Array trotz fehlender Indizes (z.B. einfach a$() ) übergeben.

Zuerst ermittelt die Subroutine die Größe des übergebenen Arrays.
arraysize(b$(),1) gibt dieGröße der ersten Dimension des Arrays b$() wieder.
Genauso gibt arraydim(b$()) die Anzahl der Dimension des angegebenen Arrays ( 2 im Beispiel) aus.

Die Routine print_array() gibt nicht nur das Array aus, sondern ergänzt es auch.
Der Ausdruck b$(a,b)="("+b$(a,b)+")" versieht jedes Element mit Klammern. Sobald print_array() ein zweites mal aufgerufen wird, werden die Array-Elemente doppelt ergänzt, z.B. werden sie in doppelte Klammern eingeschlossen.
Dies zeigt, dass das Array a$(), das der Subroutine übergeben wird, sofort ergänzt wird. Obgleich die Subroutine einen anderen Namen ( b$() ) für das Array benutzt, so hat sie doch keine lokale Kopie des Arrays. Stattdessen arbeitet sie mit dem Array des Hauptprogramms ( a$() ). Dieses Verhalten wird "Aufruf durch Adressverweis" genannt, anders als die Behandlung von Nicht-Array-Parametern (einfache Strings und Zahlen) die "Aufruf durch Wertübergabe" genannt wird.

Nach erstem Aufruf der  Routine print_array(), führt das Beispielprogramm erneut dim für das Array a$() aus, das einfach die Array-Größe ändert. Dieses Neu-Dimensionieren (Sie können auch redim schreiben), behält den ganzen alten Inhalt und richtet jedes neue Element mit einem leeren String ein (oder mit 0.0 für numerische Arrays).
Wenn Sie versuchen, die Größe eines Arrays zu verkleinern  (z.B. aus
dim a(10) ein dim a(5) machen wollten ), wird dieser Befehl nicht ausgeführt.

Zurück zum Inhaltsverzeichnis ...


Dateien (Files) und mehr über input

Um die Beispiele dieses Abschnitts zu verstehen, wollen wir annehmen, dass eine Datei test.dat im aktuellen Verzeichnis vorhanden ist und dass sie die folgenden drei Zeilen enthält:

eins zwei drei
 
vier fünf
sechs sieben acht neun

Das nächste Beispiel öffnet diese Datei und gibt seinen Inhalt aus:

open 1,"test.dat","r"
while(!eof(1))
   input #1 a$
   line input b$
   print "a$=\"",a$,"\", b$=\"",b$,"\""
wend
Eine Datei öffnen
Um eine Datei zu benutzen, muss man sie zuerst öffnen. open1,"test.dat","r" öffnet die Datei test.dat und weist Ihr die Dateinummer 1 zu. Diese Dateinummer wird benötigt, um die Datei später wieder ansprechen zu können (z.B. input #1). Dateinummern gibt es von #1 bis zu einem größten Wert (meist über 50), je nach ihrem System. Die Raute ist  traditionell erforderlich. Das wahlweise dritte Argument ("r") des the open-Befehls bestimmt den Datei-Modus. Abhängig davon, ob Sie eine Datei zum lesen oder schreiben öffnen, müssen Sie einen anderen Modus angeben. Die Datei-Moden sind aus der C-Programmiersprache entlehnt.  Hier ist die Auswahl:

Dateimodus

Zweck

"r"

Öffnen zum Lesen, Lesebeginn am Anfang der Datei

"w"

Öffnen zum Schreiben, bisheriger Inhalt wird gelöscht und überschrieben

"a"

Öffnen zum Schreiben durch Anhängen an die bestehende Datei
oder eine neue Datei mit dem angegebenen Namen eröffnen,
falls keine Datei mit diesem Namen bestand

 
Sie können auch "rb", "wb", "ab" versuchen. Der Buchstabe "b" steht für binären Modus, der es erlaubt, Dateien mit Nicht-Text-Inhalt zu öffnen und zu lesen.

Wenn Sie mit einer Dateibearbeitung fertig sind, sollten Sie sie schließen (close), um die Dateinummer für den nächsten open-Befehl frei zu machen.

Es gibt eine besondere Variante des open-Befehls, der es ermöglicht zu prüfen, ob sich eine Datei öffnen lässt:

if (not open #1,"test.dat","r") print "Kann Datei nicht öffnen!"
In Windows-Pfad angeben
Seien Sie aufmerksam, wenn Sie  einen absoluten Pfad angeben: "C:\yabasic\test.dat" ist kein gültiger Pfad, weil die Zeichenfolge "\t" innerhalb diese Strings von Yabasic als Escape-Folge ansieht und folglich in einen Tab-Sprung übersetzt werden wird. Um solche Probleme zu vermeiden, sollten Sie Ihre Backslashes stets doppelt schreiben wie "C:\\yabasic\\test.dat", weil "\\" zwar auch eine Escape-Folge ist, die aber von Yabasic als "\" interpretiert wird.
Lesen und Schreiben
Sie können in eine Datei genauso schreiben wie Sie auf den Bildschirm schreiben. Der einzige Unterschied besteht in der Dateinummer, die dem print-Befehl beigefügt wird. print #1 "Hallo" schreibt den String "Hallo" in die Datei mit der Dateinummer #1. Beachten Sie, dass es zwischen der Dateinummer (#1) und dem zu schreibenden Text ("Hallo") kein Komma gibt. Das Lesen erfolgt in gleicher Weise. input #1 a$ liest die Variable a$ aus der Datei mit der Dateinummer #1.

Zurück zu unserem obigen Beispielprogramm. Wenn sie es ablaufen lassen, werden Sie folgende Ausgabe erhalten:

a$="eins",b$="zwei drei"
a$="vier", b$="fünf"
a$="sechs", b$="sieben acht neun"
End of File (Datei-Ende)
Wie Sie sehen, durchläuft das Programm eine Schleife, solange bis die Datei vollständig gelesen wurde. Dies wurde erreicht mittels der Datei-Ende-Funktion eof(1), die FALSCH zurückgibt, solange noch Zeichen in der Datei sind, deren Dateinummer als Argument genannt wurde, und gibt WAHR zurück, wenn das Ende der Datei erreicht wird. Als einen besonderen Fall können Sie eof(0) benutzen um zu prüfen, ob noch Zeichen beim Standard Input  (z.B. Tastatur) vorhanden sind. Dies macht möglicherweise nur Sinn, wenn Yabasic als Script läuft.
Mehr über input
Sie mögen sich schon gefragt haben, wie die drei Zeilen in test.dat  den Variablen des input-Befehls zugeordnet werden.
Das hängt von der Art des benutzten input-Befehls ab:

Dies gilt unabhängig davon ob Sie aus einer Datei lesen (z.B. input a$) oder von einem Terminal (z.B. input #1 a$)

Binäre Dateien
Wenn Sie binäre Dateien bearbeiten müssen, müssen Sie zurückgreifen auf peek (lesen)und poke (schreiben).
Wahlfreier Dateizugriff
Normalerweise liest Yabasic ein Byte nach dem anderen aus einer Datei. Dennoch können Sie die Funktionen seek() und tell() benutzen, um sich in einer geöffneten Datei frei zu bewegen:
open #1,"test.dat","w":print #1 "abcdefghijkl";:close #1
open #1,"test.dat","r"
print chr$(peek(#1))," ";
seek #1,2:print chr$(peek(#1))," ";
seek #1,3,"here":print chr$(peek(#1))," ";
seek #1,-2,"end":print chr$(peek(#1))," ";
print tell(#1)
close #1

Das Programm erzeugt zuerst eine Datei test.dat, die den Text "abcdefghijkl" enthält. Danach werden einzelne Zeichen aus der Datei ausgelesen mit peek(). Zwischen den 'Peeks' wird die Position in der Datei durch seek geändert; schließlich ermittelt tell() die Position in der Datei. Der Ablauf des Programms erzeugt eine Ausgabezeile: "a c g k 11".

seek hat zwei oder drei Argumente. Die Dateinummer, die neue Startposition in der Datei und (wahlweise) die Position, von der aus die Startposition gezählt wird. Diese Position kann sein "begin" (Die Startposition zählt vom Anfang der Datei. Das ist die Vorgabe), "here" (Die Startposition zählt von der aktuellenPosition in der Datei) und "end" (Die Startposition zählt vom Ende der Datei).
Schließlich können Sie auch (ähnlich wie beim
open Kommando) seek() in der einer if-Bedingung benutzen (z.B. if (!seek(...)) error "Shit !"); damit kann man auf einfache Weise den Erfolg eines seek() testen.

Unformatierten Text drucken
Sie können das Schlüsselwort printer ohne Anführungsstriche angeben anstelle eines Dateinamens, um auf Ihrem Drucker auszugeben. Hier ist ein Beispiel.
Anders herum ...
Jetzt, wo Sie das Beispielprogramm verstehen, sollten Sie sich diese neue Variante ansehen:
a=open("test.dat","r")
while(!eof(a))
    input #(a) a$ 
    print a$
wend

open() ist eine Funktion, um die erste freie Dateinummer zu ermitteln (vielleicht 1). Diese Dateinummer können Sie mit dem  print-Befehl benutzen.  Aber denken Sie daran, dass Yabasic runde Klammern nach der Raute erwartet (wie in input #(a) a$).

Zurück zum Inhaltsverzeichnis ....


Zusammenarbeit mit dem Betriebssystem

Die system()-Funktion

Obwohl Yabasic überhaupt nicht als Script-Sprache entwickelt wurde, kann es begrenzt mit dem Betriebssystem zusammenarbeiten:

if (peek$("os")="unix") then
       command$="ls"
   else;
       command$="dir /w"
endif
cont$=system$(command$)
print "Dies ist der Inhalt des aktuellen Verzeichnisses:"
print cont$
print len(cont$)," Zeichen wurden ausgegeben."

Die system$()-Funktion ist  das Herz dieses Programms. Es übergibt seine Argumente zur Ausführung an das Steuerprogramm (shell) des zugrundeliegenden Betriebssystems.  Unter Unix ist es die bourne-shell sh und unter Windows ist es die command.com, die die Argumente aus der system()-Funktion ausführen wird.

Wenn ich dieses Programm unter Windows95 ausführe, erhalte  ich folgende Ausgabe:

Dies ist der Inhalt des aktuellen Verzeichnisses:
Datenträger in Laufwerk C: heisst WIN95
Seriennummer des Datenträgers: 0B1D-10F8
Verzeichnis von C:\WINDOWS\Desktop
FLOPPY.LNK    EMACS.LNK   DRUCKER.LNK
T.YAB         TELNET.LNK  TEST.YAB     MICROS~1.LNK  CD.LNK  PLATTE.LNK
WATCOM~1.LNK  [YABDOK~1]  TEST.DAT     WINDOW~1.LNK  [KINO] 
 
12 Datei(en) 2.693 Bytes 4 Verzeichnis(se) 
199.753.728 Bytes frei 
456 Zeichen wurden ausgegeben.

Natürlich werden Sie etwas anderes von Ihrem System erhalten (Besonders falls Sie keine deutsche  Windowsinstallation haben).

Weil dieses Yabasic-Programm sowohl unter Unix wie auch unter Windows arbeiten soll, muss das Argument der system$()-Funktion (command$) passend zum Betriebssystem gewählt werden. Um die Art des Betriebssystems zu ermitteln ("unix", "Linux" oder "windows"), enthältdas Programm das Kommando peek$("os").

Nun gibt es aber noch einen sehr ähnlichen Befehl system() (ohne $),  der die Ausgabe aufgrund eines ausgeführten Kommandos nicht als String übernimmt, sondern stattdessen den vom Kommando veranlassten Text auf dem Bildschirm ausgibt.
system() gibt einen numerischen Wert zurück, der vom ausgeführten Kommando erzeugt wurde.
Wenn Sie diesen Wert nicht benötigen, können Sie ihn einfach außer Acht lassen.
z.B.
system("dir") (ohne Zuordnung) ist genauso gültig wie a=system("dir").

date$ (Datum) und time$ (Zeit)

Um Datum und Zeit aktuell auszugeben können Sie schreiben:

print date$," ",time$

Dies erzeugte folgende Ausgabe (Ihre Ergebnis wird natürlich anders aussehen, weil sich die Zeiten ändern):

5-08-28-1998-Fri-Aug 13-51-53-0

Der date$-String hat sechs Stellen: 5 ist der Wochentag (0-6, 0 ist Sonntag, 6 Samstag), 08 ist der Monat (01-12), 28 ist der Tag desMonats (01-31), 2000 ist das Jahr, Fri ist der Name des Tages und Aug ist der Name des Monats.

Der  time$-String hat vier Stellen: 13 ist die Stunde (00-23), 51 ist die Minute (00-59), 53 ist die Sekunde (00-59) und 0 ist die Zeit, die seit dem Programmstart vergangen ist.

Da die meisten Stellen von date$ und time$  eine feste Länge haben (Mit Ausnahme der letzten Stelle in time$), ist es leicht, die Felder mittels der mid$-Funktion  auszuwerten.

Zurück zum Inhaltsverzeichnis ....


Peek und Poke

peek und poke sind eine Schnittstelle zu einigen  Internas von Yabasic und erlauben den Status von Yabasic's und sein Verhalten abzufragen und zu verändern. Anders als bei früheren Homecomputern, können Sie nicht einfach irgendwo im Arbeitsspeicher herum-peeken und -poken. Nur einige reservierte Variable sind erlaubt. Hier ein Beispiel:

print peek$("infolevel")
poke "infolevel","diagnostic"

Dies wird den aktuellen infolevel ausgeben und ihn dann auf "diagnostic" ändern.

An diesem Beispiel erkennen Sie: peek und poke akzeptieren String-Argumente (einige poke-Kommandos akzeptieren auch eine Ganzzahl als Argument) und peek kann einen String  zurückgeben (in diesem Falle erscheint er als peek$).

Trotzdem gibt es schon jetzt einige peek's und poke's, deshalb sollen sie hier vollständig aufgeführt werden:

peek$("infolevel")
Gibt den aktuellen  infolevel zurück.
poke "infolevel", "error"
Setzt den infolevel auf "debug", "note", "warning", "error" oder "fatal".
peek("fontheight")
Gibt in Pixeln die Schrifthöhe des Grafik-Textes aus.
peek$("os")
Gibt das Betiebssystem aus (operating system ,"windows" oder "unix" oder "Linux")
poke "textalign","cc"
Dieses bestimmt die Textausrichtung, bezogen auf den Punkt, der im text-Befehl angegeben ist.
peek$("textalign")
Gibt einen String aus, der die aktuelle Einstellung der Textausrichtung enthält. Mögliche Werte sind "cb", "rc", "cc", ...
peek("version")
Dies gibt die Yabasic  Version aus (z.B. 2.47).
peek$("library")
Dies gibt die Library aus, die das peek enthält. Wenn vom Yabasic-Programm aufgerufen, wird "main" ausgegeben.
peek("argument")
Gibt die Anzahl der Argumente aus, die dem Yabasic-Programm übergeben wurden. Dies kann nützlich sein, wenn Sie Yabasic nur von der Kommandozeile aus aufgerufen haben. Nehmen wir an, Sie hätten yabasic test.yab 1 2 3 eingegeben. Dies würde den Yabasic-Interpreter starten, um das Programm test.yab ablaufen zu lassen. In test.yab könnten Sie dann  peek("argument") abfragen, um die Anzahl der Argumente zu erhalten, die in der Kommandozeile übergeben wurden. Im Beispiel würde peek("argument") eine 3 ausgeben, weil es drei Argumente ("1", "2" und "3") über die Kommandozeile gab. (Der Programmname "test.yab" zählt nicht als Argument).

    Um die Argumenten-Inhalte wieder zu erhalten, benutzen Sie peek$("argument"). Jeder Aufruf von peek$("argument") verringert den Wert, der von peek("argument") zurückgegeben wird um eins.
     

peek$("argument")
Jeder Aufruf von peek$("argument") gibt eines der Kommandozeilen-Argumente zurück, die dem Yabasic-Program übergeben wurden. Lautete beispielsweise der Aufruf yabasic test.yab 1 2 3, dann würde der erste Aufruf mit peek$("argument") eine "1" zurückgeben, der zweite Aufruf eine "2", der dritte "3" und jeder weitere Aufruf würde einen leeren String ("") zurückgeben.
peek("read_controls")
Gibt 1 zurück, wenn der input Befehl nichtdruckbare Zeichen (wie ctrl-a, ctrl-v oder escape) zurück gibt. Gibt 0 zurück, wenn nichtdruckbare Zeichen einfach verschluckt werden. Der ursprüngliche Wert ist 0 (nichtdruckbare Zeichen werden also ignoriert).
poke "read_controls",x
Je nach dem Wert von x (0 or 1) wird jeder nachfolgende input Befehl nichtdruckbare Zeichen ignorieren (x=0) oder zurückgegeben (x=1).
 

Yabasic bietet begrenzte Unterstützung, um binäre Dateien zu bearbeiten:

    peek(#1)
    Dies gibt das nächste Byte der Datei #1 aus  (#2 ... #9 sind natürlich auch möglich).
    Merke, dass es keine Anführungszeichen rund um #1 gibt.
    poke #1,byte
    Schreibt das angegebene Byte in die Datei #1. byte kann jede Zahl 0...255 sein.
    poke #1,string
    Schreibt den Inhalt von string$ in Datei #1.

Diese peek's und poke's für binäre Dateien sollten nicht mit normalen Datei-I/O-Zugriffen mit print und input gleichgesetzt werden. Sie könnten Probleme mit Yabasic's interner Pufferung bekommen.
Und übrigens ist es ratsam, solche Dateien im
Dateimodus "b" (binär) zu öffnen.

Zurück zum Inhaltsverzeichnis ...


Fortgeschrittenes Drucken:
print at(),
print colour und print using

Für interaktive Programme möchten Sie vielleicht auf bestimmte Stellen drucken. Probieren Sie das nächste Beispiel:

clear screen
print at(10,5) "1 -- Einstellungen"
print at(10,7) "2 -- sichern"
print reverse at(10,9) "3 -- Beenden"
input at(5,12) "Ihre Wahl: " a$

Wenn Sie dieses Programm ablaufen lassen, erhalten Sie einen Bildschirm mit dem folgenden Layout. Beachten Sie, dass die dritte Zeile in umgekehrten Farben erscheint:

1 -- Einstellungen
2 -- sichern
3 -- Beenden         Diese Zeile wird reversiv dargestellt !
Ihre Wahl:

Merken Sie sich, Sie sollten clear screen aufrufen, bevor Sie invers ausgeben.
Danach sollten Sie auch in print oder input-Befehlen die
at()-Klausel benutzen, um zu jeder Position des Bildschirms zu gelangen
anzugeben mit den beiden Argumenten der
at()-Klausel).
at() kann auch als @() geschrieben werden.

Wenn Sie Farbe brauchen, dann können Sie diese Programm testen:

rem Alles vorbereiten
clear screen
dim c$(8)
for a=1 to 8:read c$(a):next a 
rem mehrere Farben ausgeben
for a=1 to 8:for b=1 to 8
   print colour(c$(a),c$(b)) " -- Hallo -- ";
next b:next a
rem Ein Rechteck über den Bildschirm bewegen
a$=getscreen$(1,1,10,10)
for a=1 to 100:putscreen a$ to a,a:next a
rem verfuegbare Farben
data "black","white","red","blue","green","yellow","magenta","cyan"

Dieses Programm gibt "-- Hallo --" mit den acht Farben aus, die Yabsic kennt: black, white, red, blue, green, yellow, magenta und cyan.
Mit der Anweisung 
colour(f$,b$) (oder color(f$,b$)) können Sie die Vorder- und Hintergundfarbe  für die nachfolgende print-Anweisung festlegen.

Der Zweite Teil des Beispielprogramms bewegt ein 10x10-Pixel-Rechteck mit Zeichen über den Bildschirm.
Die
getscreen$(xfrom,yfrom,xto,yto) Funktion wandelt den Inhalt des angegebenen Bildschirm-Rechtecks in eine String,
der in einer String-Variablen (
a$ im Beispiel) abgespeichert werden kann.
Ist einmal ein solches Rechteck erzeugt, kann man es an jedem Ort des Bildschirms mit dem
putscreen Kommando erscheinen lassen.

Weil nicht alle Bildschirme die gleiche Größe haben (natürlich ist 80x25 Zeichen die gebräuchlichste Größe), möchten Sie vielleicht die aktuellen Dimensionen Ihres Bildschirms wissen. Dafür gibt es zwei vordefinierte Variable. Die Breite Ihres Bildschirms kann durch besondere  peek's ausgelesen werden.
peek("screenwidth") holt die Breite des Bildschirms als Zeichenanzahl , währen peek("screenheight") die Höhe zurückgibt.
Beide peeks sind nur unmittelbar nach
clear screen verlässlig.

print using (Zur Formatierung von Zahlen)

Um die Zahlendarstellung zu steuern, benutzt man die print using-Anweisung. print 12.34 using "###.####" erzeugt 12.3400.
Der Formatstring (
"###.####") besteht aus Rauten (#) mit einem beliebig plazierten Punkt und das repräsentiert das Erscheinungsbild der zu druckenden Zahl.
Hier einige Beispiele:

Anweisung

Ausgabe

Bemerkungen

print "=",12.34 using "###.####","="

= 12.3400=

Die Ausgabe wird von links mit Leerzeichen aufgefüllt und mit Nullen von rechts, wie es die Formatvorgabe erfordert.

print "=",12.36 using ##.#,"="

=12.4=

Die letzte Stelle der Ausgabe ist gerundet.

print "=",12.34 using #.#,"="

=***=

Die Zahl kann mit dieser Vorgabe nicht dargestellt werden.

Diese Art der Formatierung ist klar und einfach, aber nicht sehr flexibel.
z.B. ist es nicht möglich, Zahlen linksbündig oder mit führenden Nullen auszugeben.

Um solche Effekte zu erzielen, erlaubt die print using Anweisung den Format-String auch wie in der printf()-Funktion der Programmiersprache C.
Einige Beispiele:

Print-Anweisung

Ausgabe

print "==",str$(12.123455,"%08.3f"),"=="

==0012.123==

print "==",str$(12.123455,"%   8.2f"),"=="

==      12.12==

print "==",str$(12.123455,"%- 6.2f"),"=="

==12.12    ==

  • . = Position des Dezimalpunktes
  • 3 bzw. 2 = Anzahl Stellen rechts des Dezimalpunktes
  • 8 bzw. 6 = insgesamt acht bzw. sechs Zeichen
  • 0 = Mit diesem Zeichen links auffüllen (hier: Nullen)
  • f = Festkomma, die Position entsprechend den Nachkommastellen
  • e oder E = Fließkomma- und Exponentialdartstellung
  • g oder G = Gleitkomma je nach Wert, ggf. exponential
  • - = rechts mit Leerzeichen auffüllen
  • + = immer Vorzeichen (+/-) angeben

Mehr über diese Formate kann in jedem Buch über die Sprache C gefunden werden.

All diese Formate können auch für die str$()-function verwendet werden.

Zurück zum Inhaltsverzeichnis ....


Ende offen

Einige Eigenschaften von Yabasic sind immer noch nicht erklärt. Hier ist ein Beispielprogramm, das sie verwendet:

10 beep
pause 1 
 
 
 
goto 10

Dieses Programm piept jede Sekunde einmal:

  • beep erzeugt das Piepen (kann auch als bell geschrieben werden) und
  • pause erzeugt die Pause (kann auch als wait geschrieben werden),
    sein Argument ist die Verzögerung in Sekunden

Und das Programm benutzt eine Zeilennummer (10) um eine bestimmte Zeile zu kennzeichnen. Diese Eigenschaft macht Yabasic kompatibel zu traditionellem BASIC. Zeilennummern sind spezielle Labels. Sie haben folgende Eigenschaften:

  • Zeilennummern dürfen nur am Anfang von Zeilen stehen.
  • Nicht jede Zeile muss eine Nummer haben und sie müssen nicht fortlaufend sein.
  • Zeilennummern können auch von der restore-Anweisung angesprungen werden.

Tastatur-Interrupts

Eine Eigenschaft, die Sie gebrauchen könnten, ist die Fähigkeit, Tastatur-Interrupts zu unterdrücken (z.B. drücken von Ctrl-C).
Normalerweise würde Yabasic sofort beenden,  wenn der Benutzer
Ctrl-C drückt.
Das kann wie folgt abgefangen werden:

on interrupt continue

Nach Verarbeitung dieser Anweisung werden Tastatur-Interrupts nicht mehr beachtet.
Das alte Verhalten wird wieder hergestellt mit dem Kommando
on interrupt break.

Zurück zum Inhaltsverzeichnis ...


Index- Inhaltsverzeichnis

Index der Yabasic-Schlüsselwörter

+ - * / ^ ?@:#,;

A: abs() acos() and and() arraydim() arraysize() asc() asin() at() atan()
B: beep bell bin$() break
C: chr$() circle clear circle clear rect clear screen clear window close close printer close window colour color compile continue cos() curve
D: date$ data dec() dim doc docu docu$() dot
E: else elsif end endif end sub eof() eor() error euler execute execute$ exit exp() export
F: fi fill for frac()
G: getbit$() getscreen$() glob() gosub goto
H: hex$()
I: ifimport inkey$ input input at input # instr() int() interrupt
J:
K:
L: label left$() len() line line input line to locallog() lower$() ltrim$()
M: map() mapx() mapy() max() mid$() min() mod() mouseb mousex mousey
N: new curve next not numparams
O: on gosub on goto open open printer open window or or() origin
P: pause peek peek$ pi poke print print at print using print # printer putbit putscreen
Q:
R: ran() rectangle read rem redim repeat restore return reverse right$() rinstr() rtrim$()
S: seek() sig() sin() static step split() sqr() sqrt() str$() subsystem() system$()
T: tan() tell text then time$ token() trim$()
U: until upper$() using
V: val()
W: wait wend while window window origin
X: xor()
Y:
Z:

Zurück zum Inhaltsverzeichnis ....


Von Yabasic benutzte Ausdrücke, die nicht als beliebige Variable benutzt werden sollten

argument
arraysize
at
backspace
cc
cb
circle

date$
debug
del
down

end
enter
error
esc

fatal
fontheight
f1...f12
home

infolevel
ins
interrupt
left
library
lower$

main
maxnum
note
new curve
numparams

on
origin
os
pi
printer

rc
rightscreen
screenheight
screenwidth
scrdown
scrup
static

tab
textalign
time$
up
upper$

version
warning
window


Index der Abschnitte

Arrays
Binäre Dateien
Bitmanipulation
Schreibweise von Schlüsselwörtern und Variablen
Kommandozeilen-Agumente
Verzweigungen mit der if-Anweisung
Escape-Folgen in Strings
Zahlen formatieren
Maus einlesen
Globbing
Wie die input-Anweisung eine Zeile aufteilt
Tastatur-Interrupts
Zeilennummern
Viele Kommandos in einer Zeile
Text drucken
Zugriff auf Dateien
In Windows Pfad angeben
Variable

Zurück zum Inhaltsverzeichnis ....


Über Yabasic

Entwicklung

Die Idee Yabasic entstand etwa um Ostern 1995. Eine erste Version wurde etwa einen Monat später vollendet, jedoch fehlten noch viele Fähigkeiten. Nach diesem schnellen Start folgte eine lange Zeit ,in der Fähigkeiten hinzugefügt und Fehler behoben wurden, was mehr oder weniger bis heute so geblieben ist.

Die einzige Unterbrechung während jener friedvollen Tage gab es im Sommer 1996, als ich meinen Windows95-Rechner bekam. Yabasic darauf zu übertragen brauchte zwei Wochen, und  um ein Installationsprogramm zu schreiben brauchte ich einen Monat.

Flex und Bison

Sie haben vielleicht im vorigen Absatz bemerkt, dass Yabasic einen ziemlich schnellen Start hatte. Das beruht hauptsächlich auf Flex und Bison, hervorragende Werkzeuge um Yabasic zu verwirklichen.

Bison und Flex bringen die Grammatik und erzeugen ein C-Programm, das diese Grammatik umsetzt. Das einzige, was dem Programmierer bleibt, ist dieses Skelett  mit Fleisch zu füllen und mit Haut zu bedecken.

Dieses Vorgehen ist bemerkenswert wirkungsvoll: 17 KBytes der Flex- und Bison-Instruktionen generieren 129 KBytes C-Code, was verglichen werden muss mit 108 KBytes C-Code, den ich schrieb. Zusammen sorgen sie für die Funktionalität von Yabasic. Deshalb kann man sagen, der größere Teil des Programmkodes wurde von Flex und Bison generiert!

Ausführen eines Yabasic-Programms

Obwohl Yabasic sich meist verhält wie ein Interpreter, ist er in Wirklichkeit keiner.  Eher ist es ein Compiler.
Wenn Sie ihm irgendein BASIC-Programm zur Ausführung geben, wird das BASIC so kompiliert, dass dies Instruktionen für eine stapelverarbeitende Maschine darstellt.  Und erst diese Instruktionen werden dann von YABASIC interpretiert, und zwar so, dass Sie von der  Stapelverarbeitung nie etwas merken.
Sie können die Zeit, die für diesen Prozess erforderlich ist, anzeigen. Dazu rufen Sie Yabasic mit dem Infolevel
note auf.

Zurück zum Inhaltsverzeichnis ...



 
 

Copyright

Yabasic darf nur kopiert werden unter Anerkennung der Artistic License oder der GNU General Public License (GPL).

Frühere Versions von Yabasic wurden nur mit der GPL versehen und es wurde Rückwärtskompatibilität erhalten.
Seit Version 2.60 haben Sie die Wahl,  Yabasic unter den Bestimmungen der Artistic License zu benutzen, die Sie berechtigt,
Yabasic in mehr oder weniger kundengerechter Art zu  benutzen und zu vetreiben, verbunden mit der Erlaubnis, brauchbare Veränderung zu machen, solange dem Urheber  Einblick in die Fortentwicklung von Yabasic gewährt wird.

Unabhängig davon, welche Lizenz Sie für Yabasic wählen (GPL oder Artistic), gilt dies nicht für Ihre eigenen Yabasic-Programme. Die Programme die Sie schreiben sind Ihre eigene Arbeit und Sie dürfen jede Lizenz Ihrer Wahl benutzen.

Nun einige Beispiele, was unter den Regeln der Artistic License möglich ist:

  • Stellen Sie Yabasic in Ihre eigene Webseite , CD oder ein anderes Medium. Nehmen Sie Geld für ihren Yabasic-Verteil-Service.
  • Schreiben Sie ihre eigenen Yabasic-Programme, übernehmen Sie Yabasic in ein Paket und verkaufen  Sie es.
    "
    Verkaufen" ist mehr als nur Geld für die Verteilungskosten und die Zeit zu nehmen.
    Sie können
    echten Gewinn mit ihren eigenen Programmen machen.
  • Verändern Sie Yabasic, verändern Sie die Leistungsmerkmale und Möglichkeiten, verkaufen Sie die veränderte Version.

Wenn Sie immer noch zweifeln, dann prüfen Sie anhand der obigen Lizenzen.

Zurück zum Inhaltsverzeichnis ...

Übersetzt aus dem Englischen von Peter.Vieweger@visselhoevede.de , Edition 25.04.2000