Frage deutsch
~~~~~~~~~~~~~
Wie kann ich Parameter an ein QuickBasic-Programm beim Aufruf übergeben?
 

Question English
~~~~~~~~~~~~~~
How do I transfer and evaluate runtime parameters from the command line?
 

Antwort 1
~~~~~~~~~
[ von Thomas Antoni, 11.1999 - 12.3.2006 ]
.
Ein compiliertes QuickBasic-Programm kann die übergebenen Aufrufparameter mit der Funktion COMMAND$ abfragen. Dies ist nur bei kompilierten QuickBASIC-, nicht bei QBasic-Programmen möglich.

COMMAND$ liefert den Text der Aufrufzeile, mit der das EXE-Programm aufgerufen wurde, als Textstring zurück. Lautet der Aufruf z.B. "programm.exe datei.txt" , dann gibt COMMAND$ den String "DATEI.TXT" zurück. Beachte, dass QuickBASIC alle übergeben Zeichen automatisch in Großbuchstaben umwandelt
 
Wenn es sich um mehr als einen Übergabeparameter handelt , dann ist es eine etwas fummelige Arbeit, die einzelnen Parmeter aus dem COMMAND$-String zu "isolieren". Zum Glück gibt es aber in der Unterprogrammsammlung QSUBFUN.BAS für diesen Zweck die SUBroutine GetArguments, die genau das übernimmt. Oder Du orientierst Dich an dem unten stehenden Programm COMMANDP.BAS.
 
Diese sehr nüzliche Unterprogrammsammlung steht auf http://www.qbasic.de unter "Download -> Sonstiges -> QSUBFUN.ZIP" zum Herunterladen bereit.
 
Während Du programmierst, kannst du in der QB-Entwicklungsumgebung zu Testzwecken auch über den Menüpunkt
"Ausführen | Ändere Command$"
 
den Übergabe-Parameter ändern und im Interpreter-Modus verwenden. Oder Du rufts die QB-Entwicklungsumgebung QB.exe (bzw. bei QB 7.1 QBX.EXE) auf der Kommandozeile mit der Option
QB.EXE /CMD <Parameter-Zeichenkette>
 
auf und übergibst in der "Parameter-Zeichenkette" den COMMAND$-String. Diese Option muß die letzte Option in der Kommandozeile sein.
 
*** Kommadozeilen-Parser COMMANDP.BAS
Und nun zu dem angekündigten Programm COMMANDP.BAS, das den durch die COMMAND$-Funktion übergebenen String auswertet ("parst" , siehe -> Parser ) und in ein Sring-Feld einträgt. Dieses Programm kann eine Hilfe sein, wenn mehr als ein Parameter übergeben wird.
 
 
'***************************************************************************
' COMMANDP.BAS = COMMAND LINE PARSER, delivers the COMMAND$ line elements
' ============ Liefert die einzelnen Parameter der COMMAND$-Kommandozeile
'
' Deutsche Beschreibung
' ----------------------
' (von Thomas Antoni, 12.3.2006)
' Dieser "Kommandozeilen-Parser" für QuickBASIC analysiert den durch die
' COMMAND$-Funktion gelieferten Kommandozeilen-String. Die Funktion
' DimParse liefert die Anzahl der mit dem EXE-Programm uebergebenen
' Kommandozeilenparameter. Die Funktion Parse liefert den Inhalt des
' i-ten Parameters, wobei i als Parameter an die Funktion uebergeben wird.
' Als Trennzeichen zwischen den einzelnen Parameter wird nur ein
' Leerzeichen anerkannt. Sollen mhrere Leerzeichen oder andere
' Trennzeichen erlaubt sein, dann kannst Du das Program leicht
' entsprechend anpassen.
'
' English Description
' ----------------------
' QUESTION: Hi, I was wondering if anyone had a good (or halfway
' decent) routine or sub for dissecting the COMMAND$ returned by
' QuickBasic 4.5. I am looking for something that will find two
' filenames and a few flags.
'
' ANSWER: Here you go....
' The DimParse function returns the number of elements in the string, (to
' DIM an array or whatever) the Parse function returns the individual
' parts of the given COMAND$ string, one part per call, until the end of
' the string is entered, then starts over. It works fast and easy. Because
' of my personal preference only a space is recognized as the separation
' between elements. Feel free to change that if you wish, should be easy.
'
' (c) July 24, 1993
'***************************************************************************
DECLARE FUNCTION Parse$ (In$)
DECLARE FUNCTION DimParse% (In$)
'Parse and DimParse functions by Andy Thomas
'
DEFINT A-Z
'
CLS
A$ = "Hello this is a test /d /a" 'test string
PRINT "Teststring: A$ = "; A$
PRINT
PRINT "Elements in A$ = "; DimParse%(A$)
FOR I = 1 TO DimParse%(A$)
PRINT "Parse$("; I; ") = "; Parse$(A$)
NEXT I
'----------
'The above would generate the following display
'---------
'Elements in A$= 7
'Hello
'this
'is
'a
'test
'/d
'/a
'
SLEEP
END
FUNCTION DimParse% (In$)
In$ = RTRIM$(LTRIM$(In$))
Parses = 0
Length = LEN(In$)
IF Length = 0 THEN
DimParse% = 0
EXIT FUNCTION
END IF
FOR I = 1 TO Length
IF MID$(In$, I, 1) = " " THEN Parses = Parses + 1
NEXT I
DimParse% = Parses + 1
END FUNCTION
'
'
FUNCTION Parse$ (In$)
DEFINT A-Z
STATIC ParseAt%, Length
IF ParseAt% = 0 THEN
ParseAt% = 1
Length = LEN(In$)
END IF
IF Length = 0 OR ParseAt% > Length THEN EXIT FUNCTION
Offset% = INSTR(ParseAt%, In$, " ")
IF Offset% = 0 THEN Offset% = Length + 1
Parse$ = MID$(In$, ParseAt%, Offset% - ParseAt%)
ParseAt% = Offset% + 1
IF ParseAt% = Length + 2 THEN ParseAt% = 0
END FUNCTION
 
