projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added wxMessageOutput as per the discussion on wx-dev.
[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 )
846 {
847 wxString usage;
848 wxMessageOutput* msgOut = wxMessageOutput::Get();
849 if ( showUsage ) usage = GetUsageString();
850 if ( msgOut )
851 msgOut->Printf( wxT("%s%s"), usage.c_str(), errorMsg.c_str() );
852 }
853
854 return ok ? 0 : helpRequested ? -1 : 1;
855 }
856
857 // ----------------------------------------------------------------------------
858 // give the usage message
859 // ----------------------------------------------------------------------------
860
861 void wxCmdLineParser::Usage()
862 {
863 wxString usage = GetUsageString();
864 wxMessageOutput* msgOut = wxMessageOutput::Get();
865 if ( msgOut )
866 msgOut->Printf( wxT("%s"), usage.c_str() );
867 }
868
869 wxString wxCmdLineParser::GetUsageString()
870 {
871 wxString appname = wxTheApp->GetAppName();
872 if ( !appname )
873 {
874 wxCHECK_MSG( !m_data->m_arguments.IsEmpty(), wxEmptyString,
875 _T("no program name") );
876
877 appname = wxFileNameFromPath(m_data->m_arguments[0]);
878 wxStripExtension(appname);
879 }
880
881 // we construct the brief cmd line desc on the fly, but not the detailed
882 // help message below because we want to align the options descriptions
883 // and for this we must first know the longest one of them
884 wxString usage;
885 wxArrayString namesOptions, descOptions;
886
887 if ( !!m_data->m_logo )
888 {
889 usage << m_data->m_logo << _T('\n');
890 }
891
892 usage << wxString::Format(_("Usage: %s"), appname.c_str());
893
894 // the switch char is usually '-' but this can be changed with
895 // SetSwitchChars() and then the first one of possible chars is used
896 wxChar chSwitch = !m_data->m_switchChars ? _T('-')
897 : m_data->m_switchChars[0u];
898
899 bool areLongOptionsEnabled = AreLongOptionsEnabled();
900 size_t n, count = m_data->m_options.GetCount();
901 for ( n = 0; n < count; n++ )
902 {
903 wxCmdLineOption& opt = m_data->m_options[n];
904
905 usage << _T(' ');
906 if ( !(opt.flags & wxCMD_LINE_OPTION_MANDATORY) )
907 {
908 usage << _T('[');
909 }
910
911 if ( !opt.shortName.empty() )
912 {
913 usage << chSwitch << opt.shortName;
914 }
915 else if ( areLongOptionsEnabled && !opt.longName.empty() )
916 {
917 usage << _T("--") << opt.longName;
918 }
919 else
920 {
921 if (!opt.longName.empty())
922 {
923 wxFAIL_MSG( wxT("option with only a long name while long ")
924 wxT("options are disabled") );
925 }
926 else
927 {
928 wxFAIL_MSG( _T("option without neither short nor long name") );
929 }
930 }
931
932 wxString option;
933
934 if ( !opt.shortName.empty() )
935 {
936 option << _T(" ") << chSwitch << opt.shortName;
937 }
938
939 if ( areLongOptionsEnabled && !opt.longName.empty() )
940 {
941 option << (option.empty() ? _T(" ") : _T(", "))
942 << _T("--") << opt.longName;
943 }
944
945 if ( opt.kind != wxCMD_LINE_SWITCH )
946 {
947 wxString val;
948 val << _T('<') << GetTypeName(opt.type) << _T('>');
949 usage << _T(' ') << val;
950 option << (!opt.longName ? _T(':') : _T('=')) << val;
951 }
952
953 if ( !(opt.flags & wxCMD_LINE_OPTION_MANDATORY) )
954 {
955 usage << _T(']');
956 }
957
958 namesOptions.Add(option);
959 descOptions.Add(opt.description);
960 }
961
962 count = m_data->m_paramDesc.GetCount();
963 for ( n = 0; n < count; n++ )
964 {
965 wxCmdLineParam& param = m_data->m_paramDesc[n];
966
967 usage << _T(' ');
968 if ( param.flags & wxCMD_LINE_PARAM_OPTIONAL )
969 {
970 usage << _T('[');
971 }
972
973 usage << param.description;
974
975 if ( param.flags & wxCMD_LINE_PARAM_MULTIPLE )
976 {
977 usage << _T("...");
978 }
979
980 if ( param.flags & wxCMD_LINE_PARAM_OPTIONAL )
981 {
982 usage << _T(']');
983 }
984 }
985
986 usage << _T('\n');
987
988 // now construct the detailed help message
989 size_t len, lenMax = 0;
990 count = namesOptions.GetCount();
991 for ( n = 0; n < count; n++ )
992 {
993 len = namesOptions[n].length();
994 if ( len > lenMax )
995 lenMax = len;
996 }
997
998 for ( n = 0; n < count; n++ )
999 {
1000 len = namesOptions[n].length();
1001 usage << namesOptions[n]
1002 << wxString(_T(' '), lenMax - len) << _T('\t')
1003 << descOptions[n]
1004 << _T('\n');
1005 }
1006
1007 return usage;
1008 }
1009
1010 // ----------------------------------------------------------------------------
1011 // private functions
1012 // ----------------------------------------------------------------------------
1013
1014 static wxString GetTypeName(wxCmdLineParamType type)
1015 {
1016 wxString s;
1017 switch ( type )
1018 {
1019 default:
1020 wxFAIL_MSG( _T("unknown option type") );
1021 // still fall through
1022
1023 case wxCMD_LINE_VAL_STRING: s = _("str"); break;
1024 case wxCMD_LINE_VAL_NUMBER: s = _("num"); break;
1025 case wxCMD_LINE_VAL_DATE: s = _("date"); break;
1026 }
1027
1028 return s;
1029 }
1030
1031 /*
1032 Returns a string which is equal to the string pointed to by p, but up to the
1033 point where p contains an character that's not allowed.
1034 Allowable characters are letters and numbers, and characters pointed to by
1035 the parameter allowedChars.
1036
1037 For example, if p points to "abcde-@-_", and allowedChars is "-_",
1038 this function returns "abcde-".
1039 */
1040 static wxString GetOptionName(const wxChar *p,
1041 const wxChar *allowedChars)
1042 {
1043 wxString argName;
1044
1045 while ( *p && (wxIsalnum(*p) || wxStrchr(allowedChars, *p)) )
1046 {
1047 argName += *p++;
1048 }
1049
1050 return argName;
1051 }
1052
1053 // Besides alphanumeric characters, short and long options can
1054 // have other characters.
1055
1056 // A short option additionally can have these
1057 #define wxCMD_LINE_CHARS_ALLOWED_BY_SHORT_OPTION wxT("_?")
1058
1059 // A long option can have the same characters as a short option and a '-'.
1060 #define wxCMD_LINE_CHARS_ALLOWED_BY_LONG_OPTION \
1061 wxCMD_LINE_CHARS_ALLOWED_BY_SHORT_OPTION wxT("-")
1062
1063 static wxString GetShortOptionName(const wxChar *p)
1064 {
1065 return GetOptionName(p, wxCMD_LINE_CHARS_ALLOWED_BY_SHORT_OPTION);
1066 }
1067
1068 static wxString GetLongOptionName(const wxChar *p)
1069 {
1070 return GetOptionName(p, wxCMD_LINE_CHARS_ALLOWED_BY_LONG_OPTION);
1071 }
1072
1073 #endif // wxUSE_CMDLINE_PARSER
1074
1075 // ----------------------------------------------------------------------------
1076 // global functions
1077 // ----------------------------------------------------------------------------
1078
1079 /*
1080 This function is mainly used under Windows (as under Unix we always get the
1081 command line arguments as argc/argv anyhow) and so it tries to handle the
1082 Windows path names (separated by backslashes) correctly. For this it only
1083 considers that a backslash may be used to escape another backslash (but
1084 normally this is _not_ needed) or a quote but nothing else.
1085
1086 In particular, to pass a single argument containing a space to the program
1087 it should be quoted:
1088
1089 myprog.exe foo bar -> argc = 3, argv[1] = "foo", argv[2] = "bar"
1090 myprog.exe "foo bar" -> argc = 2, argv[1] = "foo bar"
1091
1092 To pass an argument containing spaces and quotes, the latter should be
1093 escaped with a backslash:
1094
1095 myprog.exe "foo \"bar\"" -> argc = 2, argv[1] = "foo "bar""
1096
1097 This hopefully matches the conventions used by Explorer/command line
1098 interpreter under Windows. If not, this function should be fixed.
1099 */
1100
1101 /* static */
1102 wxArrayString wxCmdLineParser::ConvertStringToArgs(const wxChar *p)
1103 {
1104 wxArrayString args;
1105
1106 wxString arg;
1107 arg.reserve(1024);
1108
1109 bool isInsideQuotes = FALSE;
1110 for ( ;; )
1111 {
1112 // skip white space
1113 while ( *p == _T(' ') || *p == _T('\t') )
1114 p++;
1115
1116 // anything left?
1117 if ( *p == _T('\0') )
1118 break;
1119
1120 // parse this parameter
1121 arg.clear();
1122 for ( ;; p++ )
1123 {
1124 // do we have a (lone) backslash?
1125 bool isQuotedByBS = FALSE;
1126 while ( *p == _T('\\') )
1127 {
1128 p++;
1129
1130 // if we have 2 backslashes in a row, output one
1131 // unless it looks like a UNC path \\machine\dir\file.ext
1132 if ( isQuotedByBS || arg.Len() == 0 )
1133 {
1134 arg += _T('\\');
1135 isQuotedByBS = FALSE;
1136 }
1137 else // the next char is quoted
1138 {
1139 isQuotedByBS = TRUE;
1140 }
1141 }
1142
1143 bool skipChar = FALSE,
1144 endParam = FALSE;
1145 switch ( *p )
1146 {
1147 case _T('"'):
1148 if ( !isQuotedByBS )
1149 {
1150 // don't put the quote itself in the arg
1151 skipChar = TRUE;
1152
1153 isInsideQuotes = !isInsideQuotes;
1154 }
1155 //else: insert a literal quote
1156
1157 break;
1158
1159 case _T(' '):
1160 case _T('\t'):
1161 // we intentionally don't check for preceding backslash
1162 // here as if we allowed it to be used to escape spaces the
1163 // cmd line of the form "foo.exe a:\ c:\bar" wouldn't be
1164 // parsed correctly
1165 if ( isInsideQuotes )
1166 {
1167 // preserve it, skip endParam below
1168 break;
1169 }
1170 //else: fall through
1171
1172 case _T('\0'):
1173 endParam = TRUE;
1174 break;
1175
1176 default:
1177 if ( isQuotedByBS )
1178 {
1179 // ignore backslash before an ordinary character - this
1180 // is needed to properly handle the file names under
1181 // Windows appearing in the command line
1182 arg += _T('\\');
1183 }
1184 }
1185
1186 // end of argument?
1187 if ( endParam )
1188 break;
1189
1190 // otherwise copy this char to arg
1191 if ( !skipChar )
1192 {
1193 arg += *p;
1194 }
1195 }
1196
1197 args.Add(arg);
1198 }
1199
1200 return args;
1201 }
1202
wxWidgets (Impactor)