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