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
