2.11 Weitere Funktionen


^

2.11.1 Versionsnummern

Da sowohl die R-BASIC IDE als auch ein R-BASIC Programm aus verschiedenen Komponenten bestehen gibt es verschiedene Arten von Versionsnummern.
  • Das BASIC-Programm selbst hat eine Versionsnummer. Sie kann mit dem Befehl Version$ abgefragt werden.

  • Jede GEOS-Datei hat eine Protocol- und eine Release-Nummer. Diese können abgefragt und auch geändert werden.

  • Die Versionsnummer der R-BASIC IDE, mit der ein Programm erstellt wurde kann mit dem BASIC Befehl BasicVersion$ abgefragt werden.

Version$

Jedes Programm und jede Library besitzt eine Versionsnummer, mit deren Hilfe man verschiedene Programmversionen identifizieren kann. Man kann sie über die globale Variable Version$ ermitteln. Rufen Sie Version$ aus einer Library heraus auf so erhalten Sie die Versionsnummer der Library.
Syntax: <stringVar> = Version$
Der Aufbau von Version$ ist folgender:
    Major.Minor.Change
Die beiden ersten Werte (Major und Minor) werden vom Programmierer festgelegt und sind insbesondere bei Libraries von großer Bedeutung (siehe unten). Der dritte Wert (Change) wird bei jedem Compilerlauf automatisch hochgezählt. Änderungen des Major- oder des Minor-Wertes setzen den Change-Wert wieder auf Null.

Verwechseln Sie Version$ nicht mit der Variablen BasicVersion$, welche die Versionsnummer der BASIC-IDE enthält, die das aktuelle Programm compiliert hat.

Die Werte für Major und Minor können im Menüpunkt "Programm" geändert werden. Der Major-Wert sollte geändert (vergrößert) werden, wenn wesentliche neue Funktionen dazugekommen sind, ein neuer Wert für Minor sollte Bugfixes oder kleinere Änderungen anzeigen.

  • Version eines Programms
    Sie sind in der Wahl der Versionsnummer völlig frei.

  • Version einer Library
    Wenn Sie eine BASIC-Library schreiben, die nur für genau ein spezielles BASIC-Programm gedacht ist, spielt die Versionsnummer keine große Rolle. Sie lassen die Versionsnummer bei 0.0, dann gibt es keine Probleme.

    Wenn Sie eine BASIC-Library schreiben, die von verschiedenen Programmen verwendet werden soll, müssen Sie der Versionsnummer eine gewisse Aufmerksamkeit schenken. Beim Compilieren eines Programms, dass ihre Library benutzt, wird die aktuelle Versionsnummer der Library mit abgespeichert, damit das Programm später entscheiden kann, ob es mit der aktuell vorhandenen Library-Version zusammenarbeiten kann oder nicht. Dazu werden der Major und der Minor-Wert herangezogen. Der Change-Wert wird ignoriert.

    Ein Programm, das mit einer Library-Version 2.3 compiliert wurde, arbeitet mit späteren Versionen der Library (z.B. Version 2.5 oder 3.1) zusammen. Es wird aber weder mit der Version 2.1 noch mit der Version 1.9 der Library zusammenarbeiten.

Tipps:

  • Während der Entwicklungsphase einer Library oder eines Programms sollten Sie die Versionsnummer nicht ändern, egal was Sie tun.

  • Häufig ist es so, dass während der Entwicklung der Major-Wert auf Null bleibt. Bei der ersten Veröffentlichung der Library oder des Programms setzt man die Versionsnummer auf 1.0.

  • Jedes Mal wenn eine neue Version einer Library veröffentlicht wird sollten Sie die Versionsnummer ändern.

Release- und Protokollnummer

Auf GEOS Systemebene werden die Protokoll- und Releasenummer verwendet, um zu prüfen, ob Dateien, Libraries und Programme zueinander kompatibel sind.

Eine komplette Beschreibung der Befehle zur Arbeit mit Protocol- und Releasenummern finden Sie im Handbuch "Spezielle Themen", Kapitel 9.2 (Dateiattribute). Die folgende Tabelle enthält einen Überblick.

Tabelle

BasicVersion$

