Added const to argv type for better interoperability. (#98)

* Added const to argv type for better interoperability.

* Fixed example and tests compilation

* Reverted changes to catch.hpp

.clang-format

@@ -1,19 +0,0 @@
----
-Language:        Cpp
-BasedOnStyle:  LLVM
-AccessModifierOffset: 0
-AlignConsecutiveAssignments: true
-AlwaysBreakAfterReturnType: TopLevel
-BreakBeforeBraces: Custom
-BraceWrapping:
-  AfterEnum: true
-  AfterClass: true
-  AfterStruct: true
-  AfterFunction: true
-  AfterNamespace: true
-  AfterControlStatement: Always
-  BeforeElse: true
-ConstructorInitializerIndentWidth: 2
-ContinuationIndentWidth: 2
-PenaltyReturnTypeOnItsOwnLine: 200
-PointerAlignment: Left

.github/workflows/build.yml

@@ -1,24 +0,0 @@
-name: Build cxxopts
-
-on:
-  push:
-    branches: [ $default-branch ]
-  pull_request:
-    branches: [ $default-branch ]
-  workflow_dispatch:
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: setup
-      run: mkdir build; cd build
-    - name: cmake
-      run: cmake ..
-    - name: Build
-      run: make -j$(nproc)
-    - name: test
-      run: ctest

.github/workflows/cifuzz.yml

@@ -1,24 +0,0 @@
-name: CIFuzz
-on: [pull_request]
-jobs:
- Fuzzing:
-   runs-on: ubuntu-latest
-   steps:
-   - name: Build Fuzzers
-     id: build
-     uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
-     with:
-       oss-fuzz-project-name: 'cxxopts'
-       language: c++
-   - name: Run Fuzzers
-     uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
-     with:
-       oss-fuzz-project-name: 'cxxopts'
-       language: c++
-       fuzz-seconds: 300
-   - name: Upload Crash
-     uses: actions/upload-artifact@v3
-     if: failure() && steps.build.outcome == 'success'
-     with:
-       name: artifacts
-       path: ./out/artifacts

.github/workflows/cmake.yml

@@ -1,69 +0,0 @@
-name: CMake
-
-on:
-  push:
-    branches: [ master, main ]
-  pull_request:
-    branches: [ master, main ]
-  workflow_dispatch:
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: Release
-
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build-ubuntu:
-    strategy:
-      matrix:
-        os: [ ubuntu-20.04, ubuntu-22.04 ]
-        compiler: [ g++-9, g++-10, clang++ ]
-
-    name: Build and Test on Ubuntu
-    runs-on: ${{matrix.os}}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Configure CMake
-        run: cmake -S "${{github.workspace}}" -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_COMPILER=${{matrix.compiler}}
-      - name: Build
-        run: cmake --build "${{github.workspace}}/build" --config $BUILD_TYPE
-      - name: Test
-        working-directory: ${{github.workspace}}/build/test
-        run: ctest -C $BUILD_TYPE --output-on-failure
-
-  build-macos:
-    name: Build and Test on MacOS
-    strategy:
-      matrix:
-        os: [ macos-11, macos-12 ]
-    runs-on: ${{matrix.os}}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Configure CMake
-        run: cmake -S "${{github.workspace}}" -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-      - name: Show compile commands
-        run: cat build/compile_commands.json
-      - name: Build
-        run: cmake --build "${{github.workspace}}/build" --config $BUILD_TYPE
-      - name: Test
-        working-directory: ${{github.workspace}}/build/test
-        shell: bash
-        run: ctest -C $BUILD_TYPE --output-on-failure
-
-  build-windows:
-    name: Build and Test on Windows
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ilammy/msvc-dev-cmd@v1
-      - name: Configure CMake
-        run: cmake -S "${{github.workspace}}" -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -T "ClangCl"
-      - name: Build
-        run: cmake --build "${{github.workspace}}/build" --config $BUILD_TYPE
-      - name: Test
-        working-directory: ${{github.workspace}}/build/test
-        run: cd $BUILD_TYPE && ./link_test && ./options_test

.gitignore

@@ -1,77 +1,8 @@
-syntax: glob
-
-# Temporary, cache, swap files
-\#\#* 
 *.swp
-*.bkp
-
-# Files which "ask" to be hidden
-*~
-.*
-unused/
-
-# Build artifacts
-*.a
-*.o
-*.so
-*.ptx
-bin/*
-lib/*
-build/
-build-*/
-bazel-*
-
-# Core dumps
-core
-core.*
-core-*
-
-# CMake & CTest-generated files
+build*
 CMakeCache.txt
-CMakeFiles/
-cmake_install.cmake
-CMakeScripts/*
-CMakeTmp/*
 Makefile
-CTestTestfile.cmake
+CMakeFiles/
 Testing/
-
-# Eclise IDE-related files
-.project
-.cproject
-.settings
-
-# CLion IDE-related files
-.idea/
-cmake-build-*/
-
-# Patching
-*.diff
-*.rej
-*.orig
-
-# Files/folders downloaded from other repositories as part of the build
-external/*
-third-party/*
-
-# Miscellaneous
-tags
-log
-*.log
-*.v3breakpoints
-gmon.out
-.DS_Store
-
-# Doxygen
-doxygen.log
-Doxyfile
-docs/
-
-# Archives
-*.zip
-*.gz
-*.bz2
-*.tgz
-*.tar
-*.xz
-
+CTestTestfile.cmake
+cmake_install.cmake

.tipi/deps

@@ -1 +0,0 @@
-{ }

.tipi/opts

@@ -1 +0,0 @@
- 

.travis.yml

@@ -2,47 +2,18 @@ sudo: required
 dist: trusty
 language: cpp
 os:
-  - linux
+  - osx
 matrix:
   include:
-    - os: linux
-      env: COMPILER=g++-6
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources: &sources
-            - llvm-toolchain-trusty-3.8
-            - llvm-toolchain-trusty-5.0
-            - ubuntu-toolchain-r-test
-    - os: linux
-      env: COMPILER=g++-6 UNICODE_OPTIONS=-DCXXOPTS_USE_UNICODE_HELP=Yes
-      addons:
-        apt:
-          packages:
-            - g++-6
-          sources: *sources
-    - os: linux
-      env: COMPILER=g++-7
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources: *sources
-    - os: linux
-      env: COMPILER=g++-7 UNICODE_OPTIONS=-DCXXOPTS_USE_UNICODE_HELP=Yes
-      addons:
-        apt:
-          packages:
-            - g++-7
-          sources: *sources
     - os: linux
       env: COMPILER=g++-5
       addons:
         apt:
           packages:
             - g++-5
-          sources: *sources
+          sources: &sources
+            - llvm-toolchain-precise-3.8
+            - ubuntu-toolchain-r-test
     - os: linux
       env: COMPILER=g++-5 UNICODE_OPTIONS=-DCXXOPTS_USE_UNICODE_HELP=Yes
       addons:
@@ -50,20 +21,6 @@ matrix:
           packages:
             - g++-5
           sources: *sources
-    - os: linux
-      env: COMPILER=g++-4.8
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources: *sources
-    - os: linux
-      env: COMPILER=g++-4.8 UNICODE_OPTIONS=-DCXXOPTS_USE_UNICODE_HELP=Yes
-      addons:
-        apt:
-          packages:
-            - g++-4.8
-          sources: *sources
     - os: linux
       env: COMPILER=clang++-3.8 CXXFLAGS=-stdlib=libc++
       addons:
@@ -80,17 +37,9 @@ matrix:
             - clang-3.8
             - libc++-dev
           sources: *sources
-    - os: linux
-      env: COMPILER=clang++-5.0 CMAKE_OPTIONS=-DCXXOPTS_CXX_STANDARD=17
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-            - g++-5
-          sources: *sources
 script: >
-    cmake -Werror=dev -DCXXOPTS_BUILD_TESTS=ON -DCMAKE_CXX_COMPILER=$COMPILER
-    -DCMAKE_CXX_FLAGS=$CXXFLAGS $UNICODE_OPTIONS $CMAKE_OPTIONS .
+    cmake -DCXXOPTS_BUILD_TESTS=ON -DCMAKE_CXX_COMPILER=$COMPILER
+    -DCMAKE_CXX_FLAGS=$CXXFLAGS $UNICODE_OPTIONS .
     && make && make ARGS=--output-on-failure test
 
 before_install:

BUILD.bazel

@@ -1,16 +0,0 @@
-load("@rules_cc//cc:defs.bzl", "cc_library")
-
-cc_library(
-    name = "cxxopts",
-    hdrs = ["include/cxxopts.hpp"],
-    strip_include_prefix = "include",
-    visibility = ["//visibility:public"],
-)
-
-load("@rules_fuzzing//fuzzing:cc_defs.bzl", "cc_fuzz_test")
-
-cc_fuzz_test(
-    name = "cxxopts_fuzz_test",
-    srcs = ["test/fuzz.cpp"],
-    deps = [":cxxopts"],
-)

CHANGELOG.md

@@ -1,163 +0,0 @@
-# Changelog
-
-This is the changelog for `cxxopts`, a C++11 library for parsing command line
-options. The project adheres to semantic versioning.
-
-## 3.2.1
-
-### Bug fixes
-
-* Fix compilation with optional on C++20.
-
-## 3.2
-
-### Bug fixes
-
-* Fix unannotated fallthrough.
-* Fix sign conversion with Unicode output.
-* Don't initialize regex in static initialiser.
-* Fix incorrect integer overflow checks.
-
-### Added
-
-* Add fuzzing to CI
-
-### Changed
-
-* Change quote output to '' to match Windows.
-* Don't split positional arguments by the list delimiter.
-* Order help groups by the order they were added.
-
-## 3.1.1
-
-### Bug Fixes
-
-* Fixed version number in header.
-* Fixed cast warning in Unicode function.
-
-## 3.1
-
-### Added
-
-* Support for multiple long names for the same option (= multiple long aliases)
-* Add a `program()` function to retrieve the program name.
-* Added a .clang-format file.
-* Added iterator and printing for a ParseResult.
-
-### Changed
-
-* Cleanup exception code, add cxxopts::exceptions namespace.
-* Renamed several exceptions to be more descriptive, and added to a nested namespace.
-
-### Bug Fixes
-
-* Fix `arguments()` having no key for options that only have a short name.
-
-## 3.0
-
-### Changed
-
-* Only search for a C++ compiler in CMakeLists.txt.
-* Allow for exceptions to be disabled.
-* Fix duplicate default options when there is a short and long option.
-* Add `CXXOPTS_NO_EXCEPTIONS` to disable exceptions.
-* Fix char parsing for space and check for length.
-* Change argument type in `Options::parse` from `char**` to `const char**`.
-* Refactor parser to not change its arguments.
-* `ParseResult` doesn't depend on a reference to the parser.
-* Fixed several warnings and code quality issues.
-* Improved formatting for help descriptions.
-* Improve integer parsing.
-
-### Added
-
-* A list of unmatched arguments is available in `ParseResult`.
-* Support single letter options with argument attached.
-* Use <optional> if it is present.
-
-### Bug Fixes
-
-* Fix missing option name in exception.
-
-## 2.2
-
-### Changed
-
-* Allow integers to have leading zeroes.
-* Build the tests by default.
-* Don't check for container when showing positional help.
-
-### Added
-
-* Iterator inputs to `parse_positional`.
-* Throw an exception if the option in `parse_positional` doesn't exist.
-* Parse a delimited list in a single argument for vector options.
-* Add an option to disable implicit value on booleans.
-
-### Bug Fixes
-
-* Fix a warning about possible loss of data.
-* Fix version numbering in CMakeLists.txt
-* Remove unused declaration of the undefined `ParseResult::get_option`.
-* Throw on invalid option syntax when beginning with a `-`.
-* Throw in `as` when option wasn't present.
-* Fix catching exceptions by reference.
-* Fix out of bounds errors parsing integers.
-
-## 2.1.1
-
-### Bug Fixes
-
-* Revert the change adding `const` type for `argv`, because most users expect
-  to pass a non-const `argv` from `main`.
-
-## 2.1
-
-### Changed
-
-* Options with implicit arguments now require the `--option=value` form if
-  they are to be specified with an option. This is to remove the ambiguity
-  when a positional argument could follow an option with an implicit value.
-  For example, `--foo value`, where `foo` has an implicit value, will be
-  parsed as `--foo=implicit` and a positional argument `value`.
-* Boolean values are no longer special, but are just an option with a default
-  and implicit value.
-
-### Added
-
-* Added support for `std::optional` as a storage type.
-* Allow the help string to be customised.
-* Use `const` for the type in the `argv` parameter, since the contents of the
-  arguments is never modified.
-
-### Bug Fixes
-
-* Building against GCC 4.9 was broken due to overly strict shadow warnings.
-* Fixed an ambiguous overload in the `parse_positional` function when an
-  `initializer_list` was directly passed.
-* Fixed precedence in the Boolean value regex.
-
-## 2.0
-
-### Changed
-
-* `Options::parse` returns a ParseResult rather than storing the parse
-  result internally.
-* Options with default values now get counted as appearing once if they
-  were not specified by the user.
-
-### Added
-
-* A new `ParseResult` object that is the immutable result of parsing. It
-  responds to the same `count` and `operator[]` as `Options` of 1.x did.
-* The function `ParseResult::arguments` returns a vector of the parsed
-  arguments to iterate through in the order they were provided.
-* The symbol `cxxopts::version` for the version of the library.
-* Booleans can be specified with various strings and explicitly set false.
-
-## 1.x
-
-The 1.x series was the first major version of the library, with release numbers
-starting to follow semantic versioning, after 0.x being unstable.  It never had
-a changelog maintained for it. Releases mostly contained bug fixes, with the
-occasional feature added.

CMakeLists.txt

@@ -1,15 +1,15 @@
 # Copyright (c) 2014 Jarryd Beck
-#
+# 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
-#
+# 
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
-#
+# 
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -17,66 +17,72 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
-cmake_minimum_required(VERSION 3.1...3.19)
+cmake_minimum_required(VERSION 3.1)
+project(cxxopts)
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
-include(cxxopts)
-set("PROJECT_DESCRIPTION" "A header-only lightweight C++ command line option parser")
-set("PROJECT_HOMEPAGE_URL" "https://github.com/jarro2783/cxxopts")
+enable_testing()
 
-# Get the version of the library
-cxxopts_getversion(VERSION)
+set(VERSION "1.2.0")
 
-project(cxxopts
-    VERSION "${VERSION}"
-    LANGUAGES CXX
-)
+option(CXXOPTS_BUILD_EXAMPLES "Set to ON to build examples" ON)
+option(CXXOPTS_BUILD_TESTS "Set to ON to build tests" OFF)
 
-# Must include after the project call due to GNUInstallDirs requiring a language be enabled (IE. CXX)
-include(GNUInstallDirs)
-
-# Determine whether this is a standalone project or included by other projects
-set(CXXOPTS_STANDALONE_PROJECT OFF)
-if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    set(CXXOPTS_STANDALONE_PROJECT ON)
-endif()
-
-# Establish the project options
-option(CXXOPTS_BUILD_EXAMPLES "Set to ON to build examples" ${CXXOPTS_STANDALONE_PROJECT})
-option(CXXOPTS_BUILD_TESTS "Set to ON to build tests" ${CXXOPTS_STANDALONE_PROJECT})
-option(CXXOPTS_ENABLE_INSTALL "Generate the install target" ${CXXOPTS_STANDALONE_PROJECT})
-option(CXXOPTS_ENABLE_WARNINGS "Add warnings to CMAKE_CXX_FLAGS" ${CXXOPTS_STANDALONE_PROJECT})
-option(CXXOPTS_USE_UNICODE_HELP "Use ICU Unicode library" OFF)
-
-if (CXXOPTS_STANDALONE_PROJECT)
-    cxxopts_set_cxx_standard()
-endif()
-
-if (CXXOPTS_ENABLE_WARNINGS)
-    cxxopts_enable_warnings()
+# request c++11 without gnu extension for the whole project and enable more warnings
+set(CMAKE_CXX_STANDARD   11)
+set(CMAKE_CXX_EXTENSIONS OFF)
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W2")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "[Cc]lang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra -Wshadow")
 endif()
 
 add_library(cxxopts INTERFACE)
-add_library(cxxopts::cxxopts ALIAS cxxopts)
-add_subdirectory(include)
 
-# Link against the ICU library when requested
+# optionally, enable unicode support using the ICU library
+set(CXXOPTS_USE_UNICODE_HELP FALSE CACHE BOOL "Use ICU Unicode library")
 if(CXXOPTS_USE_UNICODE_HELP)
-    cxxopts_use_unicode()
+    find_package(PkgConfig)
+    pkg_check_modules(ICU REQUIRED icu-uc)
+
+    target_link_libraries(cxxopts INTERFACE ${ICU_LDFLAGS})
+    target_compile_options(cxxopts INTERFACE ${ICU_CFLAGS})
+    target_compile_definitions(cxxopts INTERFACE CXXOPTS_USE_UNICODE)
 endif()
 
-# Install cxxopts when requested by the user
-if (CXXOPTS_ENABLE_INSTALL)
-    cxxopts_install_logic()
-endif()
+target_include_directories(cxxopts INTERFACE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+    )
 
-# Build examples when requested by the user
-if (CXXOPTS_BUILD_EXAMPLES)
-    add_subdirectory(src)
-endif()
+include(CMakePackageConfigHelpers)
+set(CXXOPTS_CMAKE_DIR "lib/cmake/cxxopts" CACHE STRING
+  "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.")
+set(version_config "${PROJECT_BINARY_DIR}/cxxopts-config-version.cmake")
+set(project_config "${PROJECT_BINARY_DIR}/cxxopts-config.cmake")
+set(targets_export_name cxxopts-targets)
 
-# Enable testing when requested by the user
-if (CXXOPTS_BUILD_TESTS)
-    enable_testing()
-    add_subdirectory(test)
-endif()
+# Generate the version, config and target files into the build directory.
+write_basic_package_version_file(
+    ${version_config}
+    VERSION ${VERSION}
+    COMPATIBILITY AnyNewerVersion)
+configure_package_config_file(
+    ${PROJECT_SOURCE_DIR}/cxxopts-config.cmake.in
+    ${project_config}
+    INSTALL_DESTINATION ${CXXOPTS_CMAKE_DIR})
+export(TARGETS cxxopts NAMESPACE cxxopts::
+    FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
+
+# Install version, config and target files.
+install(
+    FILES ${project_config} ${version_config}
+    DESTINATION ${CXXOPTS_CMAKE_DIR})
+install(EXPORT ${targets_export_name} DESTINATION ${CXXOPTS_CMAKE_DIR}
+    NAMESPACE cxxopts::)
+
+# Install the header file and export the target
+install(TARGETS cxxopts EXPORT ${targets_export_name} DESTINATION lib)
+install(FILES ${PROJECT_SOURCE_DIR}/include/cxxopts.hpp DESTINATION include)
+
+add_subdirectory(src)
+add_subdirectory(test)

INSTALL

@@ -1,46 +1,10 @@
-== System installation ==
+It is preferable to build out of source.
 
-This library is header only. So you can either copy `include/cxxopts.hpp` to `/usr/include` or `/usr/local/include`, or add `include` to your search path.
+cmake ${CXXOPTS_DIR}
+make
 
-== Building the examples and tests ==
-
-It is preferable to build out of source. Make a build directory somewhere, and then
-do the following, where `${CXXOPTS_DIR}` is the path that you checked out `cxxopts`
-to:
-
-  cmake ${CXXOPTS_DIR}
-  make
 
 You can use another build tool, such as ninja.
 
-  cmake -G Ninja ${CXXOPTS_DIR}
-  ninja
-
-
-To run the tests, you have to configure `cxxopts` with another flag:
-   cmake -D CXXOPTS_BUILD_TESTS=On ${CXXOPTS_DIR}
-   make
-   make test
-
-== Using cxxopts in tipi.build projects ==
-
-`cxxopts` can be easily used in [tipi.build](https://tipi.build) projects simply by adding the following entry to your `.tipi/deps`:
-
-```json
-{
-  "jarro2783/cxxopts": { "@": "v3.0.0" }
-}
-```
-
-To try this you can run the following command in `/src` (change the target name appropriately to `linux` or `macos` or `windows`):
-
-```bash
-tipi . -t <target>
-./build/linux-cxx17/bin/test_package -v
-```
-
-To develop `cxxopts` using tipi run the following command at the root of the repository:
-
-```bash
-tipi . -t <target> --test all -v
-```
+cmake -G Ninja ${CXXOPTS_DIR}
+ninja

README.md

@@ -1,29 +1,5 @@
 [![Build Status](https://travis-ci.org/jarro2783/cxxopts.svg?branch=master)](https://travis-ci.org/jarro2783/cxxopts)
 
-# Release versions
-
-Note that `master` is generally a work in progress, and you probably want to use a
-tagged release version.
-
-## Version 3 breaking changes
-
-If you have used version 2, there are a couple of breaking changes in version 3
-that you should be aware of. If you are new to `cxxopts` you can skip this
-section.
-
-The parser no longer modifies its arguments, so you can pass a const `argc` and
-`argv` and expect them not to be changed.
-
-The `ParseResult` object no longer depends on the parser. So it can be returned
-from a scope outside the parser and still work. Now that the inputs are not
-modified, `ParseResult` stores a list of the unmatched arguments. These are
-retrieved like follows:
-
-```cpp
-auto result = options.parse(argc, argv);
-result.unmatched(); // get the unmatched arguments
-```
-
 # Quick start
 
 This is a lightweight C++ option parser library, supporting the standard GNU
@@ -44,26 +20,18 @@ Additionally, anything after `--` will be parsed as a positional argument.
 
 ## Basics
 
-```cpp
-#include <cxxopts.hpp>
-```
+    #include <cxxopts.hpp>
 
-Create a `cxxopts::Options` instance.
+Create a cxxopts::Options instance.
 
-```cpp
-cxxopts::Options options("MyProgram", "One line description of MyProgram");
-```
+    cxxopts::Options options("MyProgram", "One line description of MyProgram");
 
 Then use `add_options`.
 
-```cpp
-options.add_options()
-  ("d,debug", "Enable debugging") // a bool parameter
-  ("i,integer", "Int param", cxxopts::value<int>())
-  ("f,file", "File name", cxxopts::value<std::string>())
-  ("v,verbose", "Verbose output", cxxopts::value<bool>()->default_value("false"))
-  ;
-```
+    options.add_options()
+      ("d,debug", "Enable debugging")
+      ("f,file", "File name", cxxopts::value<std::string>())
+      ;
 
 Options are declared with a long and an optional short option. A description
 must be provided. The third argument is the value, if omitted it is boolean.
@@ -71,48 +39,16 @@ Any type can be given as long as it can be parsed, with operator>>.
 
 To parse the command line do:
 
-```cpp
-auto result = options.parse(argc, argv);
-```
+    options.parse(argc, argv);
 
-To retrieve an option use `result.count("option")` to get the number of times
+To retrieve an option use `options.count("option")` to get the number of times
 it appeared, and
 
-```cpp
-result["opt"].as<type>()
-```
+    options["opt"].as<type>()
 
 to get its value. If "opt" doesn't exist, or isn't of the right type, then an
 exception will be thrown.
 
-## Unrecognised arguments
-
-You can allow unrecognised arguments to be skipped. This applies to both
-positional arguments that are not parsed into another option, and `--`
-arguments that do not match an argument that you specify. This is done by
-calling:
-
-```cpp
-options.allow_unrecognised_options();
-```
-
-and in the result object they are retrieved with:
-
-```cpp
-result.unmatched()
-```
-
-## Exceptions
-
-Exceptional situations throw C++ exceptions. There are two types of
-exceptions: errors defining the options, and errors when parsing a list of
-arguments. All exceptions derive from `cxxopts::exceptions::exception`. Errors
-defining options derive from `cxxopts::exceptions::specification` and errors
-parsing arguments derive from `cxxopts::exceptions::parsing`.
-
-All exceptions define a `what()` function to get a printable string
-explaining the error.
-
 ## Help groups
 
 Options can be placed into groups for the purposes of displaying help messages.
@@ -122,37 +58,13 @@ vector to the `help` function.
 
 ## Positional Arguments
 
-Positional arguments are those given without a preceding flag and can be used
-alongside non-positional arguments. There may be multiple positional arguments,
-and the final positional argument may be a container type to hold a list of all
-remaining positionals.
+Positional arguments can be optionally parsed into one or more options.
+To set up positional arguments, call
 
-To set up positional arguments, first declare the options, then configure a
-set of those arguments as positional like:
+    options.parse_positional({"first", "second", "last"})
 
-```cpp
-options.add_options()
-  ("script", "The script file to execute", cxxopts::value<std::string>())
-  ("server", "The server to execute on", cxxopts::value<std::string>())
-  ("filenames", "The filename(s) to process", cxxopts::value<std::vector<std::string>>());
-
-options.parse_positional({"script", "server", "filenames"});
-
-// Parse options the usual way
-options.parse(argc, argv);
-```
-
-For example, parsing the following arguments:
-~~~
-my_script.py my_server.com file1.txt file2.txt file3.txt
-~~~
-will result in parsed arguments like the following table:
-
-| Field         | Value                                     |
-| ------------- | ----------------------------------------- |
-| `"script"`    | `"my_script.py"`                          |
-| `"server"`    | `"my_server.com"`                         |
-| `"filenames"` | `{"file1.txt", "file2.txt", "file3.txt"}` |
+where "last" should be the name of an option with a container type, and the
+others should have a single value.
 
 ## Default and implicit values
 
@@ -161,117 +73,29 @@ An option can be declared with a default or an implicit value, or both.
 A default value is the value that an option takes when it is not specified
 on the command line. The following specifies a default value for an option:
 
-```cpp
-cxxopts::value<std::string>()->default_value("value")
-```
+    cxxopts::value<std::string>()->default_value("value")
 
 An implicit value is the value that an option takes when it is given on the
 command line without an argument. The following specifies an implicit value:
 
-```cpp
-cxxopts::value<std::string>()->implicit_value("implicit")
-```
+    cxxopts::value<std::string>()->implicit_value("implicit")
 
 If an option had both, then not specifying it would give the value `"value"`,
 writing it on the command line as `--option` would give the value `"implicit"`,
 and writing `--option=another` would give it the value `"another"`.
 
-Note that the default and implicit value is always stored as a string,
-regardless of the type that you want to store it in. It will be parsed as
-though it was given on the command line.
-
-Default values are not counted by `Options::count`.
-
-## Boolean values
-
-Boolean options have a default implicit value of `"true"`, which can be
-overridden. The effect is that writing `-o` by itself will set option `o` to
-`true`. However, they can also be written with various strings using `=value`.
-There is no way to disambiguate positional arguments from the value following
-a boolean, so we have chosen that they will be positional arguments, and
-therefore, `-o false` does not work.
-
-## `std::vector<T>` values
-
-Parsing a list of values into a `std::vector<T>` is also supported, as long as `T`
-can be parsed. To separate single values in a list the define symbol `CXXOPTS_VECTOR_DELIMITER`
-is used, which is ',' by default. Ensure that you use no whitespaces between values because
-those would be interpreted as the next command line option. Example for a command line option
-that can be parsed as a `std::vector<double>`:
-
-~~~
---my_list=1,-2.1,3,4.5
-~~~
-
-## Options specified multiple times
-
-The same option can be specified several times, with different arguments, which will all
-be recorded in order of appearance. An example:
-
-~~~
---use train --use bus --use ferry
-~~~
-
-this is supported through the use of a vector of value for the option:
-
-~~~
-options.add_options()
-  ("use", "Usable means of transport", cxxopts::value<std::vector<std::string>>())
-~~~
-
-## Custom help
-
-The string after the program name on the first line of the help can be
-completely replaced by calling `options.custom_help`. Note that you might
-also want to override the positional help by calling `options.positional_help`.
-
-
-## Example
-
-Putting all together:
-```cpp
-int main(int argc, char** argv)
-{
-    cxxopts::Options options("test", "A brief description");
-
-    options.add_options()
-        ("b,bar", "Param bar", cxxopts::value<std::string>())
-        ("d,debug", "Enable debugging", cxxopts::value<bool>()->default_value("false"))
-        ("f,foo", "Param foo", cxxopts::value<int>()->default_value("10"))
-        ("h,help", "Print usage")
-    ;
-
-    auto result = options.parse(argc, argv);
-
-    if (result.count("help"))
-    {
-      std::cout << options.help() << std::endl;
-      exit(0);
-    }
-    bool debug = result["debug"].as<bool>();
-    std::string bar;
-    if (result.count("bar"))
-      bar = result["bar"].as<std::string>();
-    int foo = result["foo"].as<int>();
-
-    return 0;
-}
-```
-
 # Linking
 
 This is a header only library.
 
 # Requirements
 
-The only build requirement is a C++ compiler that supports C++11 features such as:
+The only build requirement is a C++ compiler that supports C++11 regular
+expressions. For example GCC >= 4.9 or clang with libc++.
 
-* regex
-* constexpr
-* default constructors
 
-GCC >= 4.9 or clang >= 3.1 with libc++ are known to work.
+# TODO list
 
-The following compilers are known not to work:
-
-* MSVC 2013
+* Allow unrecognised options.
+* Various help strings.
+* Unicode aware for help strings.

WORKSPACE

@@ -1,16 +0,0 @@
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-http_archive(
-    name = "rules_fuzzing",
-    sha256 = "d9002dd3cd6437017f08593124fdd1b13b3473c7b929ceb0e60d317cb9346118",
-    strip_prefix = "rules_fuzzing-0.3.2",
-    urls = ["https://github.com/bazelbuild/rules_fuzzing/archive/v0.3.2.zip"],
-)
-
-load("@rules_fuzzing//fuzzing:repositories.bzl", "rules_fuzzing_dependencies")
-
-rules_fuzzing_dependencies()
-
-load("@rules_fuzzing//fuzzing:init.bzl", "rules_fuzzing_init")
-
-rules_fuzzing_init()

cmake/cxxopts.cmake

@@ -1,163 +0,0 @@
-# Copyright (c) 2014 Jarryd Beck
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-if (CMAKE_VERSION VERSION_GREATER 3.10 OR CMAKE_VERSION VERSION_EQUAL 3.10)
-    # Use include_guard() added in cmake 3.10
-    include_guard()
-endif()
-
-include(CMakePackageConfigHelpers)
-
-function(cxxopts_getversion version_arg)
-    # Parse the current version from the cxxopts header
-    file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/cxxopts.hpp" cxxopts_version_defines
-        REGEX "#define CXXOPTS__VERSION_(MAJOR|MINOR|PATCH)")
-    foreach(ver ${cxxopts_version_defines})
-        if(ver MATCHES "#define CXXOPTS__VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$")
-            set(CXXOPTS__VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}" CACHE INTERNAL "")
-        endif()
-    endforeach()
-    set(VERSION ${CXXOPTS__VERSION_MAJOR}.${CXXOPTS__VERSION_MINOR}.${CXXOPTS__VERSION_PATCH})
-
-    # Give feedback to the user. Prefer DEBUG when available since large projects tend to have a lot
-    # going on already
-    if (CMAKE_VERSION VERSION_GREATER 3.15 OR CMAKE_VERSION VERSION_EQUAL 3.15)
-        message(DEBUG "cxxopts version ${VERSION}")
-    else()
-        message(STATUS "cxxopts version ${VERSION}")
-    endif()
-
-    # Return the information to the caller
-    set(${version_arg} ${VERSION} PARENT_SCOPE)
-endfunction()
-
-# Optionally, enable unicode support using the ICU library
-function(cxxopts_use_unicode)
-    find_package(PkgConfig)
-    pkg_check_modules(ICU REQUIRED icu-uc)
-
-    target_link_libraries(cxxopts INTERFACE ${ICU_LDFLAGS})
-    target_compile_options(cxxopts INTERFACE ${ICU_CFLAGS})
-    target_compile_definitions(cxxopts INTERFACE CXXOPTS_USE_UNICODE)
-endfunction()
-
-# Request C++11 without gnu extension for the whole project and enable more warnings
-macro(cxxopts_set_cxx_standard)
-    if (CXXOPTS_CXX_STANDARD)
-        set(CMAKE_CXX_STANDARD ${CXXOPTS_CXX_STANDARD})
-    else()
-        set(CMAKE_CXX_STANDARD 11)
-    endif()
-
-    set(CMAKE_CXX_EXTENSIONS OFF)
-endmacro()
-
-# Helper function to enable warnings
-function(cxxopts_enable_warnings)
-    if(MSVC)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W2")
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "[Cc]lang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-      if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-          if (${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL 5.0)
-            set(COMPILER_SPECIFIC_FLAGS "-Wsuggest-override")
-          endif()
-      endif()
-
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra -Wshadow -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion ${COMPILER_SPECIFIC_FLAGS}")
-    endif()
-
-    set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} PARENT_SCOPE)
-endfunction()
-
-# Helper function to ecapsulate install logic
-function(cxxopts_install_logic)
-    if(CMAKE_LIBRARY_ARCHITECTURE)
-        string(REPLACE "/${CMAKE_LIBRARY_ARCHITECTURE}" "" CMAKE_INSTALL_LIBDIR_ARCHIND "${CMAKE_INSTALL_LIBDIR}")
-    else()
-        # On some systems (e.g. NixOS), `CMAKE_LIBRARY_ARCHITECTURE` can be empty
-        set(CMAKE_INSTALL_LIBDIR_ARCHIND "${CMAKE_INSTALL_LIBDIR}")
-    endif()
-    set(CXXOPTS_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR_ARCHIND}/cmake/cxxopts" CACHE STRING "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.")
-    set(version_config "${PROJECT_BINARY_DIR}/cxxopts-config-version.cmake")
-    set(project_config "${PROJECT_BINARY_DIR}/cxxopts-config.cmake")
-    set(targets_export_name cxxopts-targets)
-    set(PackagingTemplatesDir "${PROJECT_SOURCE_DIR}/packaging")
-
-
-    if(${CMAKE_VERSION} VERSION_GREATER "3.14")
-        set(OPTIONAL_ARCH_INDEPENDENT "ARCH_INDEPENDENT")
-    endif()
-
-    # Generate the version, config and target files into the build directory.
-    write_basic_package_version_file(
-        ${version_config}
-        VERSION ${VERSION}
-        COMPATIBILITY AnyNewerVersion
-        ${OPTIONAL_ARCH_INDEPENDENT}
-    )
-    configure_package_config_file(
-        ${PackagingTemplatesDir}/cxxopts-config.cmake.in
-        ${project_config}
-        INSTALL_DESTINATION ${CXXOPTS_CMAKE_DIR})
-    export(TARGETS cxxopts NAMESPACE cxxopts::
-        FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
-
-    # Install version, config and target files.
-    install(
-        FILES ${project_config} ${version_config}
-        DESTINATION ${CXXOPTS_CMAKE_DIR})
-    install(EXPORT ${targets_export_name} DESTINATION ${CXXOPTS_CMAKE_DIR}
-        NAMESPACE cxxopts::)
-
-    # Install the header file and export the target
-    install(TARGETS cxxopts EXPORT ${targets_export_name} DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    install(FILES ${PROJECT_SOURCE_DIR}/include/cxxopts.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-
-    set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
-    set(CPACK_PACKAGE_VENDOR "cxxopt developers")
-    set(CPACK_PACKAGE_DESCRIPTION "${PROJECT_DESCRIPTION}")
-    set(CPACK_DEBIAN_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-    set(CPACK_RPM_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-    set(CPACK_PACKAGE_HOMEPAGE_URL "${PROJECT_HOMEPAGE_URL}")
-    set(CPACK_PACKAGE_MAINTAINER "${CPACK_PACKAGE_VENDOR}")
-    set(CPACK_DEBIAN_PACKAGE_MAINTAINER "${CPACK_PACKAGE_MAINTAINER}")
-    set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
-    set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
-
-    set(CPACK_DEBIAN_PACKAGE_NAME "lib${PROJECT_NAME}-dev")
-    set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6-dev")
-    set(CPACK_DEBIAN_PACKAGE_SUGGESTS "cmake, pkg-config, pkg-conf")
-
-    set(CPACK_RPM_PACKAGE_NAME "lib${PROJECT_NAME}-devel")
-    set(CPACK_RPM_PACKAGE_SUGGESTS "${CPACK_DEBIAN_PACKAGE_SUGGESTS}")
-
-    set(CPACK_DEB_COMPONENT_INSTALL ON)
-    set(CPACK_RPM_COMPONENT_INSTALL ON)
-    set(CPACK_NSIS_COMPONENT_INSTALL ON)
-    set(CPACK_DEBIAN_COMPRESSION_TYPE "xz")
-
-    set(PKG_CONFIG_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc")
-    configure_file("${PackagingTemplatesDir}/pkgconfig.pc.in" "${PKG_CONFIG_FILE_NAME}" @ONLY)
-    install(FILES "${PKG_CONFIG_FILE_NAME}"
-            DESTINATION "${CMAKE_INSTALL_LIBDIR_ARCHIND}/pkgconfig"
-    )
-
-    include(CPack)
-endfunction()

include/CMakeLists.txt

@@ -1,23 +0,0 @@
-# Copyright (c) 2014 Jarryd Beck
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-target_include_directories(cxxopts INTERFACE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-    $<INSTALL_INTERFACE:include>
-)

packaging/pkgconfig.pc.in

@@ -1,7 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
-
-Name: @PROJECT_NAME@
-Description: @PROJECT_DESCRIPTION@
-Version: @PROJECT_VERSION@
-Cflags: -I${includedir}

src/.tipi/deps

@@ -1,3 +0,0 @@
-{
-    "jarro2783/cxxopts": { }
-}

src/CMakeLists.txt

@@ -1,15 +1,15 @@
 # Copyright (c) 2014 Jarryd Beck
-#
+# 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
-#
+# 
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
-#
+# 
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -18,7 +18,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-add_executable(example example.cpp)
-target_link_libraries(example cxxopts)
-
-set_property(TARGET example PROPERTY CXX_STANDARD 17)
+if(CXXOPTS_BUILD_EXAMPLES)
+    add_executable(example example.cpp)
+    target_link_libraries(example cxxopts)
+endif()

src/example.cpp

@@ -21,51 +21,36 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
 */
-#include "cxxopts.hpp"
 
 #include <iostream>
-#include <memory>
 
-int
-parse(int argc, const char* argv[])
+#include "cxxopts.hpp"
+
+int main(int argc, const char* argv[])
 {
   try
   {
-    std::unique_ptr<cxxopts::Options> allocated(new cxxopts::Options(argv[0], " - example command line options"));
-    auto& options = *allocated;
-    options
-      .positional_help("[optional args]")
-      .show_positional_help();
+    cxxopts::Options options(argv[0], " - example command line options");
+    options.positional_help("[optional args]");
 
     bool apple = false;
 
-    options
-      .set_width(70)
-      .set_tab_expansion()
-      .allow_unrecognised_options()
-      .add_options()
-      ("a,apple,ringo", "an apple", cxxopts::value<bool>(apple))
+    options.add_options()
+      ("a,apple", "an apple", cxxopts::value<bool>(apple))
       ("b,bob", "Bob")
-      ("char", "A character", cxxopts::value<char>())
-      ("t,true", "True", cxxopts::value<bool>()->default_value("true"))
       ("f, file", "File", cxxopts::value<std::vector<std::string>>(), "FILE")
       ("i,input", "Input", cxxopts::value<std::string>())
       ("o,output", "Output file", cxxopts::value<std::string>()
           ->default_value("a.out")->implicit_value("b.def"), "BIN")
-      ("x", "A short-only option", cxxopts::value<std::string>())
       ("positional",
         "Positional arguments: these are the arguments that are entered "
         "without an option", cxxopts::value<std::vector<std::string>>())
       ("long-description",
         "thisisareallylongwordthattakesupthewholelineandcannotbebrokenataspace")
       ("help", "Print help")
-      ("tab-expansion", "Tab\texpansion")
       ("int", "An integer", cxxopts::value<int>(), "N")
       ("float", "A floating point number", cxxopts::value<float>())
-      ("vector", "A list of doubles", cxxopts::value<std::vector<double>>())
       ("option_that_is_too_long_for_the_help", "A very long option")
-      ("l,list", "List all parsed arguments (including default values)")
-      ("range", "Use range-for to list arguments")
     #ifdef CXXOPTS_USE_UNICODE
       ("unicode", u8"A help option with non-ascii: à. Here the size of the"
         " string should be correct")
@@ -78,49 +63,28 @@ parse(int argc, const char* argv[])
 
     options.parse_positional({"input", "output", "positional"});
 
-    auto result = options.parse(argc, argv);
+    options.parse(argc, argv);
 
-    if (result.count("help"))
+    if (options.count("help"))
     {
       std::cout << options.help({"", "Group"}) << std::endl;
-      return true;
-    }
-
-    if(result.count("list"))
-    {
-      if(result.count("range"))
-      {
-        for(const auto &kv: result)
-        {
-          std::cout << kv.key() << " = " << kv.value() << std::endl;
-        }
-      }
-      else
-      {
-        std::cout << result.arguments_string() << std::endl;
-      }
-      return true;
+      exit(0);
     }
 
     if (apple)
     {
-      std::cout << "Saw option ‘a’ " << result.count("a") << " times " <<
+      std::cout << "Saw option ‘a’ " << options.count("a") << " times " <<
         std::endl;
     }
 
-    if (result.count("b"))
+    if (options.count("b"))
     {
       std::cout << "Saw option ‘b’" << std::endl;
     }
 
-    if (result.count("char"))
+    if (options.count("f"))
     {
-      std::cout << "Saw a character ‘" << result["char"].as<char>() << "’" << std::endl;
-    }
-
-    if (result.count("f"))
-    {
-      auto& ff = result["f"].as<std::vector<std::string>>();
+      auto& ff = options["f"].as<std::vector<std::string>>();
       std::cout << "Files" << std::endl;
       for (const auto& f : ff)
       {
@@ -128,74 +92,44 @@ parse(int argc, const char* argv[])
       }
     }
 
-    if (result.count("input"))
+    if (options.count("input"))
     {
-      std::cout << "Input = " << result["input"].as<std::string>()
+      std::cout << "Input = " << options["input"].as<std::string>()
         << std::endl;
     }
 
-    if (result.count("output"))
+    if (options.count("output"))
     {
-      std::cout << "Output = " << result["output"].as<std::string>()
+      std::cout << "Output = " << options["output"].as<std::string>()
         << std::endl;
     }
 
-    if (result.count("positional"))
+    if (options.count("positional"))
     {
       std::cout << "Positional = {";
-      auto& v = result["positional"].as<std::vector<std::string>>();
+      auto& v = options["positional"].as<std::vector<std::string>>();
       for (const auto& s : v) {
         std::cout << s << ", ";
       }
       std::cout << "}" << std::endl;
     }
 
-    if (result.count("int"))
+    if (options.count("int"))
     {
-      std::cout << "int = " << result["int"].as<int>() << std::endl;
+      std::cout << "int = " << options["int"].as<int>() << std::endl;
     }
 
-    if (result.count("float"))
+    if (options.count("float"))
     {
-      std::cout << "float = " << result["float"].as<float>() << std::endl;
-    }
-
-    if (result.count("vector"))
-    {
-      std::cout << "vector = ";
-      const auto values = result["vector"].as<std::vector<double>>();
-      for (const auto& v : values) {
-        std::cout << v << ", ";
-      }
-      std::cout << std::endl;
+      std::cout << "float = " << options["float"].as<float>() << std::endl;
     }
 
     std::cout << "Arguments remain = " << argc << std::endl;
 
-    auto arguments = result.arguments();
-    std::cout << "Saw " << arguments.size() << " arguments" << std::endl;
-
-    std::cout << "Unmatched options: ";
-    for (const auto& option: result.unmatched())
-    {
-      std::cout << "'" << option << "' ";
-    }
-    std::cout << std::endl;
-  }
-  catch (const cxxopts::exceptions::exception& e)
+  } catch (const cxxopts::OptionException& e)
   {
     std::cout << "error parsing options: " << e.what() << std::endl;
-    return false;
-  }
-
-  return true;
-}
-
-int main(int argc, const char* argv[])
-{
-  if (!parse(argc, argv))
-  {
-    return 1;
+    exit(1);
   }
 
   return 0;

test/.tipiignore

@@ -1,2 +0,0 @@
-link_a.cpp
-link_b.cpp

test/CMakeLists.txt

@@ -1,60 +1,32 @@
-# Copyright (c) 2014 Jarryd Beck
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+if (CXXOPTS_BUILD_TESTS)
+    add_executable(options_test main.cpp options.cpp)
+    target_link_libraries(options_test cxxopts)
+    add_test(options options_test)
 
-add_executable(options_test main.cpp options.cpp)
-target_link_libraries(options_test cxxopts)
-add_test(options options_test)
+    # test if the targets are findable from the build directory
+    add_test(find-package-test ${CMAKE_CTEST_COMMAND}
+        -C ${CMAKE_BUILD_TYPE}
+        --build-and-test
+        "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
+        "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
+        --build-generator ${CMAKE_GENERATOR}
+        --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+        --build-options
+        "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
+        "-Dcxxopts_DIR=${PROJECT_BINARY_DIR}"
+    )
 
-# test if the targets are findable from the build directory
-add_test(find-package-test ${CMAKE_CTEST_COMMAND}
-    -C ${CMAKE_BUILD_TYPE}
-    --build-and-test
-    "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
-    "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
-    --build-generator ${CMAKE_GENERATOR}
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options
-    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-    "-Dcxxopts_DIR=${PROJECT_BINARY_DIR}"
-)
-
-# test if the targets are findable when add_subdirectory is used
-add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
-    -C ${CMAKE_BUILD_TYPE}
-    --build-and-test
-    "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
-    "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
-    --build-generator ${CMAKE_GENERATOR}
-    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
-    --build-options
-    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
-    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-)
-
-add_executable(link_test link_a.cpp link_b.cpp)
-target_link_libraries(link_test cxxopts)
-
-if(("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") AND ("${CMAKE_SYSTEM}" MATCHES "Linux"))
-    add_executable(fuzzer fuzz.cpp)
-    target_link_libraries(fuzzer PRIVATE cxxopts)
-    target_compile_options(fuzzer PRIVATE -fsanitize=fuzzer)
-    target_link_options(fuzzer PRIVATE -fsanitize=fuzzer)
+    # test if the targets are findable when add_subdirectory is used
+    add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
+        -C ${CMAKE_BUILD_TYPE}
+        --build-and-test
+        "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
+        "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
+        --build-generator ${CMAKE_GENERATOR}
+        --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+        --build-options
+        "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
+    )
 endif()

