Mittlerweile sind wir in der Lage, mittels Zusammenfügen einiger Bausteine, die wir gelernt haben, doch einiges zu bewerkstelligen. In diesem Kapitel wollen wir das anhand ein paar Systemsteuerungsaufgaben für Windows XP (!) mal ankosten. Die Bausteine, die wir benutzen werden, sind:

• Eine Skriptprogrammiersprache, nämlich BASIC
• Unsere Konsolenkenntnisse von DOS, die wir auf die XP-Konsole anwenden werden.
• Unsere neuen Kenntnisse bezüglich Lesen und Schreiben von Textdateien
• Die Möglichkeit, von QBASIC aus Shellkommandos abzusetzen, nämlich der Befehl SHELL von QBASIC

Von diesen vier Bausteinen fehlt uns nur noch der letzte:

Der SHELL-Befehl

Dieser ist ganz einfach. Mittels SHELL "Befehl" können Sie ein beliebiges DOS-Kommando abschicken. Also z.B. SHELL "copy A:\*.* C:\temp" würde aus QBASIC heraus alle Dateien des Diskettenlaufwerks nach C:\temp kopieren. Sogar das Ausführen von Batch-Dateien klappt so: QBASIC "back.bat" führt das Batchskript back.bat aus. Und jetzt machen Sie mal was ganz Lustiges: Starten Sie mal folgendes Programm:

SHELL "qbasic"

Was passiert? Scheinbar nichts. Ausser, dass der Eingangsbildschirm, bei dem man die ESC-Taste drücken muss, wieder erscheint. Und dann das Programm verschwunden ist. Das ist auch kein Wunder - wir haben aus dem alten QBASIC heraus ein neues QBASIC gestartet! Beenden wir es über Datei->Beenden, dann kommt zuerst der DOS- Bildschirm wieder mit der Aufforderung, eine Taste zu drücken. Und dann kommt wieder unser alter QBASIC-Schirm mit Programm.

Aufgabe 1: Windowsverzeichnis ermitteln

Nehmen wir an, wir wollen ein Programm schreiben, das ein anderes Programm so installiert, dass es als DOS-Befehl aus jedem Verzeichnis aufgerufen werden kann. Das zu installierende Programm liege als Binary vor, also als Befehl der Form "myprog.exe".

In jedem Windowssystem gibt es ein Verzeichnis, das von vornherein im Pfad der Kommandozeile steht und somit nach Befehlen durchsucht wird, wenn man auf der Kommandozeile einen Namen eingibt: Das Windowsverzeichnis selbst. Nichts einfacher also, als unser myprog.exe ins Windowsverzeichnis zu kopieren (wenn das auch nicht feine englische Art eines Installationsprogramms ist - aber es funktioniert.)

Unser Installationsprogramm soll auf jeder Windowsversion bis zur neuesten laufen. Nun sind die Windowsverzeichnisse aber alles andere als einheitlich. Schon deshalb, weil das Systemlaufwerk nicht immer C: sein muss. Was tun? Wie finden wir heraus, wo das Windows-Verzeichnis ist? Das klingt jetzt schon ganz schön kompliziert.

Ist aber nicht so schwer. Als erstes müssen wir wissen, dass es ein Windows/DOS-Kommando namens SET gibt. Öffnen Sie mal eine Konsole und geben Sie SET+enter ein. Wenn ich das hier auf meiner Maschine eingebe, dann kommt folgendes:

