OpenOffice bringt eine eigene Makro-Programmiersprache mit: Mit StarBasic können Sie umständliche manuelle Tätigkeiten automatisieren. Wir stellen Variablen, Kontrollstrukturen und Schleifen vor.

In der vorletzten Ausgabe haben Sie die Grundlagen der Makroprogrammierung mit OpenOffice Calc kennen gelernt. In diesem zweiten Teil der StarBasic-Einführung geht es um fortgeschrittene Themen:

• Variablen haben Sie bereits kurz kennengelernt. Es gibt noch mehr darüber zu wissen, und Sie lernen zusätzlich Variablenfelder kennen.
• Mit der Kontrollstruktur If ... Then ... Else können Sie Fallunterscheidungen in Ihre Makros einbauen. Abhängig davon, ob bestimmte Bedingungen erfüllt sind, führt Ihr Makro dann unterschiedliche Befehle aus.
• Schleifen helfen dabei, gleiche oder ähnliche Befehle mehrfach auszuführen – ohne, dass Sie diese auch mehrfach hinschreiben müssen.

Damit können Sie bereits mächtige Makros erstellen.

Arbeiten mit Variablen

In größeren Makroprojekten ist es hilfreich, Variablen nicht einfach bei Bedarf zu verwenden, sondern diese vorab im Makro-Programmtext zu “deklarieren”: Variablen können verschiedene Typen annehmen – eine Zahl ist etwas anderes als ein Text-String.

Über das Schlüsselwort Dim definieren Sie den Typ einer Variable. Wollen Sie etwa eine Zählvariable i verwenden, die nur ganzzahlige Werte annimmt, setzen Sie den Befehl

Dim i As Integer

an den Anfang des Makros (gleich hinter die erste Zeile, in der Sub Makroname() steht). Damit ist klar, dass i nur Werte vom Typ Integer annimmt, in OpenOffice sind das ganze Zahlen zwischen -32768 und 32767 (-2^15 bis 2^15 – 1). Jeden Versuch, i nun etwas anderes als einen Integer-Wert zuzuordnen, wird OpenOffice künftig mit einer Fehlermeldung quittieren.

Weitere wichtige Variablentypen sind:

• String: nimmt Textketten (engl. Strings), wie z. B. "test", auf.
• Single, Double: nehmen Zahlen mit Nachkommastellen, wie z. B. 3,1415, auf. Achtung: Auch wenn die deutschsprachige OpenOffice-Version Zahlen in Calc das hier übliche Dezimalkomma verwendet, müssen Sie in Makros Zahlen mit Dezimalpunkt schreiben, also 3.1415 statt 3,1415. Der Datentyp Double hat im Vergleich zu Single eine höhere Genauigkeit; vereinfacht gesagt speichern Variablen vom Typ Double mehr Nachkommastellen als ihre Schwestern vom Typ Single.
• LongInt: speichert (wie Integer-Variablen) ganze Zahlen, aber mit deutlich größerem Wertebereich: Die Zahlen dürfen dem Betrag nach bis über 2,1 Milliarden groß werden (-2.147.483.648 bis 2.147.483.647, oder – um das Prinzip zu erkennen: -2^31 bis 2^31 – 1).
• Boolean: können Wahrheitswerte (True, False) enthalten – die können Sie später direkt überall dort einsetzen, wo sonst ein logischer Ausdruck (wie etwa ein Test auf Gleichheit) hingehört, z. B. in eine If-Then-Else-Konstruktion.

Wenn Sie sich beim Programmieren selbst disziplinieren wollen, fügen Sie ganz am Anfang im Makro-Editor (noch vor der ersten Makrodefinition) die Zeile

Option Explicit

ein: Die zwingt Sie dann, alle verwendeten Variablen ordentlich zu deklarieren – vergessen Sie eine Dim-Anweisung, kommt es zu einem Laufzeitfehler, wenn Sie das Makro ausführen.

Variablenfelder

