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