extern/cxxopts/cxxopts.hpp

   1 /*
   2
   3 Copyright (c) 2014, 2015, 2016 Jarryd Beck
   4
   5 Permission is hereby granted, free of charge, to any person obtaining a copy
   6 of this software and associated documentation files (the "Software"), to deal
   7 in the Software without restriction, including without limitation the rights
   8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 copies of the Software, and to permit persons to whom the Software is
  10 furnished to do so, subject to the following conditions:
  11
  12 The above copyright notice and this permission notice shall be included in
  13 all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 THE SOFTWARE.
  22
  23 */
  24
  25 #ifndef CXX_OPTS_HPP
  26 #define CXX_OPTS_HPP
  27
  28 #if defined(__GNUC__)
  29 #pragma GCC diagnostic push
  30 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
  31 #endif
  32
  33 #include <cstring>
  34 #include <exception>
  35 #include <iostream>
  36 #include <map>
  37 #include <memory>
  38 #include <regex>
  39 #include <sstream>
  40 #include <string>
  41 #include <unordered_set>
  42 #include <vector>
  43
  44 //when we ask cxxopts to use Unicode, help strings are processed using ICU,
  45 //which results in the correct lengths being computed for strings when they
  46 //are formatted for the help output
  47 //it is necessary to make sure that <unicode/unistr.h> can be found by the
  48 //compiler, and that icu-uc is linked in to the binary.
  49
  50 #ifdef CXXOPTS_USE_UNICODE
  51 #include <unicode/unistr.h>
  52
  53 namespace cxxopts
  54 {
  55   typedef icu::UnicodeString String;
  56
  57   inline
  58   String
  59   toLocalString(std::string s)
  60   {
  61     return icu::UnicodeString::fromUTF8(s);
  62   }
  63
  64   class UnicodeStringIterator : public
  65     std::iterator<std::forward_iterator_tag, int32_t>
  66   {
  67     public:
  68
  69     UnicodeStringIterator(const icu::UnicodeString* s, int32_t pos)
  70     : s(s)
  71     , i(pos)
  72     {
  73     }
  74
  75     value_type
  76     operator*() const
  77     {
  78       return s->char32At(i);
  79     }
  80
  81     bool
  82     operator==(const UnicodeStringIterator& rhs) const
  83     {
  84       return s == rhs.s && i == rhs.i;
  85     }
  86
  87     bool
  88     operator!=(const UnicodeStringIterator& rhs) const
  89     {
  90       return !(*this == rhs);
  91     }
  92
  93     UnicodeStringIterator&
  94     operator++()
  95     {
  96       ++i;
  97       return *this;
  98     }
  99
 100     UnicodeStringIterator
 101     operator+(int32_t v)
 102     {
 103       return UnicodeStringIterator(s, i + v);
 104     }
 105
 106     private:
 107     const icu::UnicodeString* s;
 108     int32_t i;
 109   };
 110
 111   inline
 112   String&
 113   stringAppend(String&s, String a)
 114   {
 115     return s.append(std::move(a));
 116   }
 117
 118   inline
 119   String&
 120   stringAppend(String& s, int n, UChar32 c)
 121   {
 122     for (int i = 0; i != n; ++i)
 123     {
 124       s.append(c);
 125     }
 126
 127     return s;
 128   }
 129
 130   template <typename Iterator>
 131   String&
 132   stringAppend(String& s, Iterator begin, Iterator end)
 133   {
 134     while (begin != end)
 135     {
 136       s.append(*begin);
 137       ++begin;
 138     }
 139
 140     return s;
 141   }
 142
 143   inline
 144   size_t
 145   stringLength(const String& s)
 146   {
 147     return s.length();
 148   }
 149
 150   inline
 151   std::string
 152   toUTF8String(const String& s)
 153   {
 154     std::string result;
 155     s.toUTF8String(result);
 156
 157     return result;
 158   }
 159 }
 160
 161 namespace std
 162 {
 163   cxxopts::UnicodeStringIterator
 164   begin(const icu::UnicodeString& s)
 165   {
 166     return cxxopts::UnicodeStringIterator(&s, 0);
 167   }
 168
 169   cxxopts::UnicodeStringIterator
 170   end(const icu::UnicodeString& s)
 171   {
 172     return cxxopts::UnicodeStringIterator(&s, s.length());
 173   }
 174 }
 175
 176 //ifdef CXXOPTS_USE_UNICODE
 177 #else
 178
 179 namespace cxxopts
 180 {
 181   typedef std::string String;
 182
 183   template <typename T>
 184   T
 185   toLocalString(T&& t)
 186   {
 187     return t;
 188   }
 189
 190   inline
 191   size_t
 192   stringLength(const String& s)
 193   {
 194     return s.length();
 195   }
 196
 197   inline
 198   String&
 199   stringAppend(String&s, String a)
 200   {
 201     return s.append(std::move(a));
 202   }
 203
 204   inline
 205   String&
 206   stringAppend(String& s, size_t n, char c)
 207   {
 208     return s.append(n, c);
 209   }
 210
 211   template <typename Iterator>
 212   String&
 213   stringAppend(String& s, Iterator begin, Iterator end)
 214   {
 215     return s.append(begin, end);
 216   }
 217
 218   template <typename T>
 219   std::string
 220   toUTF8String(T&& t)
 221   {
 222     return std::forward<T>(t);
 223   }
 224
 225 }
 226
 227 //ifdef CXXOPTS_USE_UNICODE
 228 #endif
 229
 230 namespace cxxopts
 231 {
 232   class Value : public std::enable_shared_from_this<Value>
 233   {
 234     public:
 235
 236     virtual void
 237     parse(const std::string& text) const = 0;
 238
 239     virtual void
 240     parse() const = 0;
 241
 242     virtual bool
 243     has_arg() const = 0;
 244
 245     virtual bool
 246     has_default() const = 0;
 247
 248     virtual bool
 249     is_container() const = 0;
 250
 251     virtual bool
 252     has_implicit() const = 0;
 253
 254     virtual std::string
 255     get_default_value() const = 0;
 256
 257     virtual std::string
 258     get_implicit_value() const = 0;
 259
 260     virtual std::shared_ptr<Value>
 261     default_value(const std::string& value) = 0;
 262
 263     virtual std::shared_ptr<Value>
 264     implicit_value(const std::string& value) = 0;
 265   };
 266
 267   class OptionException : public std::exception
 268   {
 269     public:
 270     OptionException(const std::string& message)
 271     : m_message(message)
 272     {
 273     }
 274
 275     virtual const char*
 276     what() const noexcept
 277     {
 278       return m_message.c_str();
 279     }
 280
 281     private:
 282     std::string m_message;
 283   };
 284
 285   class OptionSpecException : public OptionException
 286   {
 287     public:
 288
 289     OptionSpecException(const std::string& message)
 290     : OptionException(message)
 291     {
 292     }
 293   };
 294
 295   class OptionParseException : public OptionException
 296   {
 297     public:
 298     OptionParseException(const std::string& message)
 299     : OptionException(message)
 300     {
 301     }
 302   };
 303
 304   class option_exists_error : public OptionSpecException
 305   {
 306     public:
 307     option_exists_error(const std::string& option)
 308     : OptionSpecException(u8"Option ‘" + option + u8"’ already exists")
 309     {
 310     }
 311   };
 312
 313   class invalid_option_format_error : public OptionSpecException
 314   {
 315     public:
 316     invalid_option_format_error(const std::string& format)
 317     : OptionSpecException(u8"Invalid option format ‘" + format + u8"’")
 318     {
 319     }
 320   };
 321
 322   class option_not_exists_exception : public OptionParseException
 323   {
 324     public:
 325     option_not_exists_exception(const std::string& option)
 326     : OptionParseException(u8"Option ‘" + option + u8"’ does not exist")
 327     {
 328     }
 329   };
 330
 331   class missing_argument_exception : public OptionParseException
 332   {
 333     public:
 334     missing_argument_exception(const std::string& option)
 335     : OptionParseException(u8"Option ‘" + option + u8"’ is missing an argument")
 336     {
 337     }
 338   };
 339
 340   class option_requires_argument_exception : public OptionParseException
 341   {
 342     public:
 343     option_requires_argument_exception(const std::string& option)
 344     : OptionParseException(u8"Option ‘" + option + u8"’ requires an argument")
 345     {
 346     }
 347   };
 348
 349   class option_not_has_argument_exception : public OptionParseException
 350   {
 351     public:
 352     option_not_has_argument_exception
 353     (
 354       const std::string& option,
 355       const std::string& arg
 356     )
 357     : OptionParseException(
 358         u8"Option ‘" + option + u8"’ does not take an argument, but argument‘"
 359         + arg + "’ given")
 360     {
 361     }
 362   };
 363
 364   class option_not_present_exception : public OptionParseException
 365   {
 366     public:
 367     option_not_present_exception(const std::string& option)
 368     : OptionParseException(u8"Option ‘" + option + u8"’ not present")
 369     {
 370     }
 371   };
 372
 373   class argument_incorrect_type : public OptionParseException
 374   {
 375     public:
 376     argument_incorrect_type
 377     (
 378       const std::string& arg
 379     )
 380     : OptionParseException(
 381       u8"Argument ‘" + arg + u8"’ failed to parse"
 382     )
 383     {
 384     }
 385   };
 386
 387   namespace values
 388   {
 389     template <typename T>
 390     void
 391     parse_value(const std::string& text, T& value)
 392     {
 393       std::istringstream is(text);
 394       if (!(is >> value))
 395       {
 396         throw argument_incorrect_type(text);
 397       }
 398
 399       if (is.rdbuf()->in_avail() != 0)
 400       {
 401         throw argument_incorrect_type(text);
 402       }
 403     }
 404
 405     inline
 406     void
 407     parse_value(const std::string& /*text*/, bool& value)
 408     {
 409       //TODO recognise on, off, yes, no, enable, disable
 410       //so that we can write --long=yes explicitly
 411       value = true;
 412     }
 413
 414     inline
 415     void
 416     parse_value(const std::string& text, std::string& value)
 417     {
 418       value = text;
 419     }
 420
 421     template <typename T>
 422     void
 423     parse_value(const std::string& text, std::vector<T>& value)
 424     {
 425       T v;
 426       parse_value(text, v);
 427       value.push_back(v);
 428     }
 429
 430     template <typename T>
 431     struct value_has_arg
 432     {
 433       static constexpr bool value = true;
 434     };
 435
 436     template <>
 437     struct value_has_arg<bool>
 438     {
 439       static constexpr bool value = false;
 440     };
 441
 442     template <typename T>
 443     struct type_is_container
 444     {
 445       static constexpr bool value = false;
 446     };
 447
 448     template <typename T>
 449     struct type_is_container<std::vector<T>>
 450     {
 451       static constexpr bool value = true;
 452     };
 453
 454     template <typename T>
 455     class standard_value : public Value
 456     {
 457       public:
 458       standard_value()
 459       : m_result(std::make_shared<T>())
 460       , m_store(m_result.get())
 461       {
 462       }
 463
 464       standard_value(T* t)
 465       : m_store(t)
 466       {
 467       }
 468
 469       void
 470       parse(const std::string& text) const
 471       {
 472         if (m_implicit && text.empty())
 473         {
 474           parse_value(m_implicit_value, *m_store);
 475         }
 476         else
 477         {
 478           parse_value(text, *m_store);
 479         }
 480       }
 481
 482       bool
 483       is_container() const
 484       {
 485         return type_is_container<T>::value;
 486       }
 487
 488       void
 489       parse() const
 490       {
 491         parse_value(m_default_value, *m_store);
 492       }
 493
 494       bool
 495       has_arg() const
 496       {
 497         return value_has_arg<T>::value;
 498       }
 499
 500       bool
 501       has_default() const
 502       {
 503         return m_default;
 504       }
 505
 506       bool
 507       has_implicit() const
 508       {
 509         return m_implicit;
 510       }
 511
 512       virtual std::shared_ptr<Value>
 513       default_value(const std::string& value){
 514         m_default = true;
 515         m_default_value = value;
 516         return shared_from_this();
 517       }
 518
 519       virtual std::shared_ptr<Value>
 520       implicit_value(const std::string& value){
 521         m_implicit = true;
 522         m_implicit_value = value;
 523         return shared_from_this();
 524       }
 525
 526       std::string
 527       get_default_value() const
 528       {
 529         return m_default_value;
 530       }
 531
 532       std::string
 533       get_implicit_value() const
 534       {
 535         return m_implicit_value;
 536       }
 537
 538       const T&
 539       get() const
 540       {
 541         if (m_store == nullptr)
 542         {
 543           return *m_result;
 544         }
 545         else
 546         {
 547           return *m_store;
 548         }
 549       }
 550
 551       protected:
 552       std::shared_ptr<T> m_result;
 553       T* m_store;
 554       bool m_default = false;
 555       std::string m_default_value;
 556       bool m_implicit = false;
 557       std::string m_implicit_value;
 558     };
 559   }
 560
 561   template <typename T>
 562   std::shared_ptr<Value>
 563   value()
 564   {
 565     return std::make_shared<values::standard_value<T>>();
 566   }
 567
 568   template <typename T>
 569   std::shared_ptr<Value>
 570   value(T& t)
 571   {
 572     return std::make_shared<values::standard_value<T>>(&t);
 573   }
 574
 575   class OptionAdder;
 576
 577   class OptionDetails
 578   {
 579     public:
 580     OptionDetails
 581     (
 582       const String& description,
 583       std::shared_ptr<const Value> value
 584     )
 585     : m_desc(description)
 586     , m_value(value)
 587     , m_count(0)
 588     {
 589     }
 590
 591     const String&
 592     description() const
 593     {
 594       return m_desc;
 595     }
 596
 597     bool
 598     has_arg() const
 599     {
 600       return m_value->has_arg();
 601     }
 602
 603     void
 604     parse(const std::string& text)
 605     {
 606       m_value->parse(text);
 607       ++m_count;
 608     }
 609
 610     void
 611     parse_default()
 612     {
 613       m_value->parse();
 614     }
 615
 616     int
 617     count() const
 618     {
 619       return m_count;
 620     }
 621
 622     const Value& value() const {
 623         return *m_value;
 624     }
 625
 626     template <typename T>
 627     const T&
 628     as() const
 629     {
 630 #ifdef CXXOPTS_NO_RTTI
 631       return static_cast<const values::standard_value<T>&>(*m_value).get();
 632 #else
 633       return dynamic_cast<const values::standard_value<T>&>(*m_value).get();
 634 #endif
 635     }
 636
 637     private:
 638     String m_desc;
 639     std::shared_ptr<const Value> m_value;
 640     int m_count;
 641   };
 642
 643   struct HelpOptionDetails
 644   {
 645     std::string s;
 646     std::string l;
 647     String desc;
 648     bool has_arg;
 649     bool has_default;
 650     std::string default_value;
 651     bool has_implicit;
 652     std::string implicit_value;
 653     std::string arg_help;
 654     bool is_container;
 655   };
 656
 657   struct HelpGroupDetails
 658   {
 659     std::string name;
 660     std::string description;
 661     std::vector<HelpOptionDetails> options;
 662   };
 663
 664   class Options
 665   {
 666     public:
 667
 668     Options(std::string program, std::string help_string = "")
 669     : m_program(std::move(program))
 670     , m_help_string(toLocalString(std::move(help_string)))
 671     , m_next_positional(m_positional.end())
 672     {
 673     }
 674
 675     inline
 676     void
 677     parse(int& argc, char**& argv);
 678
 679     inline
 680     OptionAdder
 681     add_options(std::string group = "");
 682
 683     inline
 684     void
 685     add_option
 686     (
 687       const std::string& group,
 688       const std::string& s,
 689       const std::string& l,
 690       std::string desc,
 691       std::shared_ptr<const Value> value,
 692       std::string arg_help
 693     );
 694
 695     int
 696     count(const std::string& o) const
 697     {
 698       auto iter = m_options.find(o);
 699       if (iter == m_options.end())
 700       {
 701         return 0;
 702       }
 703
 704       return iter->second->count();
 705     }
 706
 707     const OptionDetails&
 708     operator[](const std::string& option) const
 709     {
 710       auto iter = m_options.find(option);
 711
 712       if (iter == m_options.end())
 713       {
 714         throw option_not_present_exception(option);
 715       }
 716
 717       return *iter->second;
 718     }
 719
 720     //parse positional arguments into the given option
 721     inline
 722     void
 723     parse_positional(std::string option);
 724
 725     inline
 726     void
 727     parse_positional(std::vector<std::string> options);
 728
 729     inline
 730     std::string
 731     help(const std::vector<std::string>& groups = {""}) const;
 732
 733     inline
 734     const std::vector<std::string>
 735     groups() const;
 736
 737     inline
 738     const HelpGroupDetails&
 739     group_help(const std::string& group) const;
 740
 741     private:
 742
 743     inline
 744     void
 745     add_one_option
 746     (
 747       const std::string& option,
 748       std::shared_ptr<OptionDetails> details
 749     );
 750
 751     inline
 752     bool
 753     consume_positional(std::string a);
 754
 755     inline
 756     void
 757     add_to_option(const std::string& option, const std::string& arg);
 758
 759     inline
 760     void
 761     parse_option
 762     (
 763       std::shared_ptr<OptionDetails> value,
 764       const std::string& name,
 765       const std::string& arg = ""
 766     );
 767
 768     inline
 769     void
 770     checked_parse_arg
 771     (
 772       int argc,
 773       char* argv[],
 774       int& current,
 775       std::shared_ptr<OptionDetails> value,
 776       const std::string& name
 777     );
 778
 779     inline
 780     String
 781     help_one_group(const std::string& group) const;
 782
 783     std::string m_program;
 784     String m_help_string;
 785
 786     std::map<std::string, std::shared_ptr<OptionDetails>> m_options;
 787     std::vector<std::string> m_positional;
 788     std::vector<std::string>::iterator m_next_positional;
 789     std::unordered_set<std::string> m_positional_set;
 790
 791     //mapping from groups to help options
 792     std::map<std::string, HelpGroupDetails> m_help;
 793   };
 794
 795   class OptionAdder
 796   {
 797     public:
 798
 799     OptionAdder(Options& options, std::string group)
 800     : m_options(options), m_group(std::move(group))
 801     {
 802     }
 803
 804     inline
 805     OptionAdder&
 806     operator()
 807     (
 808       const std::string& opts,
 809       const std::string& desc,
 810       std::shared_ptr<const Value> value
 811         = ::cxxopts::value<bool>(),
 812       std::string arg_help = ""
 813     );
 814
 815     private:
 816     Options& m_options;
 817     std::string m_group;
 818   };
 819
 820 }
 821
 822 namespace cxxopts
 823 {
 824
 825   namespace
 826   {
 827
 828     constexpr int OPTION_LONGEST = 30;
 829     constexpr int OPTION_DESC_GAP = 2;
 830
 831     std::basic_regex<char> option_matcher
 832       ("--([[:alnum:]][-_[:alnum:]]+)(=(.*))?|-([a-zA-Z]+)");
 833
 834     std::basic_regex<char> option_specifier
 835       ("(([a-zA-Z]),)?([a-zA-Z0-9][-_a-zA-Z0-9]+)");
 836
 837     String
 838     format_option
 839     (
 840       const HelpOptionDetails& o
 841     )
 842     {
 843       auto& s = o.s;
 844       auto& l = o.l;
 845
 846       String result = "  ";
 847
 848       if (s.size() > 0)
 849       {
 850         result += "-" + toLocalString(s) + ",";
 851       }
 852       else
 853       {
 854         result += "   ";
 855       }
 856
 857       if (l.size() > 0)
 858       {
 859         result += " --" + toLocalString(l);
 860       }
 861
 862       if (o.has_arg)
 863       {
 864         auto arg = o.arg_help.size() > 0 ? toLocalString(o.arg_help) : "arg";
 865
 866         if (o.has_implicit)
 867         {
 868           result += " [=" + arg + "(=" + toLocalString(o.implicit_value) + ")]";
 869         }
 870         else
 871         {
 872           result += " " + arg;
 873         }
 874       }
 875
 876       return result;
 877     }
 878
 879     String
 880     format_description
 881     (
 882       const HelpOptionDetails& o,
 883       size_t start,
 884       size_t width
 885     )
 886     {
 887       auto desc = o.desc;
 888
 889       if (o.has_default)
 890       {
 891         desc += toLocalString(" (default: " + o.default_value + ")");
 892       }
 893
 894       String result;
 895
 896       auto current = std::begin(desc);
 897       auto startLine = current;
 898       auto lastSpace = current;
 899
 900       auto size = size_t{};
 901
 902       while (current != std::end(desc))
 903       {
 904         if (*current == ' ')
 905         {
 906           lastSpace = current;
 907         }
 908
 909         if (size > width)
 910         {
 911           if (lastSpace == startLine)
 912           {
 913             stringAppend(result, startLine, current + 1);
 914             stringAppend(result, "\n");
 915             stringAppend(result, start, ' ');
 916             startLine = current + 1;
 917             lastSpace = startLine;
 918           }
 919           else
 920           {
 921             stringAppend(result, startLine, lastSpace);
 922             stringAppend(result, "\n");
 923             stringAppend(result, start, ' ');
 924             startLine = lastSpace + 1;
 925           }
 926           size = 0;
 927         }
 928         else
 929         {
 930           ++size;
 931         }
 932
 933         ++current;
 934       }
 935
 936       //append whatever is left
 937       stringAppend(result, startLine, current);
 938
 939       return result;
 940     }
 941   }
 942
 943 OptionAdder
 944 Options::add_options(std::string group)
 945 {
 946   return OptionAdder(*this, std::move(group));
 947 }
 948
 949 OptionAdder&
 950 OptionAdder::operator()
 951 (
 952   const std::string& opts,
 953   const std::string& desc,
 954   std::shared_ptr<const Value> value,
 955   std::string arg_help
 956 )
 957 {
 958   std::match_results<const char*> result;
 959   std::regex_match(opts.c_str(), result, option_specifier);
 960
 961   if (result.empty())
 962   {
 963     throw invalid_option_format_error(opts);
 964   }
 965
 966   const auto& s = result[2];
 967   const auto& l = result[3];
 968
 969   m_options.add_option(m_group, s.str(), l.str(), desc, value,
 970     std::move(arg_help));
 971
 972   return *this;
 973 }
 974
 975 void
 976 Options::parse_option
 977 (
 978   std::shared_ptr<OptionDetails> value,
 979   const std::string& /*name*/,
 980   const std::string& arg
 981 )
 982 {
 983   value->parse(arg);
 984 }
 985
 986 void
 987 Options::checked_parse_arg
 988 (
 989   int argc,
 990   char* argv[],
 991   int& current,
 992   std::shared_ptr<OptionDetails> value,
 993   const std::string& name
 994 )
 995 {
 996   if (current + 1 >= argc)
 997   {
 998     if (value->value().has_implicit())
 999     {
1000       parse_option(value, name, "");
1001     }
1002     else
1003     {
1004       throw missing_argument_exception(name);
1005     }
1006   }
1007   else
1008   {
1009     if (argv[current + 1][0] == '-' && value->value().has_implicit())
1010     {
1011       parse_option(value, name, "");
1012     }
1013     else
1014     {
1015       parse_option(value, name, argv[current + 1]);
1016       ++current;
1017     }
1018   }
1019 }
1020
1021 void
1022 Options::add_to_option(const std::string& option, const std::string& arg)
1023 {
1024   auto iter = m_options.find(option);
1025
1026   if (iter == m_options.end())
1027   {
1028     throw option_not_exists_exception(option);
1029   }
1030
1031   parse_option(iter->second, option, arg);
1032 }
1033
1034 bool
1035 Options::consume_positional(std::string a)
1036 {
1037   while (m_next_positional != m_positional.end())
1038   {
1039     auto iter = m_options.find(*m_next_positional);
1040     if (iter != m_options.end())
1041     {
1042       if (!iter->second->value().is_container())
1043       {
1044         if (iter->second->count() == 0)
1045         {
1046           add_to_option(*m_next_positional, a);
1047           ++m_next_positional;
1048           return true;
1049         }
1050         else
1051         {
1052           ++m_next_positional;
1053           continue;
1054         }
1055       }
1056       else
1057       {
1058         add_to_option(*m_next_positional, a);
1059         return true;
1060       }
1061     }
1062     ++m_next_positional;
1063   }
1064
1065   return false;
1066 }
1067
1068 void
1069 Options::parse_positional(std::string option)
1070 {
1071   parse_positional(std::vector<std::string>{option});
1072 }
1073
1074 void
1075 Options::parse_positional(std::vector<std::string> options)
1076 {
1077   m_positional = std::move(options);
1078   m_next_positional = m_positional.begin();
1079
1080   m_positional_set.insert(m_positional.begin(), m_positional.end());
1081 }
1082
1083 void
1084 Options::parse(int& argc, char**& argv)
1085 {
1086   int current = 1;
1087
1088   int nextKeep = 1;
1089
1090   bool consume_remaining = false;
1091
1092   while (current != argc)
1093   {
1094     if (strcmp(argv[current], "--") == 0)
1095     {
1096       consume_remaining = true;
1097       ++current;
1098       break;
1099     }
1100
1101     std::match_results<const char*> result;
1102     std::regex_match(argv[current], result, option_matcher);
1103
1104     if (result.empty())
1105     {
1106       //not a flag
1107
1108       //if true is returned here then it was consumed, otherwise it is
1109       //ignored
1110       if (consume_positional(argv[current]))
1111       {
1112       }
1113       else
1114       {
1115         argv[nextKeep] = argv[current];
1116         ++nextKeep;
1117       }
1118       //if we return from here then it was parsed successfully, so continue
1119     }
1120     else
1121     {
1122       //short or long option?
1123       if (result[4].length() != 0)
1124       {
1125         const std::string& s = result[4];
1126
1127         for (std::size_t i = 0; i != s.size(); ++i)
1128         {
1129           std::string name(1, s[i]);
1130           auto iter = m_options.find(name);
1131
1132           if (iter == m_options.end())
1133           {
1134             throw option_not_exists_exception(name);
1135           }
1136
1137           auto value = iter->second;
1138
1139           //if no argument then just add it
1140           if (!value->has_arg())
1141           {
1142             parse_option(value, name);
1143           }
1144           else
1145           {
1146             //it must be the last argument
1147             if (i + 1 == s.size())
1148             {
1149               checked_parse_arg(argc, argv, current, value, name);
1150             }
1151             else if (value->value().has_implicit())
1152             {
1153               parse_option(value, name, "");
1154             }
1155             else
1156             {
1157               //error
1158               throw option_requires_argument_exception(name);
1159             }
1160           }
1161         }
1162       }
1163       else if (result[1].length() != 0)
1164       {
1165         const std::string& name = result[1];
1166
1167         auto iter = m_options.find(name);
1168
1169         if (iter == m_options.end())
1170         {
1171           throw option_not_exists_exception(name);
1172         }
1173
1174         auto opt = iter->second;
1175
1176         //equals provided for long option?
1177         if (result[3].length() != 0)
1178         {
1179           //parse the option given
1180
1181           //but if it doesn't take an argument, this is an error
1182           if (!opt->has_arg())
1183           {
1184             throw option_not_has_argument_exception(name, result[3]);
1185           }
1186
1187           parse_option(opt, name, result[3]);
1188         }
1189         else
1190         {
1191           if (opt->has_arg())
1192           {
1193             //parse the next argument
1194             checked_parse_arg(argc, argv, current, opt, name);
1195           }
1196           else
1197           {
1198             //parse with empty argument
1199             parse_option(opt, name);
1200           }
1201         }
1202       }
1203
1204     }
1205
1206     ++current;
1207   }
1208
1209   for (auto& opt : m_options)
1210   {
1211     auto& detail = opt.second;
1212     auto& value = detail->value();
1213
1214     if(!detail->count() && value.has_default()){
1215       detail->parse_default();
1216     }
1217   }
1218
1219   if (consume_remaining)
1220   {
1221     while (current < argc)
1222     {
1223       consume_positional(argv[current]);
1224       ++current;
1225     }
1226   }
1227
1228   argc = nextKeep;
1229
1230 }
1231
1232 void
1233 Options::add_option
1234 (
1235   const std::string& group,
1236   const std::string& s,
1237   const std::string& l,
1238   std::string desc,
1239   std::shared_ptr<const Value> value,
1240   std::string arg_help
1241 )
1242 {
1243   auto stringDesc = toLocalString(std::move(desc));
1244   auto option = std::make_shared<OptionDetails>(stringDesc, value);
1245
1246   if (s.size() > 0)
1247   {
1248     add_one_option(s, option);
1249   }
1250
1251   if (l.size() > 0)
1252   {
1253     add_one_option(l, option);
1254   }
1255
1256   //add the help details
1257   auto& options = m_help[group];
1258
1259   options.options.emplace_back(HelpOptionDetails{s, l, stringDesc,
1260       value->has_arg(),
1261       value->has_default(), value->get_default_value(),
1262       value->has_implicit(), value->get_implicit_value(),
1263       std::move(arg_help),
1264       value->is_container()});
1265 }
1266
1267 void
1268 Options::add_one_option
1269 (
1270   const std::string& option,
1271   std::shared_ptr<OptionDetails> details
1272 )
1273 {
1274   auto in = m_options.emplace(option, details);
1275
1276   if (!in.second)
1277   {
1278     throw option_exists_error(option);
1279   }
1280 }
1281
1282 String
1283 Options::help_one_group(const std::string& g) const
1284 {
1285   typedef std::vector<std::pair<String, String>> OptionHelp;
1286
1287   auto group = m_help.find(g);
1288   if (group == m_help.end())
1289   {
1290     return "";
1291   }
1292
1293   OptionHelp format;
1294
1295   size_t longest = 0;
1296
1297   String result;
1298
1299   if (!g.empty())
1300   {
1301     result += toLocalString(" " + g + " options:\n");
1302   }
1303
1304   for (const auto& o : group->second.options)
1305   {
1306     if (o.is_container && m_positional_set.find(o.l) != m_positional_set.end())
1307     {
1308       continue;
1309     }
1310
1311     auto s = format_option(o);
1312     longest = std::max(longest, stringLength(s));
1313     format.push_back(std::make_pair(s, String()));
1314   }
1315
1316   longest = std::min(longest, static_cast<size_t>(OPTION_LONGEST));
1317
1318   //widest allowed description
1319   auto allowed = size_t{76} - longest - OPTION_DESC_GAP;
1320
1321   auto fiter = format.begin();
1322   for (const auto& o : group->second.options)
1323   {
1324     if (o.is_container && m_positional_set.find(o.l) != m_positional_set.end())
1325     {
1326       continue;
1327     }
1328
1329     auto d = format_description(o, longest + OPTION_DESC_GAP, allowed);
1330
1331     result += fiter->first;
1332     if (stringLength(fiter->first) > longest)
1333     {
1334       result += '\n';
1335       result += toLocalString(std::string(longest + OPTION_DESC_GAP, ' '));
1336     }
1337     else
1338     {
1339       result += toLocalString(std::string(longest + OPTION_DESC_GAP -
1340         stringLength(fiter->first),
1341         ' '));
1342     }
1343     result += d;
1344     result += '\n';
1345
1346     ++fiter;
1347   }
1348
1349   return result;
1350 }
1351
1352 std::string
1353 Options::help(const std::vector<std::string>& groups) const
1354 {
1355   String result = m_help_string + "\nUsage:\n  " +
1356     toLocalString(m_program) + " [OPTION...]";
1357
1358   if (m_positional.size() > 0) {
1359     result += " positional parameters";
1360   }
1361
1362   result += "\n\n";
1363
1364   for (std::size_t i = 0; i < groups.size(); ++i)
1365   {
1366     String const& group_help = help_one_group(groups[i]);
1367     if (group_help.empty()) continue;
1368     result += group_help;
1369     if (i < groups.size() - 1)
1370     {
1371       result += '\n';
1372     }
1373   }
1374
1375   return toUTF8String(result);
1376 }
1377
1378 const std::vector<std::string>
1379 Options::groups() const
1380 {
1381   std::vector<std::string> g;
1382
1383   std::transform(
1384     m_help.begin(),
1385     m_help.end(),
1386     std::back_inserter(g),
1387     [] (const std::map<std::string, HelpGroupDetails>::value_type& pair)
1388     {
1389       return pair.first;
1390     }
1391   );
1392
1393   return g;
1394 }
1395
1396 const HelpGroupDetails&
1397 Options::group_help(const std::string& group) const
1398 {
1399   return m_help.at(group);
1400 }
1401
1402 }
1403
1404 #if defined(__GNU__)
1405 #pragma GCC diagnostic pop
1406 #endif
1407
1408 #endif //CXX_OPTS_HPP