Häufig benötigen Sie gleich mehrere Variablen, die gleichartige Daten enthalten und in einer bestimmten Reihenfolge genutzt werden. Wollen Sie etwa die Zellen A1 bis A8 auslesen und in Variablen speichern, könnten Sie dafür acht Variablen Wert1 bis Wert8 definieren und für diesen Zweck nutzen. Das ist aber umständlich: Besser ist es, ein so genanntes Variablenfeld zu definieren, das mehrere Werte speichert und diese über einen gemeinsamen Feldnamen zugänglich macht. Das würde dann so gehen:

Dim Werte(8) As Integer

Damit legen Sie eine ganze Sammlung von Variablen an, die Sie über Werte(0), Werte(1) bis Werte(8) ansprechen können. Die so genannte Feldgröße ist hier also 9 und nicht 8, weil StarBasic bei 0 zu zählen beginnt und der Dim-Befehl den letzten gültigen Index angibt. Wollen Sie nur acht Variablen im Feld verwalten und diese Werte(1) bis Werte(8) nennen, können Sie die Feldgrenzen auch explizit angeben:

Dim Werte(1 To 8) As Integer

Vor und hinter dem Schlüsselwort To stehen in dieser Befehlsvariante der jeweils erste und letzte gültige Index.

Elegant an den Variablenfeldern ist, dass Sie ohne großen Aufwand deren Größe ändern können. Haben Sie in der Vergangenheit ein Makro geschrieben, dass acht Werte in der oben beschriebenen Weise speichert, und benötigen Sie nun stattdessen 20 Werte, ändern Sie einfach den Dimensionierungsbefehl von Dim Werte(8) As Integer in Dim Werte(20) As Integer, und schon stehen Ihnen entsprechend mehr Speicherbereiche zur Verfügung.

Die Änderung ist allerdings nicht im laufenden Programm möglich – der folgende Code wird nicht funktionieren:

Dim v(10) As Integer
v(5) = 100
Dim v(30) As Integer
v(15) = 115

Das zweite Dim-Kommando würde eine Fehlermeldung verursachen (Abbildung 1). Es gibt ein Kommando namens ReDim, das eine Neudimensionierung (“Re-Dimensionierung”) eines Felds erlaubt. Um ein bereits vorhandenes Feld wie oben nachträglich ohne Datenverlust zu vergrößern, müssten Sie beim zweiten Aufruf ReDim Preserve v(20) As Integer schreiben – die Korrektur des obigen Listings ist also:

Dim v(10) As Integer
v(5) = 100
ReDim Preserve v(20) As Integer
v(15) = 115

Abbildung 1: Felder doppelt mit “Dim” zu definieren, ist verboten – verwenden Sie stattdessen “ReDim”.

Für das schnelle und automatische Verarbeiten solcher Variablenfelder eignet sich besonders eine Schleifenkonstruktion, die Sie weiter unten im Abschnitt For-Schleifen kennenlernen.

Felder dürfen auch mehrdimensional sein: Während Sie sich ein einfaches Variablenfeld als Teil einer Tabellenspalte oder -zeile vorstellen können, entspricht ein zweidimensionales Feld einem rechteckigen Ausschnitt aus der Tabelle.

Konvertieren zwischen Text und Zahl

Die Zahl 123 und der String "123" haben zunächst nichts miteinander zu tun: OpenOffice verarbeitet die Integer-Zahl intern ganz anders als den String (der aus den drei ASCII-Werten für die Zeichen "1", "2" und "3" besteht). Wenn Sie eine Zahl als String eingelesen haben, müssen Sie diesen zunächst in eine richtige Zahl umwandeln, bevor Sie z. B. damit rechnen können. Genauso ist oft eine Umwandlung von Zahlen in Strings notwendig, etwa wenn Sie aus der Single-Variable Kontostand eine Ausgabe der Form “Ihr Kontostand beträgt 123,45 Euro” erzeugen wollen.

Für Typumwandlungen stellt OpenOffice Basic einige Funktionen zur Verfügung, deren Namen mit einem “C” (für: convert to, konvertiere in) beginnen – die wichtigsten stellen wir Ihnen im Folgenden vor:

