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