Sie können die Versionsnummer der BASIC-IDE, die das aktuelle Programm compiliert hat, mit der Systemvariablen BasicVersion$ abfragen. Nicht zu verwechseln mit der Variablen Version$, die die Versionsnummer des aktuell ausgeführten Programms enthält.
Syntax: <stringVar> = BasicVersion$
BasicVersion$ liefert eine String der Form:
    Major.Minor.Change-Engeneering
z.B. 1.0.1-17

Dieser Wert ist der gleiche, wie er im Menü "Datei-Information" angezeigt wird, es handelt sich um die Release-Nummer der R-BASIC IDE.

Interne Details

Der folgende Abschnitt enthält Hintergrundinformationen, die zur täglichen Arbeit mit R-BASIC nicht unbedingt benötigt werden.

Die Releasenummer enthält die "Version" eines Programms oder einer Library. Sie wird angezeigt, wenn Sie im GeoManager die Tastenkombination Strg-G eingeben bzw. den Menüpunkt "Datei" -> "Info & Attribute" anklicken.

Die Protokollnummer beschreibt die "Fähigkeiten" eines Programms oder einer Library bzw. die "innere Struktur" einer Datei. Sie wird zur Versionsprüfung auf Systemebene verwendet. Wenn die Protokollnummer nicht passt ist die Datei (Dokument, Library, Programm) nicht kompatibel. Zum Beispiel verwendet die R-BASIC IDE die Protokollnummer um zu entscheiden ob R-BASIC die Datei öffnen und bearbeiten kann.

R-BASIC verwendet die Releasenummer zur Versionsprüfung. Aus Sicht des GEOS-Systems sind sowohl die R-BASIC Codedatei als auch die BIN-Datei Dokumente. Das gilt auch für R-BASIC Libraries. Das GEOS-System ignoriert die Releasenummer von Dokumenten, deshalb kann R-BASIC sie benutzen.

Der R-BASIC Compiler setzt beim Compilieren die ersten drei Felder der Releasenummer der BIN-Datei entsprechend der Versionsnummer des Programms bzw. der Library. Das hat folgende Konsequenzen:

  • Der Wert kann mit dem BASIC Befehl Version$ ausgelesen werden.

  • Uni-Installer ab Version 1.2 verwendet die Releasenummer von R-BASIC Dateien um zu entscheiden ob eine Datei neuer ist als eine andere Datei mit gleichem Namen. Dadurch kann verhindert werden, dass ältere Versionen eines R-BASIC-Programms oder einer R-BASIC Library eine neuere Version überschreiben.

  • Bei R-BASIC Libraries wird die Releasenummer (und damit die Versionsnummer der Library) verwendet um zu entscheiden, ob ein BASIC Programm mit dieser Library zusammenarbeiten kann.
Beim Anlegen eines eigenständigen Programms (R-App) wird die Releasenummer des Launchers auf die Versionsnummer des Programms gesetzt. Dadurch kann der Nutzer die Versionsnummer des Programms im GeoManager mit der Tastenkombination Strg-G erfahren.

^

2.11.2 Arbeit mit Datum und Zeit

R-BASIC unterstützt die Grundfunktionen zum Zugriff auf das Systemdatum sowie elementare Funktionen zur Anzeige von Datum und Uhrzeit. Außerdem wird die Arbeit mit dem Julianischen Datum unterstützt.

Alle Zeitfunktionen, einschließlich der Funktionen zum Zugriff auf das Dateidatum benutzen eine Struktur, die DateAndTime heißt. 

STRUCT DateAndTime
  year, month, day AS INTEGER
  hour, minute, second AS INTEGER
END  STRUCT
year, month, day enthalten das Jahr (z.B. 2014), den Monat (1...12) und den Tag (1 ... 31).

hour, minute, second enthalten die Stunde (0..23), die Minute (0...59) und die Sekunde (0...59).

Zugriff auf Datum und Zeit

SysGetTime

SysGetTime liefert das aktuelle Systemdatum und die Systemzeit.
Syntax: <time> = SysGetTime()

<time>: Variable vom Typ DateAndTime
Beispiel: 
DIM time AS DateAndTime
  time = SysGetTime()
  Print "Das Weltall. Unendliche Weiten. \
  Wir schreiben das Jahr ";time.year