• CStr() wandelt eine Zahl in einen String um, so ergibt z. B. CStr(13.4) den String “13,4”.
• CInt() wandelt einen String in eine Integer-Variable um. Eventuell vorhandene Nachkommastellen verwirft die Funktion: CInt("13,4") ergibt den Integer-Wert 13.
• CSng(), CDbl() wandeln einen String in eine Zahl mit Nachkommastellen um; je nach Funktion entweder vom Typ Single oder Double. Abbildung 2 zeigt, dass eine mit CSng umgewandelte Funktion deutlich weniger Nachkommastellen als eine Zahl vom Typ Double hat.

Abbildung 2: Single-Variablen haben weniger Nachkommastellen als Double-Variablen.

Beachten Sie, dass die Konvertierungsfunktionen nationale Zahlendarstellungen beachten: Auf einem deutschsprachigen OpenOffice funktioniert darum die Umwandlung des Strings “1,23” in die Zahl 1,23 – mit englischen Spracheinstellungen hingegen nicht.

Strings in Zahlen müssen Sie immer dann konvertieren, wenn Sie mit Hilfe von InputBox eine Zahl einlesen wollen:

Dim Zahl As Integer
Zahl = InputBox ("Geben Sie eine Zahl ein.")

wird nicht funktionieren, richtig lautet die zweite Befehlszeile:

Zahl = CInt ( InputBox ("Geben Sie eine Zahl ein.") )

Kontrolle

Schon im ersten Teil des Workshops haben Sie die If-Abfrage kennen gelernt, mit der Sie den Ablauf des Makroprogramms steuern können. So können Sie mit ihr beispielsweise den Inhalt einer Zelle überprüfen und diesen durch das Wort “ungültig” ersetzen, wenn der vorgefundene Wert außerhalb eines von Ihnen definierten Bereichs liegt:

Wert = Blatt.getCellByPosition(0,0).Value
If Wert < 0 Or Wert > 100 Then Blatt.getCellByPosition(0,0).String = "ungültig"

Hinter dem Schlüsselwort If (falls, wenn) steht eine logische Bedingung, im Beispiel Wert < 0 Or Wert > 100 – diese ist gleich aus zwei Bedingungen zusammengesetzt, die mit Or (oder), einer logischen Oder-Operation verknüpft sind. Diese Bedingung ist wahr, wenn die Variable Wert kleiner als 0 oder größer als 100 ist. (Sie wäre auch dann wahr, wenn beide Teilbedingungen gleichzeitig erfüllt sind, was in diesem Beispiel nicht möglich ist.)

Nach der Bedingung folgt das Schlüsselwort Then (dann) und dahinter ein Befehl, den OpenOffice nur dann ausführt, wenn die vorher getestete Bedingung wahr ist.

Neben der hier gezeigten Kurzform, die alle Teile in einer einzigen Programmzeile enthält, gibt es noch eine Langform, die oft übersichtlicher ist. Sie sieht folgendermaßen aus:

If Bedingung ThenAnweisungen
ElseAnweisungen
End If

Ein Beispiel dafür zeigt der folgende Ausschnitt eines Makros, das zwei Variablen entweder addiert oder subtrahiert:

If RechenOp = "+" Then
  Ergebnis = x + y
  MsgBox ("Summe ist " & Ergebnis)
Else
  Ergebnis = x - y
  MsgBox ("Differenz ist " & Ergebnis)
End If

Hier ist RechenOp eine String-Variable, und wenn sie nur ein Pluszeichen enthält, berechnet OpenOffice die Summe; bei allen anderen Inhalten die Differenz.

Falls es mehr als zwei Möglichkeiten gibt, können Sie die Fallunterscheidung mit dem Schlüsselwort ElseIf auch noch komplexer gestalten:

If Bedingung 1 ThenAnweisungen 1
ElseIf Bedingung 2 ThenAnweisungen 2
ElseIf Bedingung 3 ThenAnweisungen 3
…
ElseAnweisungen 2
End If

Mit Befehlen dieser Art fangen Sie zunächst verschiedene Fälle ab und lassen das Makro entsprechende Anweisungen ausführen – trifft keiner der über Bedingungen beschriebenen Fälle zu, führt OpenOffice die im Else-Fall definierten Befehle aus.

