Merge pull request #4916 from leoetlino/cpp-optparse

Use cpp-optparse for command line parsing

CMakeLists.txt

@@ -567,6 +567,8 @@ include_directories(Externals/Bochs_disasm)
 
 add_subdirectory(Externals/glslang)
 
+add_subdirectory(Externals/cpp-optparse)
+
 if(USE_SHARED_ENET)
 	check_lib(ENET libenet enet enet/enet.h QUIET)
 	include(CheckSymbolExists)

Externals/cpp-optparse/CMakeLists.txt

@@ -0,0 +1,6 @@
+check_and_add_flag(CXX11 -std=c++11)
+
+set(SRCS OptionParser.cpp OptionParser.h)
+
+add_library(cpp-optparse STATIC ${SRCS})
+target_include_directories(cpp-optparse PUBLIC .)

Externals/cpp-optparse/OptionParser.h

@@ -0,0 +1,278 @@
+/**
+ * Copyright (C) 2010 Johannes Weißl <jargon@molb.org>
+ * License: MIT License
+ * URL: https://github.com/weisslj/cpp-optparse
+ */
+
+#ifndef OPTIONPARSER_H_
+#define OPTIONPARSER_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+#include <list>
+#include <map>
+#include <set>
+#include <iostream>
+#include <sstream>
+
+namespace optparse {
+
+class OptionParser;
+class OptionGroup;
+class Option;
+class Values;
+class Value;
+class Callback;
+
+typedef std::map<std::string,std::string> strMap;
+typedef std::map<std::string,std::list<std::string> > lstMap;
+typedef std::map<std::string,Option const*> optMap;
+
+const char* const SUPPRESS_HELP = "SUPPRESS" "HELP";
+const char* const SUPPRESS_USAGE = "SUPPRESS" "USAGE";
+
+//! Class for automatic conversion from string -> anytype
+class Value {
+  public:
+    Value() : str(), valid(false) {}
+    Value(const std::string& v) : str(v), valid(true) {}
+    operator const char*() { return str.c_str(); }
+    operator bool() { bool t; return (valid && (std::istringstream(str) >> t)) ? t : false; }
+    operator short() { short t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator unsigned short() { unsigned short t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator int() { int t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator unsigned int() { unsigned int t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator long() { long t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator unsigned long() { unsigned long t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator float() { float t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator double() { double t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+    operator long double() { long double t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
+ private:
+    const std::string str;
+    bool valid;
+};
+
+class Values {
+  public:
+    Values() : _map() {}
+    const std::string& operator[] (const std::string& d) const;
+    std::string& operator[] (const std::string& d) { return _map[d]; }
+    bool is_set(const std::string& d) const { return _map.find(d) != _map.end(); }
+    bool is_set_by_user(const std::string& d) const { return _userSet.find(d) != _userSet.end(); }
+    void is_set_by_user(const std::string& d, bool yes);
+    Value get(const std::string& d) const { return (is_set(d)) ? Value((*this)[d]) : Value(); }
+
+    typedef std::list<std::string>::iterator iterator;
+    typedef std::list<std::string>::const_iterator const_iterator;
+    std::list<std::string>& all(const std::string& d) { return _appendMap[d]; }
+    const std::list<std::string>& all(const std::string& d) const { return _appendMap.find(d)->second; }
+
+  private:
+    strMap _map;
+    lstMap _appendMap;
+    std::set<std::string> _userSet;
+};
+
+class Option {
+  public:
+    Option(const OptionParser& p) :
+      _parser(p), _action("store"), _type("string"), _nargs(1), _callback(0) {}
+    virtual ~Option() {}
+
+    Option& action(const std::string& a);
+    Option& type(const std::string& t);
+    Option& dest(const std::string& d) { _dest = d; return *this; }
+    Option& set_default(const std::string& d) { _default = d; return *this; }
+    template<typename T>
+    Option& set_default(T t) { std::ostringstream ss; ss << t; _default = ss.str(); return *this; }
+    Option& nargs(size_t n) { _nargs = n; return *this; }
+    Option& set_const(const std::string& c) { _const = c; return *this; }
+    template<typename InputIterator>
+    Option& choices(InputIterator begin, InputIterator end) {
+      _choices.assign(begin, end); type("choice"); return *this;
+    }
+    Option& choices(std::initializer_list<std::string> ilist) {
+      _choices.assign(ilist); type("choice"); return *this;
+    }
+    Option& help(const std::string& h) { _help = h; return *this; }
+    Option& metavar(const std::string& m) { _metavar = m; return *this; }
+    Option& callback(Callback& c) { _callback = &c; return *this; }
+
+    const std::string& action() const { return _action; }
+    const std::string& type() const { return _type; }
+    const std::string& dest() const { return _dest; }
+    const std::string& get_default() const;
+    size_t nargs() const { return _nargs; }
+    const std::string& get_const() const { return _const; }
+    const std::list<std::string>& choices() const { return _choices; }
+    const std::string& help() const { return _help; }
+    const std::string& metavar() const { return _metavar; }
+    Callback* callback() const { return _callback; }
+
+  private:
+    std::string check_type(const std::string& opt, const std::string& val) const;
+    std::string format_option_help(unsigned int indent = 2) const;
+    std::string format_help(unsigned int indent = 2) const;
+
+    const OptionParser& _parser;
+
+    std::set<std::string> _short_opts;
+    std::set<std::string> _long_opts;
+
+    std::string _action;
+    std::string _type;
+    std::string _dest;
+    std::string _default;
+    size_t _nargs;
+    std::string _const;
+    std::list<std::string> _choices;
+    std::string _help;
+    std::string _metavar;
+    Callback* _callback;
+
+    friend class OptionContainer;
+    friend class OptionParser;
+};
+
+class OptionContainer {
+  public:
+    OptionContainer(const std::string& d = "") : _description(d) {}
+    virtual ~OptionContainer() {}
+
+    virtual OptionContainer& description(const std::string& d) { _description = d; return *this; }
+    virtual const std::string& description() const { return _description; }
+
+    Option& add_option(const std::string& opt);
+    Option& add_option(const std::string& opt1, const std::string& opt2);
+    Option& add_option(const std::string& opt1, const std::string& opt2, const std::string& opt3);
+    Option& add_option(const std::vector<std::string>& opt);
+
+    std::string format_option_help(unsigned int indent = 2) const;
+
+  protected:
+    std::string _description;
+
+    std::list<Option> _opts;
+    optMap _optmap_s;
+    optMap _optmap_l;
+
+  private:
+    virtual const OptionParser& get_parser() = 0;
+};
+
+class OptionParser : public OptionContainer {
+  public:
+    OptionParser();
+    virtual ~OptionParser() {}
+
+    OptionParser& usage(const std::string& u) { set_usage(u); return *this; }
+    OptionParser& version(const std::string& v) { _version = v; return *this; }
+    OptionParser& description(const std::string& d) { _description = d; return *this; }
+    OptionParser& add_help_option(bool h) { _add_help_option = h; return *this; }
+    OptionParser& add_version_option(bool v) { _add_version_option = v; return *this; }
+    OptionParser& prog(const std::string& p) { _prog = p; return *this; }
+    OptionParser& epilog(const std::string& e) { _epilog = e; return *this; }
+    OptionParser& set_defaults(const std::string& dest, const std::string& val) {
+      _defaults[dest] = val; return *this;
+    }
+    template<typename T>
+    OptionParser& set_defaults(const std::string& dest, T t) { std::ostringstream ss; ss << t; _defaults[dest] = ss.str(); return *this; }
+    OptionParser& enable_interspersed_args() { _interspersed_args = true; return *this; }
+    OptionParser& disable_interspersed_args() { _interspersed_args = false; return *this; }
+    OptionParser& add_option_group(const OptionGroup& group);
+
+    const std::string& usage() const { return _usage; }
+    const std::string& version() const { return _version; }
+    const std::string& description() const { return _description; }
+    bool add_help_option() const { return _add_help_option; }
+    bool add_version_option() const { return _add_version_option; }
+    const std::string& prog() const { return _prog; }
+    const std::string& epilog() const { return _epilog; }
+    bool interspersed_args() const { return _interspersed_args; }
+
+    Values& parse_args(int argc, char const* const* argv);
+    Values& parse_args(const std::vector<std::string>& args);
+    template<typename InputIterator>
+    Values& parse_args(InputIterator begin, InputIterator end) {
+      return parse_args(std::vector<std::string>(begin, end));
+    }
+
+    const std::list<std::string>& args() const { return _leftover; }
+    std::vector<std::string> args() {
+      return std::vector<std::string>(_leftover.begin(), _leftover.end());
+    }
+
+    std::string format_help() const;
+    void print_help() const;
+
+    void set_usage(const std::string& u);
+    std::string get_usage() const;
+    void print_usage(std::ostream& out) const;
+    void print_usage() const;
+
+    std::string get_version() const;
+    void print_version(std::ostream& out) const;
+    void print_version() const;
+
+    void error(const std::string& msg) const;
+    void exit() const;
+
+  private:
+    const OptionParser& get_parser() { return *this; }
+    const Option& lookup_short_opt(const std::string& opt) const;
+    const Option& lookup_long_opt(const std::string& opt) const;
+
+    void handle_short_opt(const std::string& opt, const std::string& arg);
+    void handle_long_opt(const std::string& optstr);
+
+    void process_opt(const Option& option, const std::string& opt, const std::string& value);
+
+    std::string format_usage(const std::string& u) const;
+
+    std::string _usage;
+    std::string _version;
+    bool _add_help_option;
+    bool _add_version_option;
+    std::string _prog;
+    std::string _epilog;
+    bool _interspersed_args;
+
+    Values _values;
+
+    strMap _defaults;
+    std::list<OptionGroup const*> _groups;
+
+    std::list<std::string> _remaining;
+    std::list<std::string> _leftover;
+
+    friend class Option;
+};
+
+class OptionGroup : public OptionContainer {
+  public:
+    OptionGroup(const OptionParser& p, const std::string& t, const std::string& d = "") :
+      OptionContainer(d), _parser(p), _title(t) {}
+    virtual ~OptionGroup() {}
+
+    OptionGroup& title(const std::string& t) { _title = t; return *this; }
+    const std::string& title() const { return _title; }
+
+  private:
+    const OptionParser& get_parser() { return _parser; }
+
+    const OptionParser& _parser;
+    std::string _title;
+
+  friend class OptionParser;
+};
+
+class Callback {
+public:
+  virtual void operator() (const Option& option, const std::string& opt, const std::string& val, const OptionParser& parser) = 0;
+  virtual ~Callback() {}
+};
+
+}
+
+#endif

Externals/cpp-optparse/cpp-optparse.vcxproj

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C636D9D1-82FE-42B5-9987-63B7D4836341}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\..\Source\VSProps\Base.props" />
+    <Import Project="..\..\Source\VSProps\ClDisableAllWarnings.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile />
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile />
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="OptionParser.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="OptionParser.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Externals/cpp-optparse/cpp-optparse.vcxproj.filters

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="OptionParser.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="OptionParser.h" />
+  </ItemGroup>
+</Project>

Source/Core/DolphinWX/CMakeLists.txt

@@ -91,7 +91,7 @@ if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
 	set(WXLIBS ${WXLIBS} dl)
 endif()
 
-list(APPEND LIBS core uicommon)
+list(APPEND LIBS core uicommon cpp-optparse)
 
 if(APPLE)
 	if(wxWidgets_FOUND)

Source/Core/DolphinWX/DolphinWX.vcxproj

@@ -48,8 +48,9 @@
     <ResourceCompile>
       <AdditionalIncludeDirectories>$(ExternalsDir)wxWidgets3\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ResourceCompile>
-    <ClCompile />
-    <ClCompile />
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(ExternalsDir)cpp-optparse;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
     <Manifest>
       <AdditionalManifestFiles>DolphinWX.manifest;%(AdditionalManifestFiles)</AdditionalManifestFiles>
     </Manifest>
@@ -228,6 +229,9 @@
     <ProjectReference Include="$(ExternalsDir)Bochs_disasm\Bochs_disasm.vcxproj">
       <Project>{8ada04d7-6db1-4da4-ab55-64fb12a0997b}</Project>
     </ProjectReference>
+    <ProjectReference Include="$(ExternalsDir)cpp-optparse\cpp-optparse.vcxproj">
+      <Project>{C636D9D1-82FE-42B5-9987-63B7D4836341}</Project>
+    </ProjectReference>
     <ProjectReference Include="$(ExternalsDir)libpng\png\png.vcxproj">
       <Project>{4c9f135b-a85e-430c-bad4-4c67ef5fc12c}</Project>
     </ProjectReference>

Source/Core/DolphinWX/Main.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <OptionParser.h>
 #include <cstdio>
 #include <cstring>
 #include <mutex>
@@ -47,6 +48,7 @@
 #include "DolphinWX/VideoConfigDiag.h"
 #include "DolphinWX/WxUtils.h"
 
+#include "UICommon/CommandLineParse.h"
 #include "UICommon/UICommon.h"
 
 #include "VideoCommon/VideoBackendBase.h"
@@ -77,6 +79,11 @@ bool DolphinApp::Initialize(int& c, wxChar** v)
 
 // The 'main program' equivalent that creates the main window and return the main frame
 
+void DolphinApp::OnInitCmdLine(wxCmdLineParser& parser)
+{
+  parser.SetCmdLine("");
+}
+
 bool DolphinApp::OnInit()
 {
   std::lock_guard<std::mutex> lk(s_init_mutex);
@@ -96,6 +103,8 @@ bool DolphinApp::OnInit()
   wxHandleFatalExceptions(true);
 #endif
 
+  ParseCommandLine();
+
   UICommon::SetUserDirectory(m_user_path.ToStdString());
   UICommon::CreateDirectories();
   InitLanguageSupport();  // The language setting is loaded from the user directory
@@ -130,60 +139,41 @@ bool DolphinApp::OnInit()
   return true;
 }
 
-void DolphinApp::OnInitCmdLine(wxCmdLineParser& parser)
+void DolphinApp::ParseCommandLine()
 {
-  static const wxCmdLineEntryDesc desc[] = {
-      {wxCMD_LINE_SWITCH, "h", "help", "Show this help message", wxCMD_LINE_VAL_NONE,
-       wxCMD_LINE_OPTION_HELP},
-      {wxCMD_LINE_SWITCH, "d", "debugger", "Opens the debugger", wxCMD_LINE_VAL_NONE,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_SWITCH, "l", "logger", "Opens the logger", wxCMD_LINE_VAL_NONE,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_OPTION, "e", "exec",
-       "Loads the specified file (ELF, DOL, GCM, ISO, TGC, WBFS, CISO, GCZ, WAD)",
-       wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_SWITCH, "b", "batch", "Exit Dolphin with emulator", wxCMD_LINE_VAL_NONE,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_OPTION, "c", "confirm", "Set Confirm on Stop", wxCMD_LINE_VAL_STRING,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_OPTION, "v", "video_backend", "Specify a video backend", wxCMD_LINE_VAL_STRING,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_OPTION, "a", "audio_emulation", "Low level (LLE) or high level (HLE) audio",
-       wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_OPTION, "m", "movie", "Play a movie file", wxCMD_LINE_VAL_STRING,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_OPTION, "u", "user", "User folder path", wxCMD_LINE_VAL_STRING,
-       wxCMD_LINE_PARAM_OPTIONAL},
-      {wxCMD_LINE_NONE, nullptr, nullptr, nullptr, wxCMD_LINE_VAL_NONE, 0}};
+  auto parser = CommandLineParse::CreateParser(CommandLineParse::ParserOptions::IncludeGUIOptions);
+  optparse::Values& options = CommandLineParse::ParseArguments(parser.get(), argc, argv);
+  std::vector<std::string> args = parser->args();
 
-  parser.SetDesc(desc);
-}
-
-bool DolphinApp::OnCmdLineParsed(wxCmdLineParser& parser)
-{
-  if (argc == 2 && File::Exists(argv[1].ToUTF8().data()))
+  if (options.is_set("exec"))
   {
     m_load_file = true;
-    m_file_to_load = argv[1];
+    m_file_to_load = static_cast<const char*>(options.get("exec"));
   }
-  else if (parser.Parse() != 0)
+  else if (args.size())
   {
-    return false;
+    m_load_file = true;
+    m_file_to_load = args.front();
+    args.erase(args.begin());
   }
 
-  if (!m_load_file)
-    m_load_file = parser.Found("exec", &m_file_to_load);
+  m_use_debugger = options.is_set("debugger");
+  m_use_logger = options.is_set("logger");
+  m_batch_mode = options.is_set("batch");
 
-  m_use_debugger = parser.Found("debugger");
-  m_use_logger = parser.Found("logger");
-  m_batch_mode = parser.Found("batch");
-  m_confirm_stop = parser.Found("confirm", &m_confirm_setting);
-  m_select_video_backend = parser.Found("video_backend", &m_video_backend_name);
-  m_select_audio_emulation = parser.Found("audio_emulation", &m_audio_emulation_name);
-  m_play_movie = parser.Found("movie", &m_movie_file);
-  parser.Found("user", &m_user_path);
+  m_confirm_stop = options.is_set("confirm");
+  m_confirm_setting = options.get("confirm");
 
-  return true;
+  m_select_video_backend = options.is_set("video_backend");
+  m_video_backend_name = static_cast<const char*>(options.get("video_backend"));
+
+  m_select_audio_emulation = options.is_set("audio_emulation");
+  m_audio_emulation_name = static_cast<const char*>(options.get("audio_emulation"));
+
+  m_play_movie = options.is_set("movie");
+  m_movie_file = static_cast<const char*>(options.get("movie"));
+
+  m_user_path = static_cast<const char*>(options.get("user"));
 }
 
 #ifdef __APPLE__
@@ -224,12 +214,7 @@ void DolphinApp::AfterInit()
   }
 
   if (m_confirm_stop)
-  {
-    if (m_confirm_setting.Upper() == "TRUE")
-      SConfig::GetInstance().bConfirmStop = true;
-    else if (m_confirm_setting.Upper() == "FALSE")
-      SConfig::GetInstance().bConfirmStop = false;
-  }
+    SConfig::GetInstance().bConfirmStop = m_confirm_setting;
 
   if (m_play_movie && !m_movie_file.empty())
   {

Source/Core/DolphinWX/Main.h

@@ -8,6 +8,7 @@
 #include <wx/app.h>
 
 class CFrame;
+class wxCmdLineParser;
 class wxLocale;
 
 extern CFrame* main_frame;
@@ -21,9 +22,8 @@ public:
 
 private:
   bool OnInit() override;
-  int OnExit() override;
   void OnInitCmdLine(wxCmdLineParser& parser) override;
-  bool OnCmdLineParsed(wxCmdLineParser& parser) override;
+  int OnExit() override;
   void OnFatalException() override;
   bool Initialize(int& c, wxChar** v) override;
 
@@ -37,6 +37,8 @@ private:
   void OnActivate(wxActivateEvent& ev);
   void OnIdle(wxIdleEvent&);
 
+  void ParseCommandLine();
+
   bool m_batch_mode = false;
   bool m_confirm_stop = false;
   bool m_is_active = true;
@@ -46,7 +48,7 @@ private:
   bool m_use_logger = false;
   bool m_select_video_backend = false;
   bool m_select_audio_emulation = false;
-  wxString m_confirm_setting;
+  bool m_confirm_setting;
   wxString m_video_backend_name;
   wxString m_audio_emulation_name;
   wxString m_user_path;

Source/Core/DolphinWX/MainNoGUI.cpp

@@ -2,10 +2,10 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <OptionParser.h>
 #include <cstddef>
 #include <cstdio>
 #include <cstring>
-#include <getopt.h>
 #include <signal.h>
 #include <string>
 #include <thread>
@@ -29,6 +29,7 @@
 #include "Core/IOS/USB/Bluetooth/WiimoteDevice.h"
 #include "Core/State.h"
 
+#include "UICommon/CommandLineParse.h"
 #include "UICommon/UICommon.h"
 
 #include "VideoCommon/RenderBase.h"
@@ -379,37 +380,24 @@ static Platform* GetPlatform()
 
 int main(int argc, char* argv[])
 {
-  int ch, help = 0;
-  struct option longopts[] = {{"exec", no_argument, nullptr, 'e'},
-                              {"help", no_argument, nullptr, 'h'},
-                              {"version", no_argument, nullptr, 'v'},
-                              {nullptr, 0, nullptr, 0}};
+  std::string boot_filename;
+  auto parser = CommandLineParse::CreateParser(CommandLineParse::ParserOptions::OmitGUIOptions);
+  optparse::Values& options = CommandLineParse::ParseArguments(parser.get(), argc, argv);
+  std::vector<std::string> args = parser->args();
 
-  while ((ch = getopt_long(argc, argv, "eh?v", longopts, 0)) != -1)
+  if (options.is_set("exec"))
   {
-    switch (ch)
-    {
-    case 'e':
-      break;
-    case 'h':
-    case '?':
-      help = 1;
-      break;
-    case 'v':
-      fprintf(stderr, "%s\n", scm_rev_str.c_str());
-      return 1;
-    }
+    boot_filename = static_cast<const char*>(options.get("exec"));
   }
-
-  if (help == 1 || argc == optind)
+  else if (args.size())
   {
-    fprintf(stderr, "%s\n\n", scm_rev_str.c_str());
-    fprintf(stderr, "A multi-platform GameCube/Wii emulator\n\n");
-    fprintf(stderr, "Usage: %s [-e <file>] [-h] [-v]\n", argv[0]);
-    fprintf(stderr, "  -e, --exec     Load the specified file\n");
-    fprintf(stderr, "  -h, --help     Show this help message\n");
-    fprintf(stderr, "  -v, --version  Print version and exit\n");
-    return 1;
+    boot_filename = args.front();
+    args.erase(args.begin());
+  }
+  else
+  {
+    parser->print_help();
+    return 0;
   }
 
   platform = GetPlatform();
@@ -435,9 +423,9 @@ int main(int argc, char* argv[])
 
   DolphinAnalytics::Instance()->ReportDolphinStart("nogui");
 
-  if (!BootManager::BootCore(argv[optind]))
+  if (!BootManager::BootCore(boot_filename))
   {
-    fprintf(stderr, "Could not boot %s\n", argv[optind]);
+    fprintf(stderr, "Could not boot %s\n", boot_filename.c_str());
     return 1;
   }
 

Source/Core/UICommon/CMakeLists.txt

@@ -1,8 +1,9 @@
-set(SRCS Disassembler.cpp
+set(SRCS CommandLineParse.cpp
+         Disassembler.cpp
          UICommon.cpp
          USBUtils.cpp)
 
-set(LIBS common)
+set(LIBS common cpp-optparse)
 if(LIBUSB_FOUND)
   set(LIBS ${LIBS} ${LIBUSB_LIBRARIES})
 endif()

Source/Core/UICommon/CommandLineParse.cpp

@@ -0,0 +1,48 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <OptionParser.h>
+
+#include "Common/Common.h"
+#include "UICommon/CommandLineParse.h"
+
+namespace CommandLineParse
+{
+std::unique_ptr<optparse::OptionParser> CreateParser(ParserOptions options)
+{
+  auto parser = std::make_unique<optparse::OptionParser>();
+  parser->usage("usage: %prog [options]... [FILE]...").version(scm_rev_str);
+
+  parser->add_option("--version").action("version").help("Print version and exit");
+
+  parser->add_option("-u", "--user").action("store").help("User folder path");
+  parser->add_option("-m", "--movie").action("store").help("Play a movie file");
+  parser->add_option("-e", "--exec")
+      .action("store")
+      .metavar("<file>")
+      .type("string")
+      .help("Load the specified file");
+
+  if (options == ParserOptions::IncludeGUIOptions)
+  {
+    parser->add_option("-d", "--debugger").action("store_true").help("Opens the debuger");
+    parser->add_option("-l", "--logger").action("store_true").help("Opens the logger");
+    parser->add_option("-b", "--batch").action("store_true").help("Exit Dolphin with emulation");
+    parser->add_option("-c", "--confirm").action("store_true").help("Set Confirm on Stop");
+  }
+
+  // XXX: These two are setting configuration options
+  parser->add_option("-v", "--video_backend").action("store").help("Specify a video backend");
+  parser->add_option("-a", "--audio_emulation")
+      .choices({"HLE", "LLE"})
+      .help("Choose audio emulation from [%choices]");
+
+  return parser;
+}
+
+optparse::Values& ParseArguments(optparse::OptionParser* parser, int argc, char** argv)
+{
+  return parser->parse_args(argc, argv);
+}
+}

Source/Core/UICommon/CommandLineParse.h

@@ -0,0 +1,23 @@
+// Copyright 2017 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include <memory>
+
+namespace optparse
+{
+class OptionParser;
+class Values;
+}
+
+namespace CommandLineParse
+{
+enum class ParserOptions
+{
+  IncludeGUIOptions,
+  OmitGUIOptions,
+};
+
+std::unique_ptr<optparse::OptionParser> CreateParser(ParserOptions options);
+optparse::Values& ParseArguments(optparse::OptionParser* parser, int argc, char** argv);
+}

Source/Core/UICommon/UICommon.vcxproj

@@ -34,6 +34,16 @@
     <Import Project="..\..\VSProps\PCHUse.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(ExternalsDir)zlib;$(ExternalsDir)cpp-optparse;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(ExternalsDir)zlib;$(ExternalsDir)cpp-optparse;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
   <ItemGroup>
     <Text Include="CMakeLists.txt" />
   </ItemGroup>
@@ -43,6 +53,7 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="CommandLineParse.cpp" />
     <ClCompile Include="UICommon.cpp" />
     <ClCompile Include="Disassembler.cpp" />
     <ClCompile Include="USBUtils.cpp">
@@ -50,11 +61,17 @@
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="CommandLineParse.h" />
     <ClInclude Include="UICommon.h" />
     <ClInclude Include="Disassembler.h" />
     <ClInclude Include="USBUtils.h" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(ExternalsDir)cpp-optparse\cpp-optparse.vcxproj">
+      <Project>{C636D9D1-82FE-42B5-9987-63B7D4836341}</Project>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

Source/dolphin-emu.sln

@@ -80,6 +80,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DolphinQt2", "Core\DolphinQ
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "glslang", "..\Externals\glslang\glslang.vcxproj", "{D178061B-84D3-44F9-BEED-EFD18D9033F0}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cpp-optparse", "..\Externals\cpp-optparse\cpp-optparse.vcxproj", "{C636D9D1-82FE-42B5-9987-63B7D4836341}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
@@ -230,6 +232,10 @@ Global
 		{D178061B-84D3-44F9-BEED-EFD18D9033F0}.Debug|x64.Build.0 = Debug|x64
 		{D178061B-84D3-44F9-BEED-EFD18D9033F0}.Release|x64.ActiveCfg = Release|x64
 		{D178061B-84D3-44F9-BEED-EFD18D9033F0}.Release|x64.Build.0 = Release|x64
+		{C636D9D1-82FE-42B5-9987-63B7D4836341}.Debug|x64.ActiveCfg = Debug|x64
+		{C636D9D1-82FE-42B5-9987-63B7D4836341}.Debug|x64.Build.0 = Debug|x64
+		{C636D9D1-82FE-42B5-9987-63B7D4836341}.Release|x64.ActiveCfg = Release|x64
+		{C636D9D1-82FE-42B5-9987-63B7D4836341}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -266,5 +272,6 @@ Global
 		{BB00605C-125F-4A21-B33B-7BF418322DCB} = {87ADDFF9-5768-4DA2-A33B-2477593D6677}
 		{570215B7-E32F-4438-95AE-C8D955F9FCA3} = {AAD1BCD6-9804-44A5-A5FC-4782EA00E9D4}
 		{D178061B-84D3-44F9-BEED-EFD18D9033F0} = {87ADDFF9-5768-4DA2-A33B-2477593D6677}
+		{C636D9D1-82FE-42B5-9987-63B7D4836341} = {87ADDFF9-5768-4DA2-A33B-2477593D6677}
 	EndGlobalSection
 EndGlobal