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