Listing 1 zeigt ein Beispiel eines Miniatur-Taschenrechners, der zunächst nach einer Rechenoperation und zwei Zahlen fragt und dann Summe (+), Produkt (*), Quotient (/) oder Differenz (-) berechnet – wenn Sie keines dieser vier Symbole eingegeben haben, erscheint stattdessen eine Fehlermeldung (Unbekannte Rechenoperation). Aus dem Aufbau können Sie leicht erkennen, wie Sie von Hand eine fünfte Operation einbauen.

Sub Rechenoperationen()
  Dim Op As String
  Dim x, y, Ergebnis As Integer
  Op = InputBox ("Geben Sie die Rechenoperation ein (+,*,-,/).")
  x = CInt ( InputBox ("Geben Sie die erste Zahl ein.") )
  y = CInt ( InputBox ("Geben Sie die zweite Zahl ein.") )
  If Op = "+" Then
    Ergebnis = x + y
    MsgBox ("Summe: " & Ergebnis)
  ElseIf Op = "-" Then
    Ergebnis = x - y
    MsgBox ("Differenz: " & Ergebnis)
  ElseIf Op = "*" Then
    Ergebnis = x * y
    MsgBox ("Produkt: " & Ergebnis)
  ElseIf Op = "/" Then
    Ergebnis = x / y
    MsgBox ("Quotient: " & Ergebnis)
  Else
    MsgBox ("Unbekannte Rechenoperation " & Op)
  End If
End Sub

Logische Verknüpfungen

Die Or-Verknüpfung (Oder) haben Sie bereits weiter oben gesehen. Neben dem logischen Oder gibt es auch noch das logische Und (And) sowie die Negation (Not). Damit können Sie komplexe logische Ausdrücke aufbauen, wie etwa

( Not ( a < 0 And b > 0 ) ) Or b < 0

Klammern helfen dabei, die Reihenfolge festzulegen, in der StarBasic diese Bedingungen auswertet und miteinander verknüpft. Bei einfacheren Vergleichen ist das Schlüsselwort Not aber oft überflüssig:

• Statt Not a < b können Sie a >= b schreiben,
• und statt Not a = b auch a <> b.

Wiederholung

Oft ist es im Rahmen eines StarBasic-Programms nötig, ähnliche (oder gleiche) Schritte mehrfach durchzuführen. Betrachten Sie etwa die Aufgabe, die ersten zehn Zellen in Spalte A mit dem Wert leer zu füllen – einen möglichen Weg, das zu tun, zeigt Listing 2. Dieses Makro können Sie aus dem aktuellen Tabellendokument heraus ausführen, und es erledigt dann die angedachte Aufgabe. Besonders elegant ist das Ganze aber nicht, und wenn Sie statt der ersten Spalte die zweite ausfüllen oder gleich mit 20 statt zehn Feldern arbeiten möchten, sind aufwendige Anpassungen am Skript nötig.

Sub Einfuegen()
  Blatt = ThisComponent.Sheets(0)
  Blatt.getCellByPosition(0,0).String = "leer"
  Blatt.getCellByPosition(0,1).String = "leer"
  Blatt.getCellByPosition(0,2).String = "leer"
  Blatt.getCellByPosition(0,3).String = "leer"
  Blatt.getCellByPosition(0,4).String = "leer"
  Blatt.getCellByPosition(0,5).String = "leer"
  Blatt.getCellByPosition(0,6).String = "leer"
  Blatt.getCellByPosition(0,7).String = "leer"
  Blatt.getCellByPosition(0,8).String = "leer"
  Blatt.getCellByPosition(0,9).String = "leer"
End Sub

Wenn Sie das Listing betrachten, sehen Sie, dass die zehn Einfügebefehle einander sehr ähnlich sind; sie haben alle die Form Blatt.getCellByPosition(0,X).String = "leer", wobei X nacheinander die Werte 0 bis 9 annimmt. So etwas lässt sich leicht zusammenfassen, und zwar mit einer For-Schleife.

Klassiker: For-Schleife

