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