COMSPEC=C:\WINNT\SYSTEM32\COMMAND.COM
COMPUTERNAME=SCHATZ
EDPATH=C:\progra~1\WATCOM\EDDAT
HOMEDRIVE=C:
HOMEPATH=\
INCLUDE=C:\progra~1\WATCOM\H;C:\progra~1\WATCOM\H\NT
LOGONSERVER=\\SCHATZ
MXBIN=D:\Programme\FireDaemon
MXHOME=D:\Programme\FireDaemon
NTRESKIT=D:\Programme\reskit1
NUMBER_OF_PROCESSORS=1
OS=Windows_NT
OS2LIBPATH=C:\WINNT\system32\os2\dll;
PATH=C:\winnt;C:\winnt\system32;C:\PROGRA~1\dosprog\tc\bin;C:\progra~1\dosprog\d
os6
PATHEXT=.COM;.EXE;.BAT;.CMD
PROCESSOR_ARCHITECTURE=x86
PROCESSOR_IDENTIFIER=x86 Family 6 Model 7 Stepping 3, GenuineIntel
PROCESSOR_LEVEL=6
PROCESSOR_REVISION=0703
PROMPT=$P$G
SYSTEMDRIVE=C:
SYSTEMROOT=C:\WINNT
TEMP=C:\TEMP
TMP=C:\TEMP
USERDOMAIN=SCHATZ
USERNAME=schatz
USERPROFILE=C:\WINNT\Profiles\schatz
WATCOM=C:\progra~1\WATCOM
WWINHELP=F:\BINW

Damit wissen Sie schon ziemlich viel über mich und meinen PC - sogar meinen Nachnamen. Sie wissen zumindest, dass ich auf einer ollen NT-Maschine mit einer ziemlich schlaffen CPU arbeite (PROCESSOR_IDENTIFIER). Was sehen wir hier? Wir sehen die voreingestellten Systemvariablen. Genau. Das sind Betriebssystem- variablen, die man abfragen und auch neu setzen kann. Die meisten davon sind Strings. Und eine davon enthält das Windows-Verzeichnis: SYSTEMROOT. Bingo.

Die nächste Aufgabe ist es, den Wert für SYSTEMROOT in unser Programm zu bekommen. Nun, wir haben im Kapitel Feine DOS-Fähigkeiten im Abschnitt "Umleitungen und Pipes" gelernt, dass man die Ausgabe eines DOS-Befehls in eine Datei umleiten kann. Geben wir also in unserem QBASIC-Verzeichnis "SET > set.txt" an, so leiten wir die Liste, was wir gerade noch auf dem Bildschirm gesehen haben, in die Datei set.txt um.

So, die nächste Aufgabe besteht nun darin, den Wert einer bestimmten Systemvariablen aus set.txt auszulesen. Das ist die Sache mit dem Dateien lesen. Hier muss man ein bisschen clever vorgehen, nämlich das Übungsergebnis aus dem vorigen Kapitel benutzen, bei dem es darum ging, eine search-Routine für Textdateien zu schreiben. Die die Textdatei nach einem bestimmten Schlüsselwort durchkämmt. Genau so etwas brauchen wir jetzt. Wenn Sie also die Übung noch nicht gemacht haben, dann schreiben Sie jetzt Ihre Routine "searchtextfile"! Ergebnis der Routine soll ein String mit der Zeile sein, in der das Schlüsselwort zum ersten Mal vorkommt. Kommt es in der Datei nicht vor, soll der String leer sein. Die Suche soll Gross- und Kleinschreibung nicht beachten.

Meine Lösung dafür sieht so aus:

'---------------------------------------------------------
'Lookstring:
'Routine fuer das Suchen eines Strings in einer Textdatei
'---------------------------------------------------------

'Sucht in #1
'#1 muss geoeffnet sein
'Suchstring: such$
'Rueckgabewert 1: rueck$
'Rueckgabewert 2: suchpos
'Enthaelt die Zeile mit dem Suchstring

'by C. Schatz 2003, Programmiertutorial

GOTO main



lookstring:

found = 0
WHILE (NOT EOF(1) AND found = 0)
  LINE INPUT #1, a$
  suchpos = INSTR(LCASE$(a$), LCASE$(such$))
  IF (suchpos > 0) THEN found = 1
WEND
IF (found = 0) THEN rueck$ = "": suchpos = 0 ELSE rueck$ = a$
RETURN

'Test
'---------
main:
SHELL "set > set.txt"
OPEN "set.txt" FOR INPUT AS #1
such$ = "systemroot"
GOSUB lookstring
CLOSE #1
PRINT rueck$
PRINT suchpos