Die einfachste Methode, mit der Sie eine Anweisung mehrfach ausführen können, ist er Einsatz einer For-Schleife: Die verwendet eine Zählvariable, für die Sie einen Anfangs- und einen Endwert vorgeben; OpenOffice erhöht dann schrittweise den Zähler, bis die Variable alle Werte zwischen Start- und Endwert angenommen hat, und in jedem Durchgang führt der Basic-Interpreter die “im Inneren” der For-Schleife stehenden Befehle aus. Ein Beispiel macht das schnell klarer:

For i = 5 To 10
  Print i,
Next i

Der Befehl Print öffnet ein Hinweisfenster und gibt darin das Argument des Befehls aus; das zusätzliche Komma am Ende sorgt dafür, dass OpenOffice auf weitere Ausgaben wartet und diese gesammelt im Hinweisfenster anzeigt. Der Beispielcode gibt

5  6  7  8  9  10

aus. Die For-Schleife setzt also die Variable i zunächst auf den (Start-)Wert 5 und führt dann den Print-Befehl aus; dann erhöht sie i auf 6 und gibt erneut den (neuen) Wert aus. So geht es weiter, bis in einem letzten Durchgang i den Wert 10 hat.

Die Aufgabe, zehn Felder mit dem Wort leer zu füllen, können Sie mit der For-Schleife nun vereinfacht in der folgenden Form lösen:

Sub Einfuegen()
  Blatt = ThisComponent.Sheets(0)
  For n = 0 To 9
    Blatt.getCellByPosition(0,n).String = "leer"
  Next n
End Sub

Ein kleines Programm, das eine Schleife mit vorab unbekannter Anzahl an Durchläufen ausführt, finden Sie in Listing 3: Es hat die Aufgabe, beliebig viele Zahlen zu addieren, und fragt zunächst nach der Anzahl dieser Zahlen. Dann dimensioniert es das Feld Werte in ausreichender Größe, um all diese Zahlen einzulesen, fragt sie ab und bildet schließlich die Summe. Beachten Sie, dass dieses Programm ein Dim-Kommando ausführt, in dem die Feldgröße selbst eine Variable ist: So kann das Makro das Feld dynamisch in genau der benötigten Größe erzeugen.

Sub Main
  ' Feldgröße abfragen, Umwandlung in Integer erzwingen
  Num = CInt ( InputBox ("Wie viele Zahlen?") )
  ' Feld "Werte" in richtiger Größe dimensionieren
  Dim Werte(Num) As Integer
  ' Werte einlesen
  For i = 1 To Num
    Werte(i) = InputBox ("Geben Sie den " & i & "-ten Wert ein")
  Next i
  ' Summe aller Werte berechnen
  Ergebnis = 0
  For i = 1 To Num
    Ergebnis = Ergebnis + Werte(i)
  Next i
  ' und ausgeben
  MsgBox ("Die Summe der Werte ist: " & Ergebnis)
End Sub

Andere Schleifen

Neben der For-Schleife, die mit einer Zählvariable eine festgelegte Anzahl von Wiederholungen erlaubt, gibt es auch Schleifen mit “offenem Ende”: Sie zählen nicht, sondern wiederholen bestimmte Befehle solange, bis eine so genannte Abbruchbedingung erfüllt ist. Diese Schleifen treten in zwei Varianten, als While- und Until-Schleifen auf.

Die While-Schleife prüft vor dem ersten Schleifendurchlauf eine Bedingung. Wenn diese nicht erfüllt ist, bricht die Schleife sofort ab – ohne die enthaltenen Befehle ein einziges Mal auszuführen. Ist die Bedingung erfüllt, laufen die im Inneren stehenden Befehle, und danach wird die Bedingung erneut geprüft. Damit so keine Endlosschleife entsteht, muss sich also im Inneren irgendetwas verändern, das Einfluss auf die Abbruchbedingung hat. Betrachten Sie folgendes Beispiel:

Sub WhileBeispiel()
  Dim n As Integer
  n = 2
  While n < 1000
    Print n,
    n = n * 2
  Wend
End Sub