test/fuzz.cpp

@@ -1,107 +0,0 @@
-#include <cassert>
-#include <cxxopts.hpp>
-#include <fuzzer/FuzzedDataProvider.h>
-
-constexpr int kMaxOptions = 1024;
-constexpr int kMaxArgSize = 1024;
-
-enum class ParseableTypes
-{
-  kInt,
-  kString,
-  kVectorString,
-  kFloat,
-  kDouble,
-
-  // Marker for fuzzer.
-  kMaxValue,
-};
-
-template <typename T>
-void
-add_fuzzed_option(cxxopts::Options* options, FuzzedDataProvider* provider)
-{
-  assert(options);
-  assert(provider);
-
-  options->add_options()(provider->ConsumeRandomLengthString(kMaxArgSize),
-                         provider->ConsumeRandomLengthString(kMaxArgSize),
-                         cxxopts::value<T>());
-}
-
-extern "C" int
-LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
-{
-  try
-  {
-    FuzzedDataProvider provider(data, size);
-
-    // Randomly generate a usage string.
-    cxxopts::Options options(provider.ConsumeRandomLengthString(kMaxArgSize),
-                             provider.ConsumeRandomLengthString(kMaxArgSize));
-
-    // Randomly generate a set of flags configurations.
-    for (int i = 0; i < provider.ConsumeIntegralInRange<int>(0, kMaxOptions);
-         i++)
-    {
-      switch (provider.ConsumeEnum<ParseableTypes>())
-      {
-      case ParseableTypes::kInt:
-        add_fuzzed_option<int>(&options, &provider);
-        break;
-      case ParseableTypes::kString:
-        add_fuzzed_option<std::string>(&options, &provider);
-        break;
-      case ParseableTypes::kVectorString:
-        add_fuzzed_option<std::vector<std::string>>(&options, &provider);
-        break;
-      case ParseableTypes::kFloat:
-        add_fuzzed_option<float>(&options, &provider);
-        break;
-      case ParseableTypes::kDouble:
-        add_fuzzed_option<double>(&options, &provider);
-        break;
-      default:
-        break;
-      }
-    }
-    // Sometimes allow unrecognised options.
-    if (provider.ConsumeBool())
-    {
-      options.allow_unrecognised_options();
-    }
-    // Sometimes allow trailing positional arguments.
-    if (provider.ConsumeBool())
-    {
-      std::string positional_option_name =
-        provider.ConsumeRandomLengthString(kMaxArgSize);
-      options.add_options()(positional_option_name,
-                            provider.ConsumeRandomLengthString(kMaxArgSize),
-                            cxxopts::value<std::vector<std::string>>());
-      options.parse_positional({positional_option_name});
-    }
-
-    // Build command line input.
-    const int argc = provider.ConsumeIntegralInRange<int>(1, kMaxOptions);
-
-    std::vector<std::string> command_line_container;
-    command_line_container.reserve(argc);
-
-    std::vector<const char*> argv;
-    argv.reserve(argc);
-
-    for (int i = 0; i < argc; i++)
-    {
-      command_line_container.push_back(
-        provider.ConsumeRandomLengthString(kMaxArgSize));
-      argv.push_back(command_line_container[i].c_str());
-    }
-
-    // Parse command line;
-    auto result = options.parse(argc, argv.data());
-  } catch (...)
-  {
-  }
-
-  return 0;
-}

test/link_a.cpp

@@ -1,6 +0,0 @@
-#include "cxxopts.hpp"
-
-int main(int, char**)
-{
-  return 0;
-}

test/link_b.cpp

@@ -1 +0,0 @@
-#include <cxxopts.hpp>