Oft, und besonders bei Konsolenanwendungen, muss man die übergebenden Parameter auswerten. Delphi bietet dafür nur wenige Funktionen (ParamStr, ParamCount, etc).
Möchte man jetzt zum Beispiel prüfen ob ein bestimmter Parameter gesetzt ist so muss man in einer Schleife jeden einzelnen Parameter überprüfen. Wenn man sich zum Beispiel die verfügbaren Parameter des Delphi Komandozeilen Compiler (dcc32.exe) anschaut stellt man fest das es neben den üblichen Parametern auch noch Optionen und Schaltern gibt. Eine solche Auswertung der Parameter im Sourcecode ist dann schon sehr aufwändig.
Wenn man z. b. die folgenden Parameter einer Anwendung übergibt:
Parameter:
1:
| test.txt /u- /Opt1 param2 /Opt2:Value1 /d+ /f |
Dann gibt es zwei Parmeter. Nämlich test.txt und param2. Außerdem sind drei Optionen angegeben: 'Opt1', 'Opt2' und 'f'. Die Option 'Opt2' verfügt außerdem über den Wert Value1. Das wird z. B. auch beim dcc32.exe unter anderem für die Angabe von Conditionals Defines verwendet. Zusätzlich sind noch zwei Schalter definiert. Der erste Schalter 'u' hat den Wert False (-) und der zweite Schalter 'd' hat den Wert True (+).
Die folgende Unit hilft einem beim auswerten von Parametern. Dabei werden Parameter, Optionen und Schalter getrennt angesprochen. Die wichtigsten Methoden sind folgende:
Delphi-Quelltext
1:
| Function Parameter (aIdx: Integer): String; |
Hier hat man Zugriff auf die übergebenden Parameter. In dem o. g. Beispiel: 'test.txt' und 'param2'.
Delphi-Quelltext
1:
| Function ParameterCount: Integer; |
Gibt die Anzahl der übergebenden Parameter zurück. In dem o. g. Beispiel: 2
Delphi-Quelltext
1:
| Function OptionSet (aName: String): Boolean; |
Gibt True zurück wenn eine Option gesetzt ist. In dem o. g. Beispiel würde die Funktion bei den Optionen 'Opt1' und 'Opt2' jeweils True zurück geben.
Delphi-Quelltext
1:
| Function OptionValue (aName: String): String; |
Gibt den Wert zurück der bei der Option angegeben würde. In dem o. g. Beispiel bei der Option 'Opt2' der Wert 'Value1'.
Delphi-Quelltext
1:
| Function SwitchSet (aName: String): Boolean; |
Prüft ob der Schalte angegeben würde.
Delphi-Quelltext
1:
| Function SwitchValue (aName: String): Boolean; |
Gibt den angegebenden Wert des Schalters zurück.
Außerdem gibt es noch das Property
CaseSensitivity. Damit kann man außerdem zwischen Groß- & Kleinschreibung unterscheiden. Optionen kann man mit -OptName oder /OptName angeben.
Hier mal ein Beispiel für die Verwendung von unitParameters.pas:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31:
| Uses sdParams;
procedure TForm1.FormCreate(Sender: TObject); Var Params: tParameters; Loop: Integer; begin Memo1.Lines.Clear;
Params := tParameters.Create; Try Memo1.Lines.Add ('==Parameter=='); For Loop := 0 To Params.ParameterCount -1 Do Memo1.Lines.Add (' ' + IntToStr (Loop) + ' = ' + Params.Parameter (Loop));
Memo1.Lines.Add ('==Optionen=='); If Params.OptionSet ('Opt1') Then Memo1.Lines.Add (' /Opt1 ist gesetzt') Else Memo1.Lines.Add (' /Opt1 ist nicht gesetzt');
If Params.OptionSet ('OPT2') Then Memo1.Lines.Add (' /Opt2 ist gesetzt') Else Memo1.Lines.Add (' /Opt2 ist nicht gesetzt'); Finally Params.Free; End; end; |
Hier die entsprechende Unit. Die Unit ist noch nicht wirklich viel getestet worden!
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83: 84: 85: 86: 87: 88: 89: 90: 91: 92: 93: 94: 95: 96: 97: 98: 99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280:
| Unit unitParameters;
Interface
Uses Classes;
Type tParamsItemTypeId = ( idParamsItemTypeParam, idParamsItemTypeOption, idParamsItemTypeSwitch );
tParamsItem = Class Typ: tParamsItemTypeId;
Param: String; Option: String; Switch: Boolean; End;
tParameters = Class Private fItems: tList; fCaseSensitivity: Boolean; Procedure ItemsCreate; Procedure ItemsClear; Function ItemsFind (aName: String): Integer;
Function GetCount: Integer; Function GetItems (Index: Integer): tParamsItem;
Property Items [Index: Integer]: tParamsItem read GetItems; Protected
Public Constructor Create; Destructor Destroy; override;
Property Count: Integer read GetCount;
Function Parameter (aIdx: Integer): String; Function ParameterCount: Integer; Function OptionSet (aName: String): Boolean; Function OptionValue (aName: String): String; Function SwitchSet (aName: String): Boolean; Function SwitchValue (aName: String): Boolean;
Property CaseSensitivity: Boolean read fCaseSensitivity write fCaseSensitivity; End;
Implementation
Uses SysUtils;
Const cParamOptionChars : Array [1..2] Of Char = ('-', '/'); cParamSwitchChars : Array [1..2] Of Char = ('-', '+'); cParamOptionParam = ':';
Constructor tParameters.Create; Begin fCaseSensitivity := False; fItems := tList.Create; ItemsCreate; End;
Destructor tParameters.Destroy; Begin ItemsClear; fItems.Free; Inherited; End;
Procedure tParameters.ItemsCreate;
Procedure AddParam (aStr: String);
Function GetType: tParamsItemTypeId; Begin If (aStr [1] = cParamOptionChars [1]) or (aStr [1] = cParamOptionChars [2]) Then If (aStr [Length (aStr)] = cParamSwitchChars [1]) or (aStr [Length (aStr)] = cParamSwitchChars [2]) Then GetType := idParamsItemTypeSwitch Else GetType := idParamsItemTypeOption Else GetType := idParamsItemTypeParam; End;
Var NewParam: tParamsItem; Begin NewParam := tParamsItem.Create;
Case GetType of idParamsItemTypeParam: Begin NewParam.Typ := idParamsItemTypeParam; NewParam.Param := aStr; End; idParamsItemTypeOption: Begin NewParam.Typ := idParamsItemTypeOption; If Pos (cParamOptionParam, aStr) > 2 Then Begin NewParam.Param := Copy ( aStr, 2, Pos (cParamOptionParam, aStr) - 2 ); NewParam.Option := Copy ( aStr, Pos (cParamOptionParam, aStr) + 1, Length (aStr) ); End Else NewParam.Param := Copy (aStr, 2, Length (aStr) - 1); End; idParamsItemTypeSwitch: Begin NewParam.Typ := idParamsItemTypeSwitch; NewParam.Param := Copy (aStr, 2, Length (aStr) - 2); NewParam.Switch := aStr [Length (aStr)] = cParamSwitchChars [2]; End; End;
If fItems.Add (NewParam) = -1 Then ; End;
Var Idx: Integer; Begin For Idx := 1 To ParamCount Do AddParam (ParamStr (Idx)); End;
Procedure tParameters.ItemsClear; Var Idx: Integer; DelItem : tParamsItem; Begin For Idx := Count - 1 DownTo 0 Do begin DelItem := Items [Idx]; DelItem.Param := ''; DelItem.Option := '';
DelItem.Free; End; fItems.Clear; End;
Function tParameters.ItemsFind (aName: String): Integer;
Function CaseSenStr (aString: String): String; Begin If fCaseSensitivity Then CaseSenStr := aString else CaseSenStr := UpperCase (aString); End; Var Idx: Integer; Begin aName := CaseSenStr (aName);
For Idx := 0 To Count - 1 Do If CaseSenStr (Items [Idx].Param) = aName Then Begin ItemsFind := Idx; Exit; End;
ItemsFind := -1; End;
Function tParameters.GetCount: Integer; Begin GetCount := fItems.Count; End;
Function tParameters.GetItems (Index: Integer): tParamsItem; Begin GetItems := fItems [Index]; End;
Function tParameters.Parameter (aIdx: Integer): String; Var Cnt, Idx: Integer; Begin Cnt := -1;
For Idx := 0 To Count - 1 Do If Items [Idx].Typ = idParamsItemTypeParam Then Begin Inc (Cnt); If Cnt = aIdx Then Begin Parameter := Items [Idx].Param; Exit; End; End;
Parameter := ''; End;
Function tParameters.ParameterCount: Integer; Var Cnt, Idx: Integer; Begin Cnt := 0;
For Idx := 0 To Count - 1 Do If Items [Idx].Typ = idParamsItemTypeParam Then Inc (Cnt);
ParameterCount := Cnt; End;
Function tParameters.OptionSet (aName: String): Boolean; Var Idx: Integer; Begin If (aName [1] = cParamOptionChars [1]) or (aName [1] = cParamOptionChars [2]) Then Idx := ItemsFind (Copy (aName, 2, Length (aName) -1)) Else Idx := ItemsFind (aName);
OptionSet := (Idx > -1) and (Items [Idx].Typ = idParamsItemTypeOption); End;
Function tParameters.OptionValue (aName: String): String; Var Idx: Integer; Begin If (aName [1] = cParamOptionChars [1]) or (aName [1] = cParamOptionChars [2]) Then Idx := ItemsFind (Copy (aName, 2, Length (aName) -1)) Else Idx := ItemsFind (aName);
If (Idx > -1) and (Items [Idx].Typ = idParamsItemTypeOption) Then OptionValue := Items [Idx].Option Else OptionValue := ''; End;
Function tParameters.SwitchSet (aName: String): Boolean; Var Idx: Integer; Begin Idx := ItemsFind (aName);
SwitchSet := (Idx > -1) and (Items [Idx].Typ = idParamsItemTypeSwitch); End;
Function tParameters.SwitchValue (aName: String): Boolean; Var Idx: Integer; Begin Idx := ItemsFind (aName);
If (Idx > -1) and (Items [Idx].Typ = idParamsItemTypeSwitch) Then SwitchValue := Items [Idx].Switch Else SwitchValue := False; End;
End. |
Moderiert von Tino: Fehler entfernt am 12.11.2007 um 22:30 Uhr