libcruft-util/parse.cpp

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Copyright 2017-2018 Danny Robson <danny@nerdcruft.net>
 */

#include "parse.hpp"

#include "cast.hpp"

#include <cstdlib>
#include <stdexcept>

using cruft::parse;

///////////////////////////////////////////////////////////////////////////////
template <typename T> struct c_traits;
template <> struct c_traits<long> { static constexpr auto func = strtol; };
template <> struct c_traits<long long> { static constexpr auto func = strtoll; };
template <> struct c_traits<unsigned long> { static constexpr auto func = strtoul; };
template <> struct c_traits<unsigned long long> { static constexpr auto func = strtoull; };

template <> struct c_traits<float> { static constexpr auto func = strtof; };
template <> struct c_traits<double> { static constexpr auto func = strtod; };
template <> struct c_traits<long double> { static constexpr auto func = strtold; };


//-----------------------------------------------------------------------------
template <typename T>
T
c_iparse (cruft::view<char const*> &data)
{
    auto head = const_cast<char *> (data.begin ());
    auto tail = head;
    auto val  = c_traits<T>::func (head, &tail, 0);

    if (tail == head)
        throw std::invalid_argument ("unable to parse integer");

    data = data.consume (tail);
    return val;
}


//-----------------------------------------------------------------------------
template <typename T>
T
c_fparse (cruft::view<char const*> &data)
{
    auto head = const_cast<char *> (data.begin ());
    auto tail = head;
    auto val  = c_traits<T>::func (head, &tail);

    if (tail == head)
        throw std::invalid_argument ("unable to parse float");

    data = data.consume (tail);
    return val;
}




///////////////////////////////////////////////////////////////////////////////
#define C_PARSE(T, KLASS)                   \
template <>                                 \
T                                           \
cruft::parse<T> (                           \
    cruft::view<const char *> &str          \
)  {                                        \
    return c_ ## KLASS ## parse<T> (str);   \
}


//-----------------------------------------------------------------------------
C_PARSE(long,               i)
C_PARSE(long long,          i)
C_PARSE(unsigned long,      i)
C_PARSE(unsigned long long, i)

C_PARSE(float,       f)
C_PARSE(double,      f)
C_PARSE(long double, f)


#define C_PARSE_WITH_CAST(FINAL, USED)                          \
template<>                                                      \
FINAL                                                           \
cruft::parse<FINAL> (cruft::view<char const*> &str) {           \
    auto remain = str;                                          \
    auto res = parse<USED> (remain);                            \
    if (res > std::numeric_limits<FINAL>::max ())               \
        throw std::invalid_argument ("overflow during parse");  \
                                                                \
    str = remain;                                               \
    return cruft::cast::narrow<FINAL> (res);                    \
}

C_PARSE_WITH_CAST(unsigned int, unsigned long)