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 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/cmdline.h"
  28
  29 #if wxUSE_CMDLINE_PARSER
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/string.h"
  33     #include "wx/log.h"
  34     #include "wx/intl.h"
  35     #include "wx/app.h"
  36     #include "wx/dynarray.h"
  37 #endif //WX_PRECOMP
  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()) << wxT("\n");
 599                     }
 600                 }
 601                 else
 602                 {
 603                     optInd = wxNOT_FOUND; // Sanity check
 604
 605                     // Print the argument including leading "--"
 606                     name.Prepend( wxT("--") );
 607                     errorMsg << wxString::Format(_("Unknown option '%s'"), name.c_str()) << wxT("\n");
 608                 }
 609
 610             }
 611             else
 612             {
 613                 isLong = false;
 614
 615                 // a short one: as they can be cumulated, we try to find the
 616                 // longest substring which is a valid option
 617                 const wxChar *p = arg.c_str() + 1;
 618
 619                 name = GetShortOptionName(p);
 620
 621                 size_t len = name.length();
 622                 do
 623                 {
 624                     if ( len == 0 )
 625                     {
 626                         // we couldn't find a valid option name in the
 627                         // beginning of this string
 628                         errorMsg << wxString::Format(_("Unknown option '%s'"), name.c_str()) << wxT("\n");
 629
 630                         break;
 631                     }
 632                     else
 633                     {
 634                         optInd = m_data->FindOption(name.Left(len));
 635
 636                         // will try with one character less the next time
 637                         len--;
 638                     }
 639                 }
 640                 while ( optInd == wxNOT_FOUND );
 641
 642                 len++;  // compensates extra len-- above
 643                 if ( (optInd != wxNOT_FOUND) && (len != name.length()) )
 644                 {
 645                     // first of all, the option name is only part of this
 646                     // string
 647                     name = name.Left(len);
 648
 649                     // our option is only part of this argument, there is
 650                     // something else in it - it is either the value of this
 651                     // option or other switches if it is a switch
 652                     if ( m_data->m_options[(size_t)optInd].kind
 653                             == wxCMD_LINE_SWITCH )
 654                     {
 655                         // pretend that all the rest of the argument is the
 656                         // next argument, in fact
 657                         wxString arg2 = arg[0u];
 658                         arg2 += arg.Mid(len + 1); // +1 for leading '-'
 659
 660                         m_data->m_arguments.insert
 661                             (m_data->m_arguments.begin() + n + 1, arg2);
 662                         count++;
 663                     }
 664                     //else: it's our value, we'll deal with it below
 665                 }
 666             }
 667
 668             if ( optInd == wxNOT_FOUND )
 669             {
 670                 ok = false;
 671
 672                 continue;   // will break, in fact
 673             }
 674
 675             wxCmdLineOption& opt = m_data->m_options[(size_t)optInd];
 676             if ( opt.kind == wxCMD_LINE_SWITCH )
 677             {
 678                 // nothing more to do
 679                 opt.SetHasValue();
 680
 681                 if ( opt.flags & wxCMD_LINE_OPTION_HELP )
 682                 {
 683                     helpRequested = true;
 684
 685                     // it's not an error, but we still stop here
 686                     ok = false;
 687                 }
 688             }
 689             else
 690             {
 691                 // get the value
 692
 693                 // +1 for leading '-'
 694                 const wxChar *p = arg.c_str() + 1 + name.length();
 695                 if ( isLong )
 696                 {
 697                     p++;    // for another leading '-'
 698
 699                     if ( *p++ != _T('=') )
 700                     {
 701                         errorMsg << wxString::Format(_("Option '%s' requires a value, '=' expected."), name.c_str()) << wxT("\n");
 702
 703                         ok = false;
 704                     }
 705                 }
 706                 else
 707                 {
 708                     switch ( *p )
 709                     {
 710                         case _T('='):
 711                         case _T(':'):
 712                             // the value follows
 713                             p++;
 714                             break;
 715
 716                         case 0:
 717                             // the value is in the next argument
 718                             if ( ++n == count )
 719                             {
 720                                 // ... but there is none
 721                                 errorMsg << wxString::Format(_("Option '%s' requires a value."),
 722                                                              name.c_str()) << wxT("\n");
 723
 724                                 ok = false;
 725                             }
 726                             else
 727                             {
 728                                 // ... take it from there
 729                                 p = m_data->m_arguments[n].c_str();
 730                             }
 731                             break;
 732
 733                         default:
 734                             // the value is right here: this may be legal or
 735                             // not depending on the option style
 736                             if ( opt.flags & wxCMD_LINE_NEEDS_SEPARATOR )
 737                             {
 738                                 errorMsg << wxString::Format(_("Separator expected after the option '%s'."),
 739                                                              name.c_str()) << wxT("\n");
 740
 741                                 ok = false;
 742                             }
 743                     }
 744                 }
 745
 746                 if ( ok )
 747                 {
 748                     wxString value = p;
 749                     switch ( opt.type )
 750                     {
 751                         default:
 752                             wxFAIL_MSG( _T("unknown option type") );
 753                             // still fall through
 754
 755                         case wxCMD_LINE_VAL_STRING:
 756                             opt.SetStrVal(value);
 757                             break;
 758
 759                         case wxCMD_LINE_VAL_NUMBER:
 760                             {
 761                                 long val;
 762                                 if ( value.ToLong(&val) )
 763                                 {
 764                                     opt.SetLongVal(val);
 765                                 }
 766                                 else
 767                                 {
 768                                     errorMsg << wxString::Format(_("'%s' is not a correct numeric value for option '%s'."),
 769                                                                  value.c_str(), name.c_str()) << wxT("\n");
 770
 771                                     ok = false;
 772                                 }
 773                             }
 774                             break;
 775
 776 #if wxUSE_DATETIME
 777                         case wxCMD_LINE_VAL_DATE:
 778                             {
 779                                 wxDateTime dt;
 780                                 const wxChar *res = dt.ParseDate(value);
 781                                 if ( !res || *res )
 782                                 {
 783                                     errorMsg << wxString::Format(_("Option '%s': '%s' cannot be converted to a date."),
 784                                                                  name.c_str(), value.c_str()) << wxT("\n");
 785
 786                                     ok = false;
 787                                 }
 788                                 else
 789                                 {
 790                                     opt.SetDateVal(dt);
 791                                 }
 792                             }
 793                             break;
 794 #endif // wxUSE_DATETIME
 795                     }
 796                 }
 797             }
 798         }
 799         else
 800         {
 801             // a parameter
 802             if ( currentParam < countParam )
 803             {
 804                 wxCmdLineParam& param = m_data->m_paramDesc[currentParam];
 805
 806                 // TODO check the param type
 807
 808                 m_data->m_parameters.push_back(arg);
 809
 810                 if ( !(param.flags & wxCMD_LINE_PARAM_MULTIPLE) )
 811                 {
 812                     currentParam++;
 813                 }
 814                 else
 815                 {
 816                     wxASSERT_MSG( currentParam == countParam - 1,
 817                                   _T("all parameters after the one with wxCMD_LINE_PARAM_MULTIPLE style are ignored") );
 818
 819                     // remember that we did have this last repeatable parameter
 820                     hadRepeatableParam = true;
 821                 }
 822             }
 823             else
 824             {
 825                 errorMsg << wxString::Format(_("Unexpected parameter '%s'"), arg.c_str()) << wxT("\n");
 826
 827                 ok = false;
 828             }
 829         }
 830     }
 831
 832     // verify that all mandatory options were given
 833     if ( ok )
 834     {
 835         size_t countOpt = m_data->m_options.GetCount();
 836         for ( size_t n = 0; ok && (n < countOpt); n++ )
 837         {
 838             wxCmdLineOption& opt = m_data->m_options[n];
 839             if ( (opt.flags & wxCMD_LINE_OPTION_MANDATORY) && !opt.HasValue() )
 840             {
 841                 wxString optName;
 842                 if ( !opt.longName )
 843                 {
 844                     optName = opt.shortName;
 845                 }
 846                 else
 847                 {
 848                     if ( AreLongOptionsEnabled() )
 849                     {
 850                         optName.Printf( _("%s (or %s)"),
 851                                         opt.shortName.c_str(),
 852                                         opt.longName.c_str() );
 853                     }
 854                     else
 855                     {
 856                         optName.Printf( wxT("%s"),
 857                                         opt.shortName.c_str() );
 858                     }
 859                 }
 860
 861                 errorMsg << wxString::Format(_("The value for the option '%s' must be specified."),
 862                                              optName.c_str()) << wxT("\n");
 863
 864                 ok = false;
 865             }
 866         }
 867
 868         for ( ; ok && (currentParam < countParam); currentParam++ )
 869         {
 870             wxCmdLineParam& param = m_data->m_paramDesc[currentParam];
 871             if ( (currentParam == countParam - 1) &&
 872                  (param.flags & wxCMD_LINE_PARAM_MULTIPLE) &&
 873                  hadRepeatableParam )
 874             {
 875                 // special case: currentParam wasn't incremented, but we did
 876                 // have it, so don't give error
 877                 continue;
 878             }
 879
 880             if ( !(param.flags & wxCMD_LINE_PARAM_OPTIONAL) )
 881             {
 882                 errorMsg << wxString::Format(_("The required parameter '%s' was not specified."),
 883                                              param.description.c_str()) << wxT("\n");
 884
 885                 ok = false;
 886             }
 887         }
 888     }
 889
 890     // if there was an error during parsing the command line, show this error
 891     // and also the usage message if it had been requested
 892     if ( !ok && (!errorMsg.empty() || (helpRequested && showUsage)) )
 893     {
 894         wxMessageOutput* msgOut = wxMessageOutput::Get();
 895         if ( msgOut )
 896         {
 897             wxString usage;
 898             if ( showUsage )
 899                 usage = GetUsageString();
 900
 901             msgOut->Printf( wxT("%s%s"), usage.c_str(), errorMsg.c_str() );
 902         }
 903         else
 904         {
 905             wxFAIL_MSG( _T("no wxMessageOutput object?") );
 906         }
 907     }
 908
 909     return ok ? 0 : helpRequested ? -1 : 1;
 910 }
 911
 912 // ----------------------------------------------------------------------------
 913 // give the usage message
 914 // ----------------------------------------------------------------------------
 915
 916 void wxCmdLineParser::Usage()
 917 {
 918     wxMessageOutput* msgOut = wxMessageOutput::Get();
 919     if ( msgOut )
 920     {
 921         msgOut->Printf( wxT("%s"), GetUsageString().c_str() );
 922     }
 923     else
 924     {
 925         wxFAIL_MSG( _T("no wxMessageOutput object?") );
 926     }
 927 }
 928
 929 wxString wxCmdLineParser::GetUsageString()
 930 {
 931     wxString appname;
 932     if ( m_data->m_arguments.empty() )
 933     {
 934         if ( wxTheApp )
 935             appname = wxTheApp->GetAppName();
 936     }
 937     else // use argv[0]
 938     {
 939         appname = wxFileName(m_data->m_arguments[0]).GetName();
 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 }