]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: common/cmdline.cpp | |
3 | // Purpose: wxCmdLineParser implementation | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 05.01.00 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2000 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
9 | // Licence: wxWindows license | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | #ifdef __GNUG__ | |
21 | #pragma implementation "cmdline.h" | |
22 | #endif | |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #include "wx/cmdline.h" | |
32 | ||
33 | #if wxUSE_CMDLINE_PARSER | |
34 | ||
35 | #ifndef WX_PRECOMP | |
36 | #include "wx/string.h" | |
37 | #include "wx/log.h" | |
38 | #include "wx/intl.h" | |
39 | #include "wx/app.h" | |
40 | #include "wx/dynarray.h" | |
41 | #include "wx/filefn.h" | |
42 | #endif //WX_PRECOMP | |
43 | ||
44 | #include <ctype.h> | |
45 | ||
46 | #include "wx/datetime.h" | |
47 | ||
48 | // ---------------------------------------------------------------------------- | |
49 | // private functions | |
50 | // ---------------------------------------------------------------------------- | |
51 | ||
52 | static wxString GetTypeName(wxCmdLineParamType type); | |
53 | ||
54 | // ---------------------------------------------------------------------------- | |
55 | // private classes | |
56 | // ---------------------------------------------------------------------------- | |
57 | ||
58 | // an internal representation of an option | |
59 | struct wxCmdLineOption | |
60 | { | |
61 | wxCmdLineOption(wxCmdLineEntryType k, | |
62 | const wxString& shrt, | |
63 | const wxString& lng, | |
64 | const wxString& desc, | |
65 | wxCmdLineParamType typ, | |
66 | int fl) | |
67 | { | |
68 | wxASSERT_MSG( !shrt.empty() || !lng.empty(), | |
69 | _T("option should have at least one name") ); | |
70 | ||
71 | kind = k; | |
72 | ||
73 | shortName = shrt; | |
74 | longName = lng; | |
75 | description = desc; | |
76 | ||
77 | type = typ; | |
78 | flags = fl; | |
79 | ||
80 | m_hasVal = FALSE; | |
81 | } | |
82 | ||
83 | // can't use union easily here, so just store all possible data fields, we | |
84 | // don't waste much (might still use union later if the number of supported | |
85 | // types increases, so always use the accessor functions and don't access | |
86 | // the fields directly!) | |
87 | ||
88 | void Check(wxCmdLineParamType WXUNUSED_UNLESS_DEBUG(typ)) const | |
89 | { | |
90 | wxASSERT_MSG( type == typ, _T("type mismatch in wxCmdLineOption") ); | |
91 | } | |
92 | ||
93 | long GetLongVal() const | |
94 | { Check(wxCMD_LINE_VAL_NUMBER); return m_longVal; } | |
95 | const wxString& GetStrVal() const | |
96 | { Check(wxCMD_LINE_VAL_STRING); return m_strVal; } | |
97 | const wxDateTime& GetDateVal() const | |
98 | { Check(wxCMD_LINE_VAL_DATE); return m_dateVal; } | |
99 | ||
100 | void SetLongVal(long val) | |
101 | { Check(wxCMD_LINE_VAL_NUMBER); m_longVal = val; m_hasVal = TRUE; } | |
102 | void SetStrVal(const wxString& val) | |
103 | { Check(wxCMD_LINE_VAL_STRING); m_strVal = val; m_hasVal = TRUE; } | |
104 | void SetDateVal(const wxDateTime val) | |
105 | { Check(wxCMD_LINE_VAL_DATE); m_dateVal = val; m_hasVal = TRUE; } | |
106 | ||
107 | void SetHasValue(bool hasValue = TRUE) { m_hasVal = hasValue; } | |
108 | bool HasValue() const { return m_hasVal; } | |
109 | ||
110 | public: | |
111 | wxCmdLineEntryType kind; | |
112 | wxString shortName, | |
113 | longName, | |
114 | description; | |
115 | wxCmdLineParamType type; | |
116 | int flags; | |
117 | ||
118 | private: | |
119 | bool m_hasVal; | |
120 | ||
121 | long m_longVal; | |
122 | wxString m_strVal; | |
123 | wxDateTime m_dateVal; | |
124 | }; | |
125 | ||
126 | struct wxCmdLineParam | |
127 | { | |
128 | wxCmdLineParam(const wxString& desc, | |
129 | wxCmdLineParamType typ, | |
130 | int fl) | |
131 | : description(desc) | |
132 | { | |
133 | type = typ; | |
134 | flags = fl; | |
135 | } | |
136 | ||
137 | wxString description; | |
138 | wxCmdLineParamType type; | |
139 | int flags; | |
140 | }; | |
141 | ||
142 | WX_DECLARE_OBJARRAY(wxCmdLineOption, wxArrayOptions); | |
143 | WX_DECLARE_OBJARRAY(wxCmdLineParam, wxArrayParams); | |
144 | ||
145 | #include "wx/arrimpl.cpp" | |
146 | ||
147 | WX_DEFINE_OBJARRAY(wxArrayOptions); | |
148 | WX_DEFINE_OBJARRAY(wxArrayParams); | |
149 | ||
150 | // the parser internal state | |
151 | struct wxCmdLineParserData | |
152 | { | |
153 | // options | |
154 | wxString m_switchChars; // characters which may start an option | |
155 | bool m_enableLongOptions; // TRUE if long options are enabled | |
156 | wxString m_logo; // some extra text to show in Usage() | |
157 | ||
158 | // cmd line data | |
159 | wxArrayString m_arguments; // == argv, argc == m_arguments.GetCount() | |
160 | wxArrayOptions m_options; // all possible options and switchrs | |
161 | wxArrayParams m_paramDesc; // description of all possible params | |
162 | wxArrayString m_parameters; // all params found | |
163 | ||
164 | // methods | |
165 | wxCmdLineParserData(); | |
166 | void SetArguments(int argc, wxChar **argv); | |
167 | void SetArguments(const wxString& cmdline); | |
168 | ||
169 | int FindOption(const wxString& name); | |
170 | int FindOptionByLongName(const wxString& name); | |
171 | }; | |
172 | ||
173 | // ============================================================================ | |
174 | // implementation | |
175 | // ============================================================================ | |
176 | ||
177 | // ---------------------------------------------------------------------------- | |
178 | // wxCmdLineParserData | |
179 | // ---------------------------------------------------------------------------- | |
180 | ||
181 | wxCmdLineParserData::wxCmdLineParserData() | |
182 | { | |
183 | m_enableLongOptions = TRUE; | |
184 | #ifdef __UNIX_LIKE__ | |
185 | m_switchChars = _T("-"); | |
186 | #else // !Unix | |
187 | m_switchChars = _T("/-"); | |
188 | #endif | |
189 | } | |
190 | ||
191 | void wxCmdLineParserData::SetArguments(int argc, wxChar **argv) | |
192 | { | |
193 | m_arguments.Empty(); | |
194 | ||
195 | for ( int n = 0; n < argc; n++ ) | |
196 | { | |
197 | m_arguments.Add(argv[n]); | |
198 | } | |
199 | } | |
200 | ||
201 | void wxCmdLineParserData::SetArguments(const wxString& cmdLine) | |
202 | { | |
203 | m_arguments.Empty(); | |
204 | ||
205 | m_arguments.Add(wxTheApp->GetAppName()); | |
206 | ||
207 | wxArrayString args = wxCmdLineParser::ConvertStringToArgs(cmdLine); | |
208 | ||
209 | WX_APPEND_ARRAY(m_arguments, args); | |
210 | } | |
211 | ||
212 | int wxCmdLineParserData::FindOption(const wxString& name) | |
213 | { | |
214 | if ( !name.empty() ) | |
215 | { | |
216 | size_t count = m_options.GetCount(); | |
217 | for ( size_t n = 0; n < count; n++ ) | |
218 | { | |
219 | if ( m_options[n].shortName == name ) | |
220 | { | |
221 | // found | |
222 | return n; | |
223 | } | |
224 | } | |
225 | } | |
226 | ||
227 | return wxNOT_FOUND; | |
228 | } | |
229 | ||
230 | int wxCmdLineParserData::FindOptionByLongName(const wxString& name) | |
231 | { | |
232 | size_t count = m_options.GetCount(); | |
233 | for ( size_t n = 0; n < count; n++ ) | |
234 | { | |
235 | if ( m_options[n].longName == name ) | |
236 | { | |
237 | // found | |
238 | return n; | |
239 | } | |
240 | } | |
241 | ||
242 | return wxNOT_FOUND; | |
243 | } | |
244 | ||
245 | // ---------------------------------------------------------------------------- | |
246 | // construction and destruction | |
247 | // ---------------------------------------------------------------------------- | |
248 | ||
249 | void wxCmdLineParser::Init() | |
250 | { | |
251 | m_data = new wxCmdLineParserData; | |
252 | } | |
253 | ||
254 | void wxCmdLineParser::SetCmdLine(int argc, wxChar **argv) | |
255 | { | |
256 | m_data->SetArguments(argc, argv); | |
257 | } | |
258 | ||
259 | void wxCmdLineParser::SetCmdLine(const wxString& cmdline) | |
260 | { | |
261 | m_data->SetArguments(cmdline); | |
262 | } | |
263 | ||
264 | wxCmdLineParser::~wxCmdLineParser() | |
265 | { | |
266 | delete m_data; | |
267 | } | |
268 | ||
269 | // ---------------------------------------------------------------------------- | |
270 | // options | |
271 | // ---------------------------------------------------------------------------- | |
272 | ||
273 | void wxCmdLineParser::SetSwitchChars(const wxString& switchChars) | |
274 | { | |
275 | m_data->m_switchChars = switchChars; | |
276 | } | |
277 | ||
278 | void wxCmdLineParser::EnableLongOptions(bool enable) | |
279 | { | |
280 | m_data->m_enableLongOptions = enable; | |
281 | } | |
282 | ||
283 | void wxCmdLineParser::SetLogo(const wxString& logo) | |
284 | { | |
285 | m_data->m_logo = logo; | |
286 | } | |
287 | ||
288 | // ---------------------------------------------------------------------------- | |
289 | // command line construction | |
290 | // ---------------------------------------------------------------------------- | |
291 | ||
292 | void wxCmdLineParser::SetDesc(const wxCmdLineEntryDesc *desc) | |
293 | { | |
294 | for ( ;; desc++ ) | |
295 | { | |
296 | switch ( desc->kind ) | |
297 | { | |
298 | case wxCMD_LINE_SWITCH: | |
299 | AddSwitch(desc->shortName, desc->longName, desc->description, | |
300 | desc->flags); | |
301 | break; | |
302 | ||
303 | case wxCMD_LINE_OPTION: | |
304 | AddOption(desc->shortName, desc->longName, desc->description, | |
305 | desc->type, desc->flags); | |
306 | break; | |
307 | ||
308 | case wxCMD_LINE_PARAM: | |
309 | AddParam(desc->description, desc->type, desc->flags); | |
310 | break; | |
311 | ||
312 | default: | |
313 | wxFAIL_MSG( _T("unknown command line entry type") ); | |
314 | // still fall through | |
315 | ||
316 | case wxCMD_LINE_NONE: | |
317 | return; | |
318 | } | |
319 | } | |
320 | } | |
321 | ||
322 | void wxCmdLineParser::AddSwitch(const wxString& shortName, | |
323 | const wxString& longName, | |
324 | const wxString& desc, | |
325 | int flags) | |
326 | { | |
327 | wxASSERT_MSG( m_data->FindOption(shortName) == wxNOT_FOUND, | |
328 | _T("duplicate switch") ); | |
329 | ||
330 | wxCmdLineOption *option = new wxCmdLineOption(wxCMD_LINE_SWITCH, | |
331 | shortName, longName, desc, | |
332 | wxCMD_LINE_VAL_NONE, flags); | |
333 | ||
334 | m_data->m_options.Add(option); | |
335 | } | |
336 | ||
337 | void wxCmdLineParser::AddOption(const wxString& shortName, | |
338 | const wxString& longName, | |
339 | const wxString& desc, | |
340 | wxCmdLineParamType type, | |
341 | int flags) | |
342 | { | |
343 | wxASSERT_MSG( m_data->FindOption(shortName) == wxNOT_FOUND, | |
344 | _T("duplicate option") ); | |
345 | ||
346 | wxCmdLineOption *option = new wxCmdLineOption(wxCMD_LINE_OPTION, | |
347 | shortName, longName, desc, | |
348 | type, flags); | |
349 | ||
350 | m_data->m_options.Add(option); | |
351 | } | |
352 | ||
353 | void wxCmdLineParser::AddParam(const wxString& desc, | |
354 | wxCmdLineParamType type, | |
355 | int flags) | |
356 | { | |
357 | // do some consistency checks: a required parameter can't follow an | |
358 | // optional one and nothing should follow a parameter with MULTIPLE flag | |
359 | #ifdef __WXDEBUG__ | |
360 | if ( !m_data->m_paramDesc.IsEmpty() ) | |
361 | { | |
362 | wxCmdLineParam& param = m_data->m_paramDesc.Last(); | |
363 | ||
364 | wxASSERT_MSG( !(param.flags & wxCMD_LINE_PARAM_MULTIPLE), | |
365 | _T("all parameters after the one with wxCMD_LINE_PARAM_MULTIPLE style will be ignored") ); | |
366 | ||
367 | if ( !(flags & wxCMD_LINE_PARAM_OPTIONAL) ) | |
368 | { | |
369 | wxASSERT_MSG( !(param.flags & wxCMD_LINE_PARAM_OPTIONAL), | |
370 | _T("a required parameter can't follow an optional one") ); | |
371 | } | |
372 | } | |
373 | #endif // Debug | |
374 | ||
375 | wxCmdLineParam *param = new wxCmdLineParam(desc, type, flags); | |
376 | ||
377 | m_data->m_paramDesc.Add(param); | |
378 | } | |
379 | ||
380 | // ---------------------------------------------------------------------------- | |
381 | // access to parse command line | |
382 | // ---------------------------------------------------------------------------- | |
383 | ||
384 | bool wxCmdLineParser::Found(const wxString& name) const | |
385 | { | |
386 | int i = m_data->FindOption(name); | |
387 | if ( i == wxNOT_FOUND ) | |
388 | i = m_data->FindOptionByLongName(name); | |
389 | ||
390 | wxCHECK_MSG( i != wxNOT_FOUND, FALSE, _T("unknown switch") ); | |
391 | ||
392 | wxCmdLineOption& opt = m_data->m_options[(size_t)i]; | |
393 | if ( !opt.HasValue() ) | |
394 | return FALSE; | |
395 | ||
396 | return TRUE; | |
397 | } | |
398 | ||
399 | bool wxCmdLineParser::Found(const wxString& name, wxString *value) const | |
400 | { | |
401 | int i = m_data->FindOption(name); | |
402 | if ( i == wxNOT_FOUND ) | |
403 | i = m_data->FindOptionByLongName(name); | |
404 | ||
405 | wxCHECK_MSG( i != wxNOT_FOUND, FALSE, _T("unknown option") ); | |
406 | ||
407 | wxCmdLineOption& opt = m_data->m_options[(size_t)i]; | |
408 | if ( !opt.HasValue() ) | |
409 | return FALSE; | |
410 | ||
411 | wxCHECK_MSG( value, FALSE, _T("NULL pointer in wxCmdLineOption::Found") ); | |
412 | ||
413 | *value = opt.GetStrVal(); | |
414 | ||
415 | return TRUE; | |
416 | } | |
417 | ||
418 | bool wxCmdLineParser::Found(const wxString& name, long *value) const | |
419 | { | |
420 | int i = m_data->FindOption(name); | |
421 | if ( i == wxNOT_FOUND ) | |
422 | i = m_data->FindOptionByLongName(name); | |
423 | ||
424 | wxCHECK_MSG( i != wxNOT_FOUND, FALSE, _T("unknown option") ); | |
425 | ||
426 | wxCmdLineOption& opt = m_data->m_options[(size_t)i]; | |
427 | if ( !opt.HasValue() ) | |
428 | return FALSE; | |
429 | ||
430 | wxCHECK_MSG( value, FALSE, _T("NULL pointer in wxCmdLineOption::Found") ); | |
431 | ||
432 | *value = opt.GetLongVal(); | |
433 | ||
434 | return TRUE; | |
435 | } | |
436 | ||
437 | bool wxCmdLineParser::Found(const wxString& name, wxDateTime *value) const | |
438 | { | |
439 | int i = m_data->FindOption(name); | |
440 | if ( i == wxNOT_FOUND ) | |
441 | i = m_data->FindOptionByLongName(name); | |
442 | ||
443 | wxCHECK_MSG( i != wxNOT_FOUND, FALSE, _T("unknown option") ); | |
444 | ||
445 | wxCmdLineOption& opt = m_data->m_options[(size_t)i]; | |
446 | if ( !opt.HasValue() ) | |
447 | return FALSE; | |
448 | ||
449 | wxCHECK_MSG( value, FALSE, _T("NULL pointer in wxCmdLineOption::Found") ); | |
450 | ||
451 | *value = opt.GetDateVal(); | |
452 | ||
453 | return TRUE; | |
454 | } | |
455 | ||
456 | size_t wxCmdLineParser::GetParamCount() const | |
457 | { | |
458 | return m_data->m_parameters.GetCount(); | |
459 | } | |
460 | ||
461 | wxString wxCmdLineParser::GetParam(size_t n) const | |
462 | { | |
463 | return m_data->m_parameters[n]; | |
464 | } | |
465 | ||
466 | // Resets switches and options | |
467 | void wxCmdLineParser::Reset() | |
468 | { | |
469 | for ( size_t i = 0; i < m_data->m_options.Count(); i++ ) | |
470 | { | |
471 | wxCmdLineOption& opt = m_data->m_options[i]; | |
472 | opt.SetHasValue(FALSE); | |
473 | } | |
474 | } | |
475 | ||
476 | ||
477 | // ---------------------------------------------------------------------------- | |
478 | // the real work is done here | |
479 | // ---------------------------------------------------------------------------- | |
480 | ||
481 | int wxCmdLineParser::Parse(bool showUsage) | |
482 | { | |
483 | bool maybeOption = TRUE; // can the following arg be an option? | |
484 | bool ok = TRUE; // TRUE until an error is detected | |
485 | bool helpRequested = FALSE; // TRUE if "-h" was given | |
486 | bool hadRepeatableParam = FALSE; // TRUE if found param with MULTIPLE flag | |
487 | ||
488 | size_t currentParam = 0; // the index in m_paramDesc | |
489 | ||
490 | size_t countParam = m_data->m_paramDesc.GetCount(); | |
491 | ||
492 | Reset(); | |
493 | ||
494 | // parse everything | |
495 | wxString arg; | |
496 | size_t count = m_data->m_arguments.GetCount(); | |
497 | for ( size_t n = 1; ok && (n < count); n++ ) // 0 is program name | |
498 | { | |
499 | arg = m_data->m_arguments[n]; | |
500 | ||
501 | // special case: "--" should be discarded and all following arguments | |
502 | // should be considered as parameters, even if they start with '-' and | |
503 | // not like options (this is POSIX-like) | |
504 | if ( arg == _T("--") ) | |
505 | { | |
506 | maybeOption = FALSE; | |
507 | ||
508 | continue; | |
509 | } | |
510 | ||
511 | // empty argument or just '-' is not an option but a parameter | |
512 | if ( maybeOption && arg.length() > 1 && | |
513 | wxStrchr(m_data->m_switchChars, arg[0u]) ) | |
514 | { | |
515 | bool isLong; | |
516 | wxString name; | |
517 | int optInd = wxNOT_FOUND; // init to suppress warnings | |
518 | ||
519 | // an option or a switch: find whether it's a long or a short one | |
520 | if ( m_data->m_enableLongOptions && | |
521 | arg[0u] == _T('-') && arg[1u] == _T('-') ) | |
522 | { | |
523 | // a long one | |
524 | isLong = TRUE; | |
525 | ||
526 | const wxChar *p = arg.c_str() + 2; | |
527 | while ( wxIsalnum(*p) || (*p == _T('_')) || (*p == _T('-')) ) | |
528 | { | |
529 | name += *p++; | |
530 | } | |
531 | ||
532 | optInd = m_data->FindOptionByLongName(name); | |
533 | if ( optInd == wxNOT_FOUND ) | |
534 | { | |
535 | wxLogError(_("Unknown long option '%s'"), name.c_str()); | |
536 | } | |
537 | } | |
538 | else | |
539 | { | |
540 | isLong = FALSE; | |
541 | ||
542 | // a short one: as they can be cumulated, we try to find the | |
543 | // longest substring which is a valid option | |
544 | const wxChar *p = arg.c_str() + 1; | |
545 | while ( wxIsalnum(*p) || (*p == _T('_')) ) | |
546 | { | |
547 | name += *p++; | |
548 | } | |
549 | ||
550 | size_t len = name.length(); | |
551 | do | |
552 | { | |
553 | if ( len == 0 ) | |
554 | { | |
555 | // we couldn't find a valid option name in the | |
556 | // beginning of this string | |
557 | wxLogError(_("Unknown option '%s'"), name.c_str()); | |
558 | ||
559 | break; | |
560 | } | |
561 | else | |
562 | { | |
563 | optInd = m_data->FindOption(name.Left(len)); | |
564 | ||
565 | // will try with one character less the next time | |
566 | len--; | |
567 | } | |
568 | } | |
569 | while ( optInd == wxNOT_FOUND ); | |
570 | ||
571 | len++; // compensates extra len-- above | |
572 | if ( (optInd != wxNOT_FOUND) && (len != name.length()) ) | |
573 | { | |
574 | // first of all, the option name is only part of this | |
575 | // string | |
576 | name = name.Left(len); | |
577 | ||
578 | // our option is only part of this argument, there is | |
579 | // something else in it - it is either the value of this | |
580 | // option or other switches if it is a switch | |
581 | if ( m_data->m_options[(size_t)optInd].kind | |
582 | == wxCMD_LINE_SWITCH ) | |
583 | { | |
584 | // pretend that all the rest of the argument is the | |
585 | // next argument, in fact | |
586 | wxString arg2 = arg[0u]; | |
587 | arg2 += arg.Mid(len + 1); // +1 for leading '-' | |
588 | ||
589 | m_data->m_arguments.Insert(arg2, n + 1); | |
590 | count++; | |
591 | } | |
592 | //else: it's our value, we'll deal with it below | |
593 | } | |
594 | } | |
595 | ||
596 | if ( optInd == wxNOT_FOUND ) | |
597 | { | |
598 | ok = FALSE; | |
599 | ||
600 | continue; // will break, in fact | |
601 | } | |
602 | ||
603 | wxCmdLineOption& opt = m_data->m_options[(size_t)optInd]; | |
604 | if ( opt.kind == wxCMD_LINE_SWITCH ) | |
605 | { | |
606 | // nothing more to do | |
607 | opt.SetHasValue(); | |
608 | ||
609 | if ( opt.flags & wxCMD_LINE_OPTION_HELP ) | |
610 | { | |
611 | helpRequested = TRUE; | |
612 | ||
613 | // it's not an error, but we still stop here | |
614 | ok = FALSE; | |
615 | } | |
616 | } | |
617 | else | |
618 | { | |
619 | // get the value | |
620 | ||
621 | // +1 for leading '-' | |
622 | const wxChar *p = arg.c_str() + 1 + name.length(); | |
623 | if ( isLong ) | |
624 | { | |
625 | p++; // for another leading '-' | |
626 | ||
627 | if ( *p++ != _T('=') ) | |
628 | { | |
629 | wxLogError(_("Option '%s' requires a value, '=' expected."), name.c_str()); | |
630 | ||
631 | ok = FALSE; | |
632 | } | |
633 | } | |
634 | else | |
635 | { | |
636 | switch ( *p ) | |
637 | { | |
638 | case _T('='): | |
639 | case _T(':'): | |
640 | // the value follows | |
641 | p++; | |
642 | break; | |
643 | ||
644 | case 0: | |
645 | // the value is in the next argument | |
646 | if ( ++n == count ) | |
647 | { | |
648 | // ... but there is none | |
649 | wxLogError(_("Option '%s' requires a value."), | |
650 | name.c_str()); | |
651 | ||
652 | ok = FALSE; | |
653 | } | |
654 | else | |
655 | { | |
656 | // ... take it from there | |
657 | p = m_data->m_arguments[n].c_str(); | |
658 | } | |
659 | break; | |
660 | ||
661 | default: | |
662 | // the value is right here: this may be legal or | |
663 | // not depending on the option style | |
664 | if ( opt.flags & wxCMD_LINE_NEEDS_SEPARATOR ) | |
665 | { | |
666 | wxLogError(_("Separator expected after the option '%s'."), | |
667 | name.c_str()); | |
668 | ||
669 | ok = FALSE; | |
670 | } | |
671 | } | |
672 | } | |
673 | ||
674 | if ( ok ) | |
675 | { | |
676 | wxString value = p; | |
677 | switch ( opt.type ) | |
678 | { | |
679 | default: | |
680 | wxFAIL_MSG( _T("unknown option type") ); | |
681 | // still fall through | |
682 | ||
683 | case wxCMD_LINE_VAL_STRING: | |
684 | opt.SetStrVal(value); | |
685 | break; | |
686 | ||
687 | case wxCMD_LINE_VAL_NUMBER: | |
688 | { | |
689 | long val; | |
690 | if ( value.ToLong(&val) ) | |
691 | { | |
692 | opt.SetLongVal(val); | |
693 | } | |
694 | else | |
695 | { | |
696 | wxLogError(_("'%s' is not a correct numeric value for option '%s'."), | |
697 | value.c_str(), name.c_str()); | |
698 | ||
699 | ok = FALSE; | |
700 | } | |
701 | } | |
702 | break; | |
703 | ||
704 | case wxCMD_LINE_VAL_DATE: | |
705 | { | |
706 | wxDateTime dt; | |
707 | const wxChar *res = dt.ParseDate(value); | |
708 | if ( !res || *res ) | |
709 | { | |
710 | wxLogError(_("Option '%s': '%s' cannot be converted to a date."), | |
711 | name.c_str(), value.c_str()); | |
712 | ||
713 | ok = FALSE; | |
714 | } | |
715 | else | |
716 | { | |
717 | opt.SetDateVal(dt); | |
718 | } | |
719 | } | |
720 | break; | |
721 | } | |
722 | } | |
723 | } | |
724 | } | |
725 | else | |
726 | { | |
727 | // a parameter | |
728 | if ( currentParam < countParam ) | |
729 | { | |
730 | wxCmdLineParam& param = m_data->m_paramDesc[currentParam]; | |
731 | ||
732 | // TODO check the param type | |
733 | ||
734 | m_data->m_parameters.Add(arg); | |
735 | ||
736 | if ( !(param.flags & wxCMD_LINE_PARAM_MULTIPLE) ) | |
737 | { | |
738 | currentParam++; | |
739 | } | |
740 | else | |
741 | { | |
742 | wxASSERT_MSG( currentParam == countParam - 1, | |
743 | _T("all parameters after the one with wxCMD_LINE_PARAM_MULTIPLE style are ignored") ); | |
744 | ||
745 | // remember that we did have this last repeatable parameter | |
746 | hadRepeatableParam = TRUE; | |
747 | } | |
748 | } | |
749 | else | |
750 | { | |
751 | wxLogError(_("Unexpected parameter '%s'"), arg.c_str()); | |
752 | ||
753 | ok = FALSE; | |
754 | } | |
755 | } | |
756 | } | |
757 | ||
758 | // verify that all mandatory options were given | |
759 | if ( ok ) | |
760 | { | |
761 | size_t countOpt = m_data->m_options.GetCount(); | |
762 | for ( size_t n = 0; ok && (n < countOpt); n++ ) | |
763 | { | |
764 | wxCmdLineOption& opt = m_data->m_options[n]; | |
765 | if ( (opt.flags & wxCMD_LINE_OPTION_MANDATORY) && !opt.HasValue() ) | |
766 | { | |
767 | wxString optName; | |
768 | if ( !opt.longName ) | |
769 | { | |
770 | optName = opt.shortName; | |
771 | } | |
772 | else | |
773 | { | |
774 | optName.Printf(_("%s (or %s)"), | |
775 | opt.shortName.c_str(), | |
776 | opt.longName.c_str()); | |
777 | } | |
778 | ||
779 | wxLogError(_("The value for the option '%s' must be specified."), | |
780 | optName.c_str()); | |
781 | ||
782 | ok = FALSE; | |
783 | } | |
784 | } | |
785 | ||
786 | for ( ; ok && (currentParam < countParam); currentParam++ ) | |
787 | { | |
788 | wxCmdLineParam& param = m_data->m_paramDesc[currentParam]; | |
789 | if ( (currentParam == countParam - 1) && | |
790 | (param.flags & wxCMD_LINE_PARAM_MULTIPLE) && | |
791 | hadRepeatableParam ) | |
792 | { | |
793 | // special case: currentParam wasn't incremented, but we did | |
794 | // have it, so don't give error | |
795 | continue; | |
796 | } | |
797 | ||
798 | if ( !(param.flags & wxCMD_LINE_PARAM_OPTIONAL) ) | |
799 | { | |
800 | wxLogError(_("The required parameter '%s' was not specified."), | |
801 | param.description.c_str()); | |
802 | ||
803 | ok = FALSE; | |
804 | } | |
805 | } | |
806 | } | |
807 | ||
808 | if ( !ok && showUsage ) | |
809 | { | |
810 | Usage(); | |
811 | } | |
812 | ||
813 | return ok ? 0 : helpRequested ? -1 : 1; | |
814 | } | |
815 | ||
816 | // ---------------------------------------------------------------------------- | |
817 | // give the usage message | |
818 | // ---------------------------------------------------------------------------- | |
819 | ||
820 | void wxCmdLineParser::Usage() | |
821 | { | |
822 | wxString appname = wxTheApp->GetAppName(); | |
823 | if ( !appname ) | |
824 | { | |
825 | wxCHECK_RET( !m_data->m_arguments.IsEmpty(), _T("no program name") ); | |
826 | ||
827 | appname = wxFileNameFromPath(m_data->m_arguments[0]); | |
828 | wxStripExtension(appname); | |
829 | } | |
830 | ||
831 | // we construct the brief cmd line desc on the fly, but not the detailed | |
832 | // help message below because we want to align the options descriptions | |
833 | // and for this we must first know the longest one of them | |
834 | wxString brief; | |
835 | wxArrayString namesOptions, descOptions; | |
836 | brief.Printf(_("Usage: %s"), appname.c_str()); | |
837 | ||
838 | // the switch char is usually '-' but this can be changed with | |
839 | // SetSwitchChars() and then the first one of possible chars is used | |
840 | wxChar chSwitch = !m_data->m_switchChars ? _T('-') | |
841 | : m_data->m_switchChars[0u]; | |
842 | ||
843 | size_t n, count = m_data->m_options.GetCount(); | |
844 | for ( n = 0; n < count; n++ ) | |
845 | { | |
846 | wxCmdLineOption& opt = m_data->m_options[n]; | |
847 | ||
848 | brief << _T(' '); | |
849 | if ( !(opt.flags & wxCMD_LINE_OPTION_MANDATORY) ) | |
850 | { | |
851 | brief << _T('['); | |
852 | } | |
853 | ||
854 | if ( !opt.shortName.empty() ) | |
855 | { | |
856 | brief << chSwitch << opt.shortName; | |
857 | } | |
858 | else if ( !opt.longName.empty() ) | |
859 | { | |
860 | brief << _T("--") << opt.longName; | |
861 | } | |
862 | else | |
863 | { | |
864 | wxFAIL_MSG( _T("option without neither short nor long name?") ); | |
865 | } | |
866 | ||
867 | wxString option; | |
868 | ||
869 | if ( !opt.shortName.empty() ) | |
870 | { | |
871 | option << _T(" ") << chSwitch << opt.shortName; | |
872 | } | |
873 | ||
874 | if ( !opt.longName.empty() ) | |
875 | { | |
876 | option << (option.empty() ? _T(" ") : _T(", ")) | |
877 | << _T("--") << opt.longName; | |
878 | } | |
879 | ||
880 | if ( opt.kind != wxCMD_LINE_SWITCH ) | |
881 | { | |
882 | wxString val; | |
883 | val << _T('<') << GetTypeName(opt.type) << _T('>'); | |
884 | brief << _T(' ') << val; | |
885 | option << (!opt.longName ? _T(':') : _T('=')) << val; | |
886 | } | |
887 | ||
888 | if ( !(opt.flags & wxCMD_LINE_OPTION_MANDATORY) ) | |
889 | { | |
890 | brief << _T(']'); | |
891 | } | |
892 | ||
893 | namesOptions.Add(option); | |
894 | descOptions.Add(opt.description); | |
895 | } | |
896 | ||
897 | count = m_data->m_paramDesc.GetCount(); | |
898 | for ( n = 0; n < count; n++ ) | |
899 | { | |
900 | wxCmdLineParam& param = m_data->m_paramDesc[n]; | |
901 | ||
902 | brief << _T(' '); | |
903 | if ( param.flags & wxCMD_LINE_PARAM_OPTIONAL ) | |
904 | { | |
905 | brief << _T('['); | |
906 | } | |
907 | ||
908 | brief << param.description; | |
909 | ||
910 | if ( param.flags & wxCMD_LINE_PARAM_MULTIPLE ) | |
911 | { | |
912 | brief << _T("..."); | |
913 | } | |
914 | ||
915 | if ( param.flags & wxCMD_LINE_PARAM_OPTIONAL ) | |
916 | { | |
917 | brief << _T(']'); | |
918 | } | |
919 | } | |
920 | ||
921 | if ( !!m_data->m_logo ) | |
922 | { | |
923 | wxLogMessage(m_data->m_logo); | |
924 | } | |
925 | ||
926 | // in console mode we want to show the brief usage message first, then the | |
927 | // detailed one but in GUI build we give the details first and then the | |
928 | // summary - like this, the brief message appears in the wxLogGui dialog, | |
929 | // as expected | |
930 | #if !wxUSE_GUI | |
931 | wxLogMessage(brief); | |
932 | #endif // !wxUSE_GUI | |
933 | ||
934 | // now construct the detailed help message | |
935 | size_t len, lenMax = 0; | |
936 | count = namesOptions.GetCount(); | |
937 | for ( n = 0; n < count; n++ ) | |
938 | { | |
939 | len = namesOptions[n].length(); | |
940 | if ( len > lenMax ) | |
941 | lenMax = len; | |
942 | } | |
943 | ||
944 | wxString detailed; | |
945 | for ( n = 0; n < count; n++ ) | |
946 | { | |
947 | len = namesOptions[n].length(); | |
948 | detailed << namesOptions[n] | |
949 | << wxString(_T(' '), lenMax - len) << _T('\t') | |
950 | << descOptions[n] | |
951 | << _T('\n'); | |
952 | } | |
953 | ||
954 | wxLogMessage(detailed); | |
955 | ||
956 | // do it now if not done above | |
957 | #if wxUSE_GUI | |
958 | wxLogMessage(brief); | |
959 | #endif // wxUSE_GUI | |
960 | } | |
961 | ||
962 | // ---------------------------------------------------------------------------- | |
963 | // private functions | |
964 | // ---------------------------------------------------------------------------- | |
965 | ||
966 | static wxString GetTypeName(wxCmdLineParamType type) | |
967 | { | |
968 | wxString s; | |
969 | switch ( type ) | |
970 | { | |
971 | default: | |
972 | wxFAIL_MSG( _T("unknown option type") ); | |
973 | // still fall through | |
974 | ||
975 | case wxCMD_LINE_VAL_STRING: s = _("str"); break; | |
976 | case wxCMD_LINE_VAL_NUMBER: s = _("num"); break; | |
977 | case wxCMD_LINE_VAL_DATE: s = _("date"); break; | |
978 | } | |
979 | ||
980 | return s; | |
981 | } | |
982 | ||
983 | #endif // wxUSE_CMDLINE_PARSER | |
984 | ||
985 | // ---------------------------------------------------------------------------- | |
986 | // global functions | |
987 | // ---------------------------------------------------------------------------- | |
988 | ||
989 | /* static */ | |
990 | wxArrayString wxCmdLineParser::ConvertStringToArgs(const wxChar *p) | |
991 | { | |
992 | wxArrayString args; | |
993 | ||
994 | wxString arg; | |
995 | arg.reserve(1024); | |
996 | ||
997 | bool isInsideQuotes = FALSE; | |
998 | for ( ;; ) | |
999 | { | |
1000 | // skip white space | |
1001 | while ( *p == _T(' ') || *p == _T('\t') ) | |
1002 | p++; | |
1003 | ||
1004 | // anything left? | |
1005 | if ( *p == _T('\0') ) | |
1006 | break; | |
1007 | ||
1008 | // parse this parameter | |
1009 | arg.clear(); | |
1010 | for ( ;; p++ ) | |
1011 | { | |
1012 | // do we have a (lone) backslash? | |
1013 | bool isQuotedByBS = FALSE; | |
1014 | while ( *p == _T('\\') ) | |
1015 | { | |
1016 | p++; | |
1017 | ||
1018 | // if we have 2 backslashes in a row, output one | |
1019 | if ( isQuotedByBS ) | |
1020 | { | |
1021 | arg += _T('\\'); | |
1022 | isQuotedByBS = FALSE; | |
1023 | } | |
1024 | else // the next char is quoted | |
1025 | { | |
1026 | isQuotedByBS = TRUE; | |
1027 | } | |
1028 | } | |
1029 | ||
1030 | bool skipChar = FALSE, | |
1031 | endParam = FALSE; | |
1032 | switch ( *p ) | |
1033 | { | |
1034 | case _T('"'): | |
1035 | if ( !isQuotedByBS ) | |
1036 | { | |
1037 | // don't put the quote itself in the arg | |
1038 | skipChar = TRUE; | |
1039 | ||
1040 | isInsideQuotes = !isInsideQuotes; | |
1041 | } | |
1042 | //else: insert a literal quote | |
1043 | ||
1044 | break; | |
1045 | ||
1046 | case _T(' '): | |
1047 | case _T('\t'): | |
1048 | if ( isInsideQuotes || isQuotedByBS ) | |
1049 | { | |
1050 | // preserve it, skip endParam below | |
1051 | break; | |
1052 | } | |
1053 | //else: fall through | |
1054 | ||
1055 | case _T('\0'): | |
1056 | endParam = TRUE; | |
1057 | break; | |
1058 | ||
1059 | default: | |
1060 | if ( isQuotedByBS ) | |
1061 | { | |
1062 | // ignore backslash before an ordinary character - this | |
1063 | // is needed to properly handle the file names under | |
1064 | // Windows appearing in the command line | |
1065 | arg += _T('\\'); | |
1066 | } | |
1067 | } | |
1068 | ||
1069 | // end of argument? | |
1070 | if ( endParam ) | |
1071 | break; | |
1072 | ||
1073 | // otherwise copy this char to arg | |
1074 | if ( !skipChar ) | |
1075 | { | |
1076 | arg += *p; | |
1077 | } | |
1078 | } | |
1079 | ||
1080 | args.Add(arg); | |
1081 | } | |
1082 | ||
1083 | return args; | |
1084 | } | |
1085 |