Dieses Beispielprogramm berechnet alle Zweierpotenzen, die kleiner als 1000 sind (Abbildung 3), indem es mit einem Startwert n = 2 beginnt und diesen solange immer wieder verdoppelt, wie das Ergebnis noch klein genug ist.

Abbildung 3: Diese einfache While-Schleife gibt alle Zweierpotenzen (2, 4, 8, 16, 32, …) aus, die kleiner als 1000 sind.

While-Schleifen haben immer den syntaktischen Aufbau

While BedingungAnweisungen
Wend

Das Wort “Wend” steht dabei für “While End” (Ende der While-Schleife).

Dasselbe leistet die folgende Until-Schleife, die aber die Abbruchbedingung immer erst nach einem Schleifendurchlauf prüft – die im Inneren stehenden Befehle also mindestens einmal ausführt:

Sub UntilBeispiel()
  Dim n As Integer
  n = 2
  Do
    Print n,
    n = n * 2
  Loop Until n > 1000
End Sub

Die Syntax sieht ein wenig anders als bei der While-Schleife aus – nach dem einleitenden Schlüsselwort Do (etwa: “Tu das Folgende!”) kommen direkt die Befehle, die StarBasic mit jedem Durchlauf ausführen soll; am Ende steht dann Loop Until Bedingung (“Lauf durch die Schleife, bis diese Bedingung erfüllt ist”).

While– und Until-Schleifen sind flexibler als die For-Schleifen. Sie können hier verschiedene Variablen auswerten und so individuelle Abbruchbedingungen zusammenstellen. Bei Bedarf können Sie auch nach jedem Durchlauf über eine InputBox nachfragen, ob StarBasic weiter durch die Schleife laufen soll, etwa wie in Listing 4.

Sub Quadrieren()
  Dim i As Integer
  Dim s As String
  Do
    i = CInt(InputBox ("Geben Sie eine Zahl ein."))
    MsgBox i & " zum Quadrat ist " & i * i
    s = InputBox ("Noch mal? Ja / Nein")
  Loop Until s = "Nein"
End Sub

Funktionen und Sub-Makros

Wie in anderen Programmiersprachen, können Sie auch in StarBasic eigene Funktionen definieren, die Sie genau wie die eingebauten Funktionen (z. B. die trigonometrischen Funktionen cos() und sin()) verwenden können. Als erstes Beispiel betrachten Sie die in den folgenden Zeilen definierte Funktion PlusEins(), die einen Integer-Wert als Argument erwartet und diesen, um 1 erhöht, zurück gibt:

Function PlusEins (n As Integer) As Integer
  PlusEins = n+1
End Function

An diesem Beispiel sehen Sie, wie in StarBasic die Definition eines Funktionsarguments und die Rückgabe des Ergebniswerts funktionieren: Das Argument gehört in Klammern hinter den Funktionsnamen, und wenn der Typ des Arguments bekannt ist, können Sie ihn ähnlich wie bei einer Variablendeklaration mit Dim angeben (n As Integer). Den Typ des Rückgabewerts setzen Sie ans Ende der mit Function eingeleiteten Funktionsdefinition (As Integer).

Ausprobieren können Sie Ihre neue Funktion aus einem Makro heraus:

Sub TestPlusEins()
  Dim i As Integer
  i = InputBox ("Geben Sie eine Integer-Zahl ein.")
  MsgBox "Ergebnis: " & PlusEins(i)
End Sub

Sie können auch Funktionen mit mehreren Argumenten schreiben, eine einfache Additionsfunktion für Variablen mit Nachkommastellen (vom Typ Single) sieht etwa wie folgt aus:

Function Addiere(x As Integer, y As Integer)
  Addiere = x+y
End Function

Um aus einem Makro heraus die Summe von a und b zu berechnen, könnten Sie dann den Funktionsaufruf Addiere(a,b) einsetzen.

Neben der Möglichkeit, Funktionen zu definieren, können Sie auch weitere Makros schreiben, die Sie nicht direkt aus OpenOffice, sondern aus einem anderen Makro heraus aufrufen. Ein nützliches Beispiel von Makros und Funktionen finden Sie in Listing 5: Es enthält eine Funktion Get(), die den Wert aus einer Zelle im Tabellendokument liest, und ein Makro Put, das den umgekehrten Wert geht, also einen Wert in eine Zelle schreibt.