SysGetCount

SysGetCount liefert die Anzahl der "Tics" (1/60 s) seit dem letzten Systemstart.
Syntax: <numVar> = SysGetCount()

<numVar>: numerische Variable



Formatierung von Datum und Zeit

Da man über die DateAndTime-Struktur direkten Zugriff auf das Jahr, den Monat, die Stunde usw. als Zahl hat, ist es nicht kompliziert einen formatierten String zu erzeugen, der Datum oder Zeit enthält. Zum Beispiel erzeugt der Code 
s$ = "Jahr: " + Str$(time.year)
einen String, der das Jahr als Text enthält.

Aber manchmal braucht man einen einfachen Weg Datums- oder Zeitangaben zu formatieren. Die folgenden Routinen erledigen das.

FormatDate$

FormatDate$ gibt das Datum in der Form "24.03.2010" oder in der Form "2010/03/24" aus. Die lokalen Einstellungen des Computers werden dabei nicht berücksichtigt.
Syntax: <stringVar> = FormatDate$(time [, flag ])

time: Variable (oder Funktion) vom Typ DateAndTime.

flag (optional): TRUE: Das Format "2010/03/24" benutzen
FALSE (default): Das Format "24.03.2010" benutzen

Beispiel: 
DIM time AS DateAndTime
  time = SysGetTime()
  Print  "Aktuelles Datum: "; FormatDate$(time)

FormatTime$

FormatTime$ gibt die Uhrzeit im 24-Stunden-Format aus. Die lokalen Einstellungen des Computers werden dabei nicht berücksichtigt.
Syntax: <stringVar> = FormatTime$( time [, flag ])

time: Variable (oder Funktion) vom Typ DateAndTime.

flag (optional): TRUE (default): Sekunden anzeigen (17:34:54)
FALSE: Sekunden nicht anzeigen (17:34)
Beispiel: 
DIM time AS DateAndTime
  time = SysGetTime()
  Print  "Aktuelle Uhrzeit: "; FormatTime$(time)

Weekday$, DayOfWeek

Weekday$ gibt den Wochentag in Textform aus, wobei die lokalen Einstellungen (Sprache) des Computers berücksichtigt werden. DayOfWeek liefert eine Zahl (0..6) die dem Wochentag entspricht. Der Sonntag hat den Wert Null.
Syntax: <stringVar> = Weekday$( time)

Syntax: <numVar> = DayOfWeek( time)

time: Variable (oder Funktion) vom Typ DateAndTime.
Beispiel: 
DIM time  AS  DateAndTime
  time = SysGetTime()
  Print "Heute ist "; Weekday$( time )
  Print "Das ist der"; DayOfWeek( time ) + 1 ; ". Tag der Woche."

LocalFormatDateAndTime$

LocalFormatDateAndTime$ greift auf die Systemeinstellung für die Darstellung von Datum und Zeit zu und formatiert Datums- und Zeitangaben entsprechend diesen Einstellungen. Dadurch erscheinen die Datums- und Zeitangaben in dem vom Nutzer eingestellten Format. Das kann allerdings auf verschiedenen Systemen völlig unterschiedlich sein.
Syntax: <stringVar> = LocalFormatDateAndTime$( time, format )

time: Variable (oder Funktion) vom Typ DateAndTime.

format: Eine DateAndTimeFormat (DTF-) Konstanten aus der aus der Tabelle unten.

Die folgenden Tabelle zeigt das Ausgabeformat von LocalFormatDateAndTime$ für die Standardeinstellungen auf einem deutschen PC/GEOS System. Auf anderen Systemen, insbesondere auf fremdsprachigen Systemen, kann das Ausgabeformat völlig anders aussehen.

Tabelle

Julianisches Datum

Das Julianische Datum ist eine Zahl, die der Anzahl der Tage seit dem 1.1.4713 vor Christus, 12 Uhr mittags entspricht. Man beginnt 12 Uhr mittags damit bei astronomischen Beobachtungen während der Nacht kein Datumswechsel auftritt. Die Nachkommastellen entsprechen der Uhrzeit (bezogen auf 12 Uhr mittags).