Schauen wir uns diese Lösung einmal an. Was fällt Ihnen auf?

• Ich habe mehrere Funktionen von QBASIC benutzt, die wir noch nicht besprochen haben. Unverschämtheit! Nun, das war Absicht. Es gibt zwei Prinzipien, die sich beim Programmieren immer ein bisschen in der Quere sind. Prinzip 1: Nutze Ressourcen, die schon da sind. Das heisst, programmiere nicht etwas selbst, was andere schon längst besser programmiert haben und das du benutzen kannst. Bevor ich also selbst eine Stringbehandlungsroutine schreibe, schaue ich erstmal in QBASIC nach, ob es nicht etwas entsprechendes gibt. Und siehe da: QBASIC kann sowohl in einem String nach einem Suchstring sichen (INSTR()) als auch einen String in Klein- oder Grossbuchstaben umwandeln (LCASE$, bzw. UCASE$). Prinzip 2 ist allerdings: Sei kreativ! Denn auf der anderen Seite schreibt man kleine Teillösungen oft schneller, als man sie z.B. im Internet zusammengesucht hat. Zudem muss man eine Lösung fremder Programmierer immer erst genau auf ihre Eigenschaften untersuchen, während man die Eigenschaft der eigenen Routine natürlich kennt (oder kennen sollte!) Das sind so zwei Prinzipien, zwischen denen man immer hängt, wenn man selbst programmiert. Wenn Sie also sich selbst entsprechende Routinen geschrieben haben, dann war das nicht falsch. Aber Sie sollten auch bedenken: Jemand anderes, der QBASIC kennt, wird Ihr Programm besser verstehen können, wenn Sie nicht Ihre eigenen Routinen verwenden, sondern die von QBASIC.
• Ich habe ziemlich viel Kommentar an den Anfang geschrieben, besonders die Übergabewerte genau erklärt. Das hilft, wenn man die Routine später wieder verwenden möchte.
• Am Anfang kommt gleich ein "Goto". Was soll das denn? Nun, viele Dinge, die wir hier lernen, sollen ja allgemein für das Programmieren gültig sein, nicht nur in QBASIC. Daher sollten wir auch den Programmaufbau so wählen, wie er allgemein üblich ist. Und das ist: Zuerst die Unterprogramme und dann ganz unten das Hauptprogramm. Das hat zwei Gründe: Der erste ist historisch. Die "grossen" Programmiersprachen sind Compilersprachen. Und ein Compiler übersetzt ein Programm Zeile für Zeile von oben nach unten. Wenn ein Compiler auf einen Ausdruck trifft, z.B. einen Unterprogrammnamen, muss er ihn schon kennen, d.h. wissen, dass dies ein Unterprogramm darstellen muss. Deshalb muss die Deklaration einer Routine immer vor ihrer Verwendung erfolgen. Das ist auch heute noch bei "grossen" Programmiersprachen der Fall. Der zweite Grund ist, dass der Leser eines Quelltextes genau das gleiche Problem hat. Auch er liest das Programm von oben nach unten. Also ist es auch gut, in QBASIC die Ordnung so zu halten. Da QBASIC aber ein Programm von oben nach unten durchgeht und nicht zuerst nach dem Hauptprogramm sucht, muss man es erst zum Hauptprogramm "schicken". Für diesen einen Fall müssen wir ein GOTO verwenden, das geht kaum anders.
• In der While-Schleife wird die EOF() mitverwendet. Das sollte man nie vergessen, da es ja auch sein kann, dass der Suchstring NICHT gefunden wird.

So. Das Hauptprogramm zeigt schon, wie wir nun ganz elegant an die Systemvariablen rankommt, auch z.B. an das temporäre Verzeichnis des Rechners. Wir müssen nun nur noch aus der richtigen Zeile des Variablenwert extrahieren. Das ist ziemlich einfach. Wir ermitteln mit INSTR() die Position des Gleichheitszeichens und nehmen dann den String ab einem Zeichen hinter dieser Position:

