Negative numbers are not parsed correctly

[kkarbowiak]

In fact, anything that starts with a dash is treated as a potential optional argument, so negative numbers cannot be parsed. This results in parsing errors:

#include "argparse.hpp"
#include <iostream>


int main(int argc, char * argv[])
{
    auto parser = argparse::ArgumentParser();
    parser.add_argument("num").type<int>();
    auto parsed = parser.parse_args(argc, argv);
    auto num = parsed.get_value<int>("num");
    std::cout << "The number is " << num << '\n';
}

$ ./test1 -10
unrecognised arguments: -10
usage: test1 [-h] num

positional arguments:
  num

optional arguments:
  -h, --help            show this help message and exit

and

#include "argparse.h"
#include <iostream>


int main(int argc, char * argv[])
{
    auto parser = argparse::ArgumentParser();
    parser.add_argument("--num").type<int>();
    auto parsed = parser.parse_args(argc, argv);
    auto num = parsed.get_value<int>("num");
    std::cout << "The number is " << num << '\n';
}

$ ./test2 --num -10
argument --num: expected one argument
usage: test2 [-h] [--num NUM]

optional arguments:
  -h, --help            show this help message and exit
  --num NUM

This is a regression introduced in

• 307ebfe for positional arguments
• 9d582f5 for optional arguments

[kkarbowiak]

There are workarounds.

For positional arguments, precede negative numbers with -- pseudoargument:

$ ./test1 -- -10
The number is -10

For optional arguments, join the argument with its value:

$ ./test2 --num=-10
The number is -10

or

$ ./test3 -n-10
The number is -10

[kkarbowiak]

This is fixed with #159 and #160 with the caveat that parsing custom types with string representation starting with dash can still fail:

#include "argparse.hpp"
#include <string>
#include <sstream>


struct Point
{
    Point() = default;

    Point(int xx, int yy) : x(xx), y(yy)
    {
    }

    int x = 0;
    int y = 0;
};

namespace argparse
{
template<>
inline auto from_string(std::string const & s, Point & p) -> bool
{
    std::istringstream iss(s);
    char comma;
    iss >> p.x >> comma >> p.y;
    return true;
}

template<>
inline auto to_string(Point const & p) -> std::string
{
    return std::to_string(p.x) + "," + std::to_string(p.y);
}

template<>
inline auto are_equal(Point const & l, Point const & r) -> bool
{
    return l.x == r.x && l.y == r.y;
}
}

auto main(int argc, char * argv[]) -> int
{
    auto parser = argparse::ArgumentParser();
    parser.add_argument("point").type<Point>();
    auto parsed = parser.parse_args(argc, argv);
    auto pt = parsed.get_value<Point>("point");
    std::cout << "Point: [" << pt.x << ", " << pt.y << "]\n";
}

$ test 1,3
Point: [1, 3]
$ test 1,-3
Point: [1, -3]
$ test -1,-3
unrecognised arguments: -1,-3
usage: test [-h] point

positional arguments:
  point

optional arguments:
  -h, --help            show this help message and exit
$ test -- -1,-3
Point: [-1, -3]

For what it's worth, Python's argparse has exactly the same problem.