Das Julianische Datum ist fortlaufend. Unregelmäßigkeiten wie unterschiedliche Monatslängen, Monats und Jahreswechsel oder auch Schaltjahre werden automatisch berücksichtigt. Damit lassen sich Fragen wie "Wie viele Tage liegen zwischen dem 28.04.2016 und dem 17.07.1962?" einfach durch die Differenz der beiden zugehörigen Julianischen Datumszahlen beantworten. Der Vergleich von zwei Zeitpunkten (einschließlich der Frage, welcher früher liegt) reduziert sich auf den Vergleich von zwei Real-Zahlen.

Für das Julianische Datum wird allgemein die Abkürzung JD verwendet.

JDFromDAT

Die Funktion JDFromDAT ermittelt den julianischen Datumswert (JD) aus einer DateAndTime Struktur (DAT).
Syntax: <numVar> = JDFromDAT ( <dat> )

<numVar>: numerische Variable, empfohlener Datentyp: Real

<dat>: Variable oder Ausdruck vom Datentyp DateAndTime



DATFromJD

Die Funktion DATFromJD rechnet einen julianischen Datumswert (JD) in eine DateAndTime Struktur um.
Syntax: <var> = DATFromJD ( <jd> )

<jd>: numerischer Ausdruck. Julianisches Datum

<var>: Variable vom Datentyp DateAndTime

Das folgende Beispiel gibt aus, welches Datum wir in 100 Tagen, gerechnet ab heute, haben. 
DIM jetzt, dann AS DateAndTime
DIM jd as Real
  jetzt = SysGetTime()
  jd = JDFromDAT(jetzt)
  dann = DATFromJD ( jd + 100)
  Print "In 100 Tagen ist der ";FormatDate$(dann)
Wir wollen wissen in wie vielen Tagen Weihnachten ist. 
DIM zeit as DateAndTime
DIM ist, soll, count as Real
  zeit = SysGetTime()
  ist = JDFromDAT(zeit)    ' aktuelles Julianisches Datum
  zeit.day = 24
  zeit.month = 12
  soll = JDFromDAT(zeit)   ' Julianisches Datum vom Weihnachten
  count = soll - ist
  Print "In";count;"Tagen ist Weihnachten."

JDDeltaFromMinutes

Die Funktion JDDeltaFromMinutes berechnet, wie groß die Differenz zweier Julianischer Daten ist, die sie sich um die gegebene Anzahl von Minuten unterscheiden. Damit kann man Daten und Uhrzeiten ermitteln, die um eine gegebene Zeitdifferenz vor oder nach einem bekannten Zeitpunkt liegen.
Syntax: <numVar> = JDDeltaFromMinutes ( <n> )

<numVar>: numerische Variable, empfohlender Datentyp: Real

<n>: Zeitdifferenz in Minuten. Negative Zahlen und Dezimalzahlen sind zulässig.
Beispiel: 1 min, 30 sek.: time = 1.5
Beispiele:

Wir wollen wissen wie spät es in 73,5 Minuten ist 

DIM zeit as DateAndTime
DIM ist, soll, count as Real
  zeit = SysGetTime()
  ist = JDFromDAT(zeit)       ' aktuelles Julianisches Datum
  soll = ist + JDDeltaFromMinutes(73.5)
  zeit = DATFromJD(soll)      ' DateAndTime-Struktur bilden
  Print "In 73,5 min ist es ";FormatTime$(zeit);" Uhr"
Die folgende Function liefert TRUE, wenn sich zwei Daten um mehr als 1 Stunde unterscheiden. Als Vergleichswert wählen wir 60.001 Minuten (ca. 1/10 Sekunde mehr als 1 h) weil es durch die interne Zahlendarstellung zu minimalen Abweichungen kommen kann. 
FUNCTION CompareTime(dat1, dat2 AS DateAndTime) as Real
DIM jd1, jd2, diff as Real
  jd1 = JDFromDAT(dat1)
  jd2 = JDFromDAT(dat2)
  if ( jd1 > jd2 ) THEN
    diff = jd1 - jd2
  ELSE
    diff = jd2 - jd1         ' diff immer positiv
  END IF
  IF diff > JDDeltaFromMinutes(60.01) THEN RETURN TRUE
  Return FALSE