Function Get (x As Integer, y As Integer)
  Blatt = ThisComponent.Sheets(0)
  Get = Blatt.getCellByPosition(x,y).Value
End Function
Sub Put (x As Integer, y As Integer, v As Variant)
  Blatt = ThisComponent.Sheets(0)
  Blatt.getCellByPosition(x,y).Value = v
End Sub

Um mit diesem Code nun die Zelle B5 auszulesen und abhängig von ihrem Inhalt einen daraus berechneten Wert in die Nachbarzelle C5 zurück zu schreiben, könnten Sie folgenden Code verwenden:

Sub TestMakro()
  Dim Inhalt,Berechnet As Integer
  ' Koordinaten von B5: (1,4)
  Inhalt = Get(1,4)
  If Inhalt >= 100 Then
    Berechnet = Inhalt-100
  Else
    Berechnet = Inhalt
  End If
  ' Koordinaten von C5: (2,4)
  Put(2,4, Berechnet)
End Sub

Dieser Code schreibt den in B5 vorgefundenen Wert unverändert in Zelle C5, wenn er kleiner als 100 war – andernfalls zieht das Makro 100 vom Wert ab. Makros dieser Art können Sie verwenden, um etwa in Tabellen Gültigkeitsprüfungen durchzuführen – so könnten Sie in einer Spalte eine Reihe von Werten erfassen und dann ein Makro prüfen lassen, ob alle eingegebenen Werte innerhalb eines gültigen Bereichs liegen; für alle (vermuteten) Fehleingaben landet dann ein Warnhinweis in der benachbarten Spalte.

Mit Get und Put aus Listing 5 erhalten Sie auch ein wenig von dem Komfort zurück, den Microsofts VBA im Vergleich zu StarBasic bietet, was den Zugriff auf Tabellen angeht: Dort lässt sich die Zelle B5 einfach über Cells(4,1) sowohl auslesen als auch mit neuem Inhalt füllen. Beachten Sie hier, dass Get und Put nur mit Zahlenwerten umgehen können; um einen String auszulesen oder zu schreiben, müssten Sie auf ähnliche Weise z. B. GetString und PutString programmieren, dann aber in den Definitionen Blatt.getCellByPosition(x,y).Value durch Blatt.getCellByPosition(x,y).String ersetzen.

Zeilen und Spalten vertauschen

Zum Abschluss noch ein kleines Anwendungsbeispiel, das die hier selbst definierten Funktionen/Makros Get und Put sowie ein zweidimensionales Variablenfeld verwendet, um in einer Tabelle Spalten und Zeilen zu vertauschen. Das Makro Transponieren aus Listing 6 erwartet fünf Zeilen und fünf Spalten in der Tabelle, also einen quadratischen Bereich. Damit das Makro auch Bereiche mit unterschiedlicher Zeilen-/Spaltenzahl bearbeiten kann, ist etwas Zusatzarbeit nötig. Noch besser wäre es, wenn das Makro einen markierten Bereich (und nicht einfach die ersten fünf Zeilen und Spalten) transponieren könnte – dazu mehr im nächsten Teil der StarBasic-Reihe.

Sub Transponieren()
  Dim i,j As Integer
  Dim Werte (2,4) As Single
  ' Werte auslesen
  For i = 0 To 2
    For j = 0 To 4
      Werte(i,j) = Get(i,j)
    Next j
  Next i
  ' … und zurückschreiben
  For i = 0 To 2
    For j = 0 To 4
      Put(j,i, Werte(i,j))
    Next j
  Next i
End Sub

Sub PrintLog (LogFileName As String, LogMessage As String)
  dim fn as integer
  fn = freefile
  open LogFileName for append as #fn
  print #fn, LogMessage
  close #fn
End Sub

Sub DebugPrint (DebugMessage As String)
  PrintLog "/tmp/ooomakros.log", DebugMessage
End Sub

DebugPrint "Hier ist ein Fehler"

touch /tmp/ooomakros.log; tail -f /tmp/ooomakros.log