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