End Function
Unsere Schicht endet um 16 Uhr 15 Minuten. Wir wollen wissen wie viele Minuten wir noch arbeiten müssen. 
DIM zeit as DateAndTime
DIM ist, soll, count as Real
  zeit = SysGetTime()
  ist = JDFromDAT(zeit)      ' aktuelles Julianisches Datum
  zeit.hour = 20
  zeit.minute = 15
  zeit.second = 0
  soll = JDFromDAT(zeit)     ' Julianisches Datum vom Feierabend
  IF ist > soll THEN
    count = (ist-soll)/JDDeltaFromMinutes(1)
    Print "Du hast schon seit "; count; " Minuten Feierabend!"
  ELSE
    count = (soll-ist)/JDDeltaFromMinutes(1)
    Print "Du musst noch "; count; " Minuten arbeiten."
  END IF

Interne Details

Diese Informationen können hilfreich sein, werden aber zur Arbeit mit dem Julianischen Datum nicht unbedingt benötigt.
  • JDFromDAT und DATFromJD verwenden für Daten nach der Kalenderreform (d.h. ab dem 15.10.1582) den heute gültigen Gregorianischen Kalender. Dieser verwendet die erweiterte Schaltjahresregel, für Daten bis zum 04.10.1582 wird der julianische Kalender verwendet (einfache Schaltjahresregel).

  • Historisch folgte in den damals führenden Ländern auf den 04.10.1582 sofort der 15.10.1582. Die dazwischen liegenden Daten existieren nicht. JDFromDAT und DATFromJD berücksichtigen das. Sie berücksichtigen aber nicht, dass viele Länder die Kalenderreform erst viel später durchführten.

  • Historisch gab es vor Einführung des Julianischen Kalenders im Jahr 46 vor Christus keine Schaltjahre. Bei der Berechnung des Julianischen Datums wird das nicht berücksichtigt.

  • Historisch existiert das Jahr Null nicht. Dem Jahr 1 vor Christus folgte sofort das Jahr 1 der christlichen Zeitrechnung. Bei kalendarischen Berechnungen wird das Jahr 1 vor Christus deshalb als Null gezählt, -1 entspricht dem Jahr 2 vor Christus usw.

  • JDFromDAT ist tolerant gegenüber fehlerhaften Daten. Für den nicht existierenden 29.Februar 1999 wird beispielsweise das Julianische Datum des 1.März 1999 berechnet. Ein beliebiges Datum mit dem "nullten" des Monats (z.B. 0.3.1999) liefert das Julianische Datum des letzten Tags des Vormonats (im Beispiel den 28. Februar 1999).

  • Die Nachkommastellen im Julianischen Datum entsprechen der Uhrzeit, wobei die Formel 
std/24 + min/1440 + sek/86400
    verwendet wird. Std, min und sek entsprechen dabei der Zeit, die seit 12 Uhr mittags vergangen ist. Für 14 Uhr gilt also: std = 2.

    Beispiele:

      17.03.2016, 12 Uhr mittagsJD = 2457465

      17.03.2016, 22 Uhr abendsJD = 2457465.41666667

      18.03.2016, Null Uhr (morgens)JD = 2457465.5

      18.03.2016, 8 Uhr morgensJD = 2457465.83333333

    Im Allgemeinen ist es nicht notwendig die Zahlenwerte zu kennen, wenn man mit dem Julianischen Datum arbeiten will.

  • JDDeltaFromMinutes(x) entspricht entsprechend der obigen Formel dem Term x/1440. JDDeltaFromMinutes(24*60) liefert den Wert 1 ( = 1 Tag).

  • Die Funktionen DayOfWeek() und WeekDay$() verwenden das Julianische Datum. Damit berücksichtigen sie automatisch den Gregorianischen und den Julianischen Kalender.


^

2.11.3 Speicherzugriff

