src/common/cmdline.cpp

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