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