Gelegentlich benötigt man einfach eine bestimmte Menge Speicher, die man nach den eigenen Vorstellungen organisieren kann. R-BASIC ermöglicht zwar keinen direkten Zugriff auf den Hauptspeicher des Computers (das wäre zu unsicher), stellt dem Programmierer aber 64 kByte "geschützten" (virtuellen) Speicher zur Verfügung, der aus Sicht des Programms als 64 kByte fortlaufender Speicher über die Adressen 0 bis 65635 (hexadezimal &h0 bis &hFFFF) angesprochen werden kann. Der Zugriff auf diesen Speicher erfolgt schreibend über diverse Poke- und lesend über die passenden Peek-Befehle (siehe Tabelle).

Tabelle

    <adr> numerischer Ausdruck, der einen Wert von 0 bis 65635 liefert. Liegt der Wert außerhalb dieses Bereichs, wird MOD 65636 gerechnet, d.h. es wird einfach wieder von vorne begonnen.

    <string> Ein Stringausdruck.

    <struktur> Eine Strukturvariable oder eine Funktion, die eine Struktur liefert. Es sind sowohl R-BASIC Strukturen als auch selbst definierte Strukturen zulässig.

    <nVar> numerische Variable.

    <sVar$> String-Variable.

    <stVar> Strukturvariable.

Hinweise:
  • R-BASIC verwaltet den Speicher in Blöcken zu 8 kByte, die erst angefordert werden, wenn sie benötigt werden.

  • Dieser Speicherbereich wird auch an Libraries übergeben, die im PC/GEOS-SDK-Mode geschrieben sind. Außerdem wird er von einigen Objekten (z.B. BitmapContent) benutzt um große Datenmengen zu transferieren.

  • Wollen Sie andere Datentypen (FILE, HANDLE, DWORD etc.) schreiben, müssen Sie sie in einer Struktur kapseln.

  • R-BASIC kontrolliert nicht, ob die gelesenen Daten gültig sind, d.h. zum gelesenen Datentyp passen.


^

2.11.4 DATA-Zeilen

Die DATA-Anweisung dient dazu, feste Werte im Programm abzulegen, auf die zum gegebenen Zeitpunkt - bei Bedarf auch mehrfach - zugegriffen werden kann. Mit Hilfe der READ-Anweisung werden die Werte aus den DATA-Zeilen gelesen. RESTORE wird verwendet, um eine bestimmte DATA-Zeile anzuwählen. Dazu muss mit der Anweisung LABEL eine Codezeile markiert werden, auf die Restore verweisen kann.

DATA-Zeilen sind der klassische Weg um Daten (Zahlen und Strings) in einem BASIC-Programm unterzubringen. Die Verwendung von DATA-Zeilen ist ein veralteter Programmierstil und sie verbrauchen sehr viel Speicher im Programmcode. Für größere Datenmengen können Sie zum Beispiel externe Dateien verwenden, für Bilder können Sie auch die Picture-List (Menüpunkt: Extras) benutzen.

Manchmal, insbesondere wenn Sie nur kleine Datenmengen haben, sind DATA-Zeilen trotzdem sehr nützlich.

Sie können die Anweisungen DATA, READ, und RESTORE auch innerhalb einer Library verwenden. R-BASIC verwaltet die Werte für das Hauptprogramm und jede eingebundene Library getrennt, so dass eine gegenseitige Beeinflussung ausgeschlossen ist. Sie können also auch nicht vom Hauptprogramm aus mit READ auf die DATA-Werte einer Library zugreifen.

DATA