winpath$=MID$(rueck$,INSTR(rueck$,"=")+1,len(rueck$))

Die Zeile ist allerdings ein bisschen unübersichtlich. "Sprechender" wäre es, sie in mehrere Zeilen aufzuteilen:

posstart=INSTR(rueck$,"=")+1
IF (posstart=1) THEN STOP 'Hups! Kein Gleichheitszeichen!
posend=LEN(rueck$)
winpath$=MID$(rueck$,posstart,posend)

Das ganze Programm: Kopieren eines Files ins Windowsverzeichnis

Der Rest ist nun einfach. Nehmen wir an, wir wollen das File von Diskette ins Windowsverzeichnis kopieren. Dann bilden wir den ganzen DOS-Befehl als String: cmd$="copy A:\"+fname$+" "+winpath$
und übergeben ihn der SHELL: SHELL(cmd$). fname$ enthält den Filenamen, z.B. "myprog.exe". Und das war's dann.

Was haben wir gelernt?

• Was man mit dem Lesen von Textdateien aus Programmen heraus so machen kann. Die Kombination von DOS-Befehl, Dateiumleitung und Fileauslesen in QBASIC lässt sich auch bezüglich vieler anderer Befehle verwenden, vor allem solchen, die mit dem Netzwerk zu tun haben: ping, nslookup, ipconfig, tracert usw. Die net-Befehle geben ja sehr viele Informationen über das NT-Netzwerk in die Konsole aus und mittels der gelernten Technik können wir sie dann in QBASIC benutzen.
• Ein gewichtiger Vorwand gegen diese Technik könnte sein: Sie ist stark von der Windowsversion abhängig, da sich unter den verschiedenen Windowsversionen die Ausgaben der genannten Befehle im Format teilweise ziemlich unterscheiden. Das stimmt. Aber der Effekt ist bei unserem Programm nicht besonders tragisch, da wir ja nicht bestimmte Zahlen von Zeilen und Spalten annehmen, sondern immer nach Schlüsselworten suchen. Solange die Schlüsselworte aus den Bildschirmausgaben nicht verschwinden, kann nicht soviel schief gehen.
  Es gibt allerdings auch Fälle, wo der Einwand voll zutrifft. Wenn Sie z.B. versuchen, den dir-Befehl umzuleiten, um auf diese Art und Weise eine Operation auf jede Datei im aktuellen verzeichnis anzuwenden. Das können Sie gut machen, aber die Ausgabe des dir-Befehls ist sehr versionsabhängig. Hier kommen Sie nicht umhin, zuerst die Windowsversion abzufragen (Systemvariable!), um dann für jedes dir- Format eine extra Version ihrer dir-Leseroutine zu schreiben.
• Wir haben aber auch ein bisschen etwas zur allgemeinen Programmiertechnik dazugelernt: Kommentieren von Routinen, Aufsuchen von Ressourcen (schon programmierten Routinen), Aufbau von Programmen, usw.

Übung:

1. Schreiben Sie ein Programm (einfache Version), das alle Dateien mit der Endung .txt oder .bas in einem beliebig zu wählenden Verzeichnis durchsucht und darin alle DOS-Umlaute in Windows-Umlaute umsetzt - oder umgekehrt. "Einfache Version" heisst: Nur für Ihre Windows-Version. Um zu wissen, welchen Code in DOS- und Windows-Programme jeweils haben, müssen Sie erstmal zwei Auswertungen machen: Einfach jeweils mit einem Windows- und einem DOS-Editor die Umlaute schreiben, abspeichern, mit QBASIC einlesen und mit der ASC()-Funktion schauen, welche Codes sich dahinter verbergen. Das Ergebnis ist dann die "Übersetzungstabelle".
2. Erweitern Sie das Programm so, dass es auch in den Unterverzeichnissen des angegeben Verzeichnissen die Umwandlung vornimmt!
3. Erweitern Sie die Version so, dass es zuerst die Windowsversion ermittelt und dann die verschiedenen dir-Ausgabeformate der Windowsversionen berücksichtigt.