Das obige Programm steht im Verzeichnis Progs\ zur Verfügung sowie online unter www.antonis.de/faq/progs/commandp.bas .
 
Es geht aber auch etwas einfacher, wie der folgende Programmvorschlag von Quinn Tyler Jackson zeigt:
 
 
DEFINT A-Z
'SUB procedure to get command line and split into arguments.
'Parameters: NumArgs : Number of command line args found.
' Args$() : Array in which to return arguments.
' MaxArgs : Maximum number of arguments array can return.
STATIC SUB Comline (NumArgs, Args$(), MaxArgs)
CONST TRUE = -1, FALSE = 0
NumArgs = 0: In = FALSE
'Get the command line using the COMMAND$ function.
Cl$ = COMMAND$
L = LEN(Cl$)
'Go through the command line a character at a time.
FOR I = 1 TO L
C$ = MID$(Cl$, I, 1)
'Test for character being a blank or a tab.
IF (C$ <> " " AND C$ <> CHR$(9)) THEN
'Neither blank nor tab. Test if you're already inside an argument.
IF NOT In THEN
'You've found the start of a new argument.
'Test for too many arguments.
IF NumArgs = MaxArgs THEN EXIT FOR
NumArgs = NumArgs + 1
In = TRUE
END IF
'Add the character to the current argument.
Args$(NumArgs) = Args$(NumArgs) + C$
ELSE
'Found a blank or a tab.
'Set "Not in an argument" flag to FALSE.
In = FALSE
END IF
NEXT I
END SUB
 
Antwort 2
~~~~~~~~~~~~~~~~
[ von verschiedenen Teilnehmern im QB-Forum, 7.2005 ]
.
Wenn Du an der Kommandozeile oder über ein Batch-Programm oder die Kommandozeile einen Parameter an Dein QuickBASIC-Programm übergeben willst, dann musst dann einfach COMMAND$ in deinem Programm abfragen, etwa so:
IF COMMAND$ = "Hallo" THEN PRINT "Hallo zurück."
 
Also: Der COMMAND$- Befehl in einem selbstausführenden QB-Programm speichert sozusagen den Anhang der Programmaufrufs. In einer Batch-Datei könnte das so aussehen:
C:\Basic\Com.exe Blaubeerkuchen
 
Das Wort "Blaubeerkuchen" ist jetzt in COMMAND$ (in dem Beispiel-Programm Com.exe ) automatisch gespeichert. Wenn Du a$=COMMAND$ geschrieben hättest, wäre es auch in a$ gespeichert.
 
Wenn Du eine Zahl übergeben willst, dann musst Du berücksichtigen, dass diese Zahl als Textstring in COMMAND$ gespeichert ist und erst noch in eine Zahl umgewandelt werden muß.
 
In der Batch-Datei steht z,B,:
C:\Basic\Com.exe 2005
 
In COMMAND$ ist dann das "Wort" (bzw, der Textstring) "2005" gespeichert und nicht der Zahlenwert, wie oben erklärt.
 
Mit
Variable% = LTRIM$(VAL(COMMAND$))
 
kannst Du statt des Teststrings den Zahlenwert in der Variablen Variable% speichern. Also Variable% = 2005.
 
Willst Du in der QuickBASIC-Entwicklungsumgebung einen Parameterwert "Esel" im Interpretermodus zum Testen vorgeben, so machst Du das über das "Ausführen"-Menü wie folgt:
"Ausführen | Ändere COMMAND$...| Esel" .
 
Oder Du rufst die Entwicklungsumgebung Qb.EXE mit folgender Option auf:
qb /cmd Esel
 
Diese Option muß die letzte Option in der Kommandozeile sein.
 
 

Answer 2
~~~~~~~~~
How do I make runtime parameters?
 
Runtime parameters, for those who don't know, are things like dir /w, the /w is a runtime parameter, or switch. In Qb, you can parse these with the COMMAND$ function.
 
COMMAND$ works for QuickBasic and higher only and returns the command line which launched the EXE-programm as a string.
 
To give you a basic idea ...
 
IF COMMAND$ = "stuff" THEN CALL DoActions
 
But be careful: COMMAND$ returns the entire command line. You must "isolate" the transferred parameter(s) from it.
 
And now, of course, your next question will be: "How do I seperate command line arguments?"
 
Well, the answer ist as follows:
 
You can use the following routine to seperate anything in a string variable that is seperated by spaces:
'
'
DIM SHARED arg$(20) 'Max of 20 arguments, increase/decrease for your app.
'Set up string and make call:
TheString$="This is a test of the EBS system."
NumOfWords%=ArgSplit%(TheString$)
For x%=0 to NumOfWords%
Print arg$(x%)
Next x%
'
SUB ArgSplit%(cline$)
I = 1: arg = LBOUND(arg$): inword = -1
WHILE I <= LENGTH
ch$ = MID$(cline$, I, 1)
IF ch$ <> " " THEN
IF NOT inword THEN inword = -1
arg$(arg) = arg$(arg) + ch$
ELSEIF inword THEN
arg = arg + 1
inword = 0
END IF
I = I + 1
WEND
ArgSplit% = arg
END SUB
 
 

[ The QBasic-MonsterFAQ --- Start Page: www.antonis.de/faq ]