Syntax: DATA Wert [, Wert [, Wert] ...

Wert: jeweils eine Konstante vom Typ REAL oder STRING, Variablen sind nicht zulässig.

Beispiele: 
DATA 12, 144, 13, 169
DATA "Paul", "Müller", "Malocher"

READ

Syntax: READ <var> [, <var>] [, <var>] ...

<var> bezeichnet die zu belegenden Variablen.

Hinweise:
  • Zulässig für <var> sind alle numerischen Datentypen sowie alle String-Typen. Dazu zählen auch Feld- und Struktur-Elemente.

  • Der Typ der Variablen muss kompatibel zum jeweiligen Wert in der DATA-Zeile sein, sonst kommt es zu einem Laufzeitfehler und das Programm wird beendet.
Beispiele:

Der folgende Code liest die Werte aus den DATA-Zeilen aus dem Beispiel zum Befehl DATA (oben). 

READ A, B, C, D
READ Vorname$, Name$, Job$

RESTORE

Syntax: RESTORE

RESTORE <label>

<label> ist ein im Programm definiertes Label.

Hinweise:
  • Wird kein Parameter (<label>) angegeben, so wird die erste DATA-Zeile des Programms angewählt.

  • Existiert das Label nicht, kommt es zu einem Compilerfehler.

  • Weist das Label nicht direkt auf eine DATA-Zeile, so wird die nächste im Programm vorkommende DATA-Zeile angewählt.

  • Weist das Label hinter die letzte DATA-Zeile, so kommt es bei der nächsten READ-Anweisung zu einem Laufzeitfehler
Beispiele: 
DATA 1,2,3,4,5,6,7,8
LABEL Liste1
DATA "a","b","c","d","e","f"
....
RESTORE          ' zur ersten DATA-Zeile
RESTORE Liste1   ' zur DATA-Zeile ab Liste1
Allgemeine Hinweise:
  • Sind mehr Werte in einer DATA-Zeile, als Variablen gelesen werden, so setzt die nächste READ-Anweisung mit dem nächsten Wert in dieser Zeile fort.

  • Sollen mehr Werte gelesen werden, als Werte in einer DATA-Zeile sind, so wird mit der nächsten DATA-Zeile fortgesetzt.

  • Stößt der Interpreter beim Programmablauf auf eine DATA-Zeile, wird diese übersprungen.

  • Versucht das Programm mehr Werte zu lesen, als durch DATA-Zeilen definiert sind, kommt es zu einem Laufzeitfehler und das Programm wird beendet.
Tipps:
  • Verwenden Sie in einer DATA-Zeile nach Möglichkeit nur einen Typ von Werten (z.B. nur Zahlen oder nur Strings)

  • Fassen Sie die DATA-Zeilen zu einem Block im Programm zusammen. Es bietet sich hier das DIM & DATA-Fenster an.
Beispiel: 
LABEL Liste1
DATA 10, 12, 19, 20
DATA 10.8, 7.06, 51.2, 8.13  ' Beachten: Punkt als Dezimaltrennzeichen
RESTORE Liste1               ' DATA-Zeiger setzen
READ a, b, c, d              ' liest die Werte 10, 12, 19, 20
READ e, f, g, h              ' liest die Werte 10.8, 7.06, 51.2, 8.13
....
RESTORE Liste1
READ e, f, g, h              ' liest wieder die Werte 10, 12, 19, 20
Kompatibilität

R-BASIC unterstützt auch die in vielen BASIC-Interpretern verwendete Kombination "RESTORE Zeilennummer". Das kann die Übertragung fremder BASIC-Programme vereinfachen. Die "Zeilennummer" muss dabei explizit angegeben sein (z.B. "1000 DATA ..."). Sie sollten diese Variante in eigenen Programmen nicht verwenden.

LABEL

Die Anweisung LABEL (Marke) vereinbart ein Ansprungziel für GOTO, RESTORE oder GOTO.
Syntax: LABEL <sprungZiel>

<sprungZiel>: Name, unter dem die Stelle erreicht werden kann.

Beispiel: 
GOTO keinFehler   ' verzweigt das Programm nach unten
....              ' hier passiert etwas anderes
LABEL keinFehler
...               ' hier geht es dann weiter
Hinweise:
  • Ein Sprung-Ziel (Label) muss noch nicht definiert sein, bevor es das erste Mal verwendet wird. Eine Verwendung definiert das Label vorläufig. So auch im Beispiel oben.

  • Wird ein Sprung-Ziel verwendet, ohne es später mit LABEL endgültig zu definieren, kommt es zu einem Compilerfehler.

  • Die Verwendung von GOSUB ist veraltet und wird nur noch aus Kompatibilitätsgründen unterstützt. Sie sollten GOSUB in eigenen Programmen nicht verwenden.


^

2.11.5 System Services

Hier finden Sie eine Liste der wichtigsten Systemservices, die von R-BASIC aus benutzt werden können, sowie Informationen, wo sie beschrieben werden. Die meisten dieser Services werden von GEOS-Objekten bereitgestellt.

Tastatur

Die meisten Objekte unterstützen die Tastatur automatisch, ohne weiteres Zutun des Programmierers. Zum direkten Zugriff auf die Tastatur stehen Ihnen folgende Möglichkeiten zur Verfügung:
  • Für einfache Fälle stehen Ihnen die Funktionen InKey$, GetKey, GetKeyLP und GetKeyState zur Verfügung, die im Kapitel 2.7.2 des Programmierhandbuchs beschrieben werden.

  • Sie können einen Tastaturhandler schreiben. Tastaturhandler werden automatisch aufgerufen, wenn der Nutzer eine Taste betätigt. Sie werden im Handbuch "Spezielle Themen", Kapitel 14 (Arbeit mit der Tastatur) beschrieben.

Maus

Die meisten Objekte unterstützen die Maus automatisch, ohne weiteres Zutun des Programmierers. Wenn Sie selbst direkt auf Mausereignisse reagieren wollen müssen Sie einen Maushandler schreiben. Maushandler werden automatisch aufgerufen, wenn der Nutzer die Maus bewegt oder eine der Maustasten betätigt. Sie werden im Handbuch "Spezielle Themen", Kapitel 17 (Arbeit mit der Maus) beschrieben.

Drucken

Um aus einem R-BASIC Programm heraus drucken zu können müssen Sie ein Objekt der Klasse PrintControl einbinden. Dieses Objekt wird im Objekt-Handbuch, Kapitel 4.14, beschrieben. Eventuell benötigen Sie noch ein Objekt der Klasse PageSizeControl. Dieses Objekt wird im Kapitel 4.15 des Objekt-Handbuchs beschrieben.

Clipboard

Über die Zwischenablage (Clipboard) können R-BASIC Programme Daten (z.B. Texte oder Grafiken) mit anderen Programmen austauschen. Die Arbeit mit der Zwischenablage wird im Handbuch "Spezielle Themen", Kapitel 5 (Arbeit mit der Zwischenablage) beschrieben.

Hilfedateien

R-BASIC stellt Ihnen das GEOS-weite Hilfesystem zur Verfügung. Im Kapitel 4 des Handbuchs "Spezielle Themen" (Einbinden von Hilfedateien) ist beschrieben, wie man das Hilfesystem einsetzt.

Timer

Ein Timer stellt eine Routine bereit, die in regelmäßigen Abständen automatisch aufgerufen wird. Timer sind im Kapitel 16 des Handbuchs "Spezielle Themen" (Timer) ist beschrieben.

Dateiarbeit

R-BASIC unterstützt die Arbeit mit DOS- und GEOS-Dateien. Sie können sowohl Binär- als auch Text-Dateien lesen und schreiben. Die Arbeit mit Dateien ist in folgenden Kapiteln des Handbuchs "Spezielle Themen" beschrieben.
  • Kapitel 6: Das Dateisystem

  • Kapitel 7: Arbeit mit Pfaden und Ordnern

  • Kapitel 8: Verwaltung von Dateien

  • Kapitel 9: Arbeit mit Dateien

  • Kapitel 10: Arbeit mit Laufwerken und Datenträgern
Um in den Genuss der Vorteile von GEOS-VM-Dateien zu kommen müssen Sie die Library "VMFiles" einbinden. Diese Library muss separat von der R-BASIC Webseite heruntergeladen werden.

Dokumente

Im Kapitel 15 des Handbuchs "Spezielle Themen" (Implementieren eines Dokument-Interfaces) finden Sie eine ausführliche Anleitung, wie man unter R-BASIC die Funktionen des "Datei" Menüs implementiert. Einen großen Teil der Funktionen übernimmt dabei ein Objekt der Klasse DocumentGuardian. Diese Objekte arbeiten mit der Library "DocumentTools" zusammen und sind im Objekt-Handbuch, Kapitel 4.13, beschrieben.

Automatisches Geometriemanagement

Eine der wesentlichen Eigenschaften des GEOS Systems ist seine Fähigkeit, die Objekte automatisch so anzuordnen, dass sie alle gut sichtbar sind ohne sich zu überlappen. Diese Fähigkeit ist auf elementarer Systemebene implementiert und im Objekt-Handbuch, Kapitel 3.3 (Geometriemanagement) beschrieben.

^

Weiter...