From 5d2bbca39c79dcc73060ac480a4e229affef0a14 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Fri, 10 Jun 2022 19:34:11 +0200 Subject: Add strto[u]{hh,h,z}, strto{i,u}{,8,16,32,64} MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- LICENSE | 2 +- Makefile | 17 +++ libsimple.h | 1 + libsimple/strtoint.h | 362 +++++++++++++++++++++++++++++++++++++++++++++++++++ strtoh.c | 30 +++++ strtohh.c | 30 +++++ strtoi.c | 30 +++++ strtoi16.c | 33 +++++ strtoi32.c | 33 +++++ strtoi64.c | 33 +++++ strtoi8.c | 33 +++++ strtou.c | 27 ++++ strtou16.c | 29 +++++ strtou32.c | 29 +++++ strtou64.c | 31 +++++ strtou8.c | 29 +++++ strtouh.c | 27 ++++ strtouhh.c | 27 ++++ strtouz.c | 18 +++ strtoz.c | 18 +++ 20 files changed, 838 insertions(+), 1 deletion(-) create mode 100644 libsimple/strtoint.h create mode 100644 strtoh.c create mode 100644 strtohh.c create mode 100644 strtoi.c create mode 100644 strtoi16.c create mode 100644 strtoi32.c create mode 100644 strtoi64.c create mode 100644 strtoi8.c create mode 100644 strtou.c create mode 100644 strtou16.c create mode 100644 strtou32.c create mode 100644 strtou64.c create mode 100644 strtou8.c create mode 100644 strtouh.c create mode 100644 strtouhh.c create mode 100644 strtouz.c create mode 100644 strtoz.c diff --git a/LICENSE b/LICENSE index c96ce73..f4e0c18 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ ISC License -© 2017, 2018 Mattias Andrée +© 2017, 2018, 2021, 2022 Mattias Andrée Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above diff --git a/Makefile b/Makefile index cc1c5c9..cc583ab 100644 --- a/Makefile +++ b/Makefile @@ -36,6 +36,7 @@ SUBHDR =\ libsimple/strdup.h\ libsimple/strn.h\ libsimple/strndup.h\ + libsimple/strtoint.h\ libsimple/time.h\ libsimple/valloc.h\ libsimple/vallocz.h\ @@ -192,8 +193,24 @@ OBJ =\ strrnstr.o\ strrstr.o\ strstarts.o\ + strtoh.o\ + strtohh.o\ + strtoi.o\ + strtoi16.o\ + strtoi32.o\ + strtoi64.o\ + strtoi8.o\ strtotimespec.o\ strtotimeval.o\ + strtou.o\ + strtou16.o\ + strtou32.o\ + strtou64.o\ + strtou8.o\ + strtouh.o\ + strtouhh.o\ + strtouz.o\ + strtoz.o\ sumtimespec.o\ sumtimeval.o\ timespec2timeval.o\ diff --git a/libsimple.h b/libsimple.h index e97ac27..6443dd4 100644 --- a/libsimple.h +++ b/libsimple.h @@ -128,6 +128,7 @@ #include "libsimple/array.h" #include "libsimple/str.h" #include "libsimple/strn.h" +#include "libsimple/strtoint.h" /** diff --git a/libsimple/strtoint.h b/libsimple/strtoint.h new file mode 100644 index 0000000..34c2432 --- /dev/null +++ b/libsimple/strtoint.h @@ -0,0 +1,362 @@ +/* See LICENSE file for copyright and license details. */ + + +/** + * Converts a string to a `signed char` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +signed char libsimple_strtohh(const char *restrict, char **restrict, int); +#ifndef strtohh +# define strtohh libsimple_strtohh +#endif + +/** + * Converts a string to a `unsigned char` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +unsigned char libsimple_strtouhh(const char *restrict, char **restrict, int); +#ifndef strtouhh +# define strtouhh libsimple_strtouhh +#endif + +/** + * Converts a string to a `signed short int` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +signed short int libsimple_strtoh(const char *restrict, char **restrict, int); +#ifndef strtoh +# define strtoh libsimple_strtoh +#endif + +/** + * Converts a string to a `unsigned short int` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +unsigned short int libsimple_strtouh(const char *restrict, char **restrict, int); +#ifndef strtouh +# define strtouh libsimple_strtouh +#endif + +/** + * Converts a string to a `signed int` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +signed int libsimple_strtoi(const char *restrict, char **restrict, int); +#ifndef strtoi +# define strtoi libsimple_strtoi +#endif + +/** + * Converts a string to a `unsigned int` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +unsigned int libsimple_strtou(const char *restrict, char **restrict, int); +#ifndef strtou +# define strtou libsimple_strtou +#endif + +/** + * Converts a string to a `ssize_t` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +inline ssize_t +libsimple_strtoz(const char *restrict nptr, char **restrict endptr, int base) +{ + return (ssize_t)strtol(nptr, endptr, base); +} +#ifndef strtoz +# define strtoz libsimple_strtoz +#endif + +/** + * Converts a string to a `size_t` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +inline size_t +libsimple_strtouz(const char *restrict nptr, char **restrict endptr, int base) +{ + return (size_t)strtoul(nptr, endptr, base); +} +#ifndef strtouz +# define strtouz libsimple_strtouz +#endif + +/** + * Converts a string to a `int8_t` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +int_least8_t libsimple_strtoi8(const char *restrict, char **restrict, int); +#ifndef strtoi8 +# define strtoi8 libsimple_strtoi8 +#endif + +/** + * Converts a string to a `uint8_t` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +uint_least8_t libsimple_strtou8(const char *restrict, char **restrict, int); +#ifndef strtou8 +# define strtou8 libsimple_strtou8 +#endif + +/** + * Converts a string to a `int16_t` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +int_least16_t libsimple_strtoi16(const char *restrict, char **restrict, int); +#ifndef strtoi16 +# define strtoi16 libsimple_strtoi16 +#endif + +/** + * Converts a string to a `uint16_t` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +uint_least16_t libsimple_strtou16(const char *restrict, char **restrict, int); +#ifndef strtou16 +# define strtou16 libsimple_strtou16 +#endif + +/** + * Converts a string to a `int32_t` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +int_least32_t libsimple_strtoi32(const char *restrict, char **restrict, int); +#ifndef strtoi32 +# define strtoi32 libsimple_strtoi32 +#endif + +/** + * Converts a string to a `uint32_t` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +uint_least32_t libsimple_strtou32(const char *restrict, char **restrict, int); +#ifndef strtou32 +# define strtou32 libsimple_strtou32 +#endif + +/** + * Converts a string to a `int64_t` + * according to the rules of strtol(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +int_least64_t libsimple_strtoi64(const char *restrict, char **restrict, int); +#ifndef strtoi64 +# define strtoi64 libsimple_strtoi64 +#endif + +/** + * Converts a string to a `uint64_t` + * according to the rules of strtoul(3) + * + * @param nptr The string to parse + * @param endptr Output parameter for the position in `nptr` + * where the first character that is not part + * of the interpreted value resides + * @param base The base the value is encoded in, 0 if + * the function shall accept a prefix to + * specify the base if it is not 10 + * @return The encoded value (`errno` is unchanges), or + * if out of range (`errno` set to `ERANGE`), the + * closed value that can be represented; 0 on + * failure (unless `errno` not set to `ERANGE`) + */ +_LIBSIMPLE_GCC_ONLY(__attribute__((__nonnull__(2), __warn_unused_result__))) +uint_least64_t libsimple_strtou64(const char *restrict, char **restrict, int); +#ifndef strtou64 +# define strtou64 libsimple_strtou64 +#endif diff --git a/strtoh.c b/strtoh.c new file mode 100644 index 0000000..47ea6d3 --- /dev/null +++ b/strtoh.c @@ -0,0 +1,30 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +signed short int +libsimple_strtoh(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + signed long int r = strtol(nptr, end, base); + if(r < SHRT_MIN) { + r = SHRT_MIN; + errno = ERANGE; + } else if(r > SHRT_MAX) { + r = SHRT_MAX; + errno = ERANGE; + } + return (signed short int)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtohh.c b/strtohh.c new file mode 100644 index 0000000..67da198 --- /dev/null +++ b/strtohh.c @@ -0,0 +1,30 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +signed char +libsimple_strtohh(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + signed long int r = strtol(nptr, end, base); + if(r < SCHAR_MIN) { + r = SCHAR_MIN; + errno = ERANGE; + } else if(r > SCHAR_MAX) { + r = SCHAR_MAX; + errno = ERANGE; + } + return (signed char)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtoi.c b/strtoi.c new file mode 100644 index 0000000..6b3fcb2 --- /dev/null +++ b/strtoi.c @@ -0,0 +1,30 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +signed int +libsimple_strtoi(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + signed int r = strtol(nptr, end, base); + if(r < INT_MIN) { + r = INT_MIN; + errno = ERANGE; + } else if(r > INT_MAX) { + r = INT_MAX; + errno = ERANGE; + } + return (signed int)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtoi16.c b/strtoi16.c new file mode 100644 index 0000000..2960603 --- /dev/null +++ b/strtoi16.c @@ -0,0 +1,33 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 32767LL +#define RET_MIN (-RET_MAX - 1LL) + + +int_least16_t +libsimple_strtoi16(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + intmax_t r = strtoimax(nptr, end, base); + if(r < RET_MIN) { + r = RET_MIN; + errno = ERANGE; + } else if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (int_least16_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtoi32.c b/strtoi32.c new file mode 100644 index 0000000..ce4a7f4 --- /dev/null +++ b/strtoi32.c @@ -0,0 +1,33 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 2147483647LL +#define RET_MIN (-RET_MAX - 1LL) + + +int_least32_t +libsimple_strtoi32(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + intmax_t r = strtoimax(nptr, end, base); + if(r < RET_MIN) { + r = RET_MIN; + errno = ERANGE; + } else if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (int_least32_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtoi64.c b/strtoi64.c new file mode 100644 index 0000000..963574b --- /dev/null +++ b/strtoi64.c @@ -0,0 +1,33 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 9223372036854775807LL +#define RET_MIN (-RET_MAX - 1LL) + + +int_least32_t +libsimple_strtoi32(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + intmax_t r = strtoimax(nptr, end, base); + if(r < RET_MIN) { + r = RET_MIN; + errno = ERANGE; + } else if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (int_least32_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtoi8.c b/strtoi8.c new file mode 100644 index 0000000..f6fecc6 --- /dev/null +++ b/strtoi8.c @@ -0,0 +1,33 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 127LL +#define RET_MIN (-RET_MAX - 1LL) + + +int_least8_t +libsimple_strtoi8(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + intmax_t r = strtoimax(nptr, end, base); + if(r < RET_MIN) { + r = RET_MIN; + errno = ERANGE; + } else if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (int_least8_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtou.c b/strtou.c new file mode 100644 index 0000000..4201c1f --- /dev/null +++ b/strtou.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +unsigned int +libsimple_strtou(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + signed long int r = strtoul(nptr, end, base); + if(r > UINT_MAX) { + r = UINT_MAX; + errno = ERANGE; + } + return (unsigned int)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtou16.c b/strtou16.c new file mode 100644 index 0000000..dea2678 --- /dev/null +++ b/strtou16.c @@ -0,0 +1,29 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 65535ULL + + +uint_least16_t +libsimple_strtou16(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + uintmax_t r = strtoumax(nptr, end, base); + if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (uint_least16_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtou32.c b/strtou32.c new file mode 100644 index 0000000..0260d4f --- /dev/null +++ b/strtou32.c @@ -0,0 +1,29 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 4294967295ULL + + +uint_least32_t +libsimple_strtou32(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + uintmax_t r = strtoumax(nptr, end, base); + if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (uint_least32_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtou64.c b/strtou64.c new file mode 100644 index 0000000..1deb3a5 --- /dev/null +++ b/strtou64.c @@ -0,0 +1,31 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 18446744073709551615ULL + + +uint_least64_t +libsimple_strtou64(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + uintmax_t r = strtoumax(nptr, end, base); +#if UINTMAX_MAX > RET_MAX + if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } +#endif + return (uint_least64_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtou8.c b/strtou8.c new file mode 100644 index 0000000..5a8bcf5 --- /dev/null +++ b/strtou8.c @@ -0,0 +1,29 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + +#define RET_MAX 255ULL + + +uint_least8_t +libsimple_strtou8(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + uintmax_t r = strtoumax(nptr, end, base); + if(r > RET_MAX) { + r = RET_MAX; + errno = ERANGE; + } + return (uint_least8_t)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtouh.c b/strtouh.c new file mode 100644 index 0000000..7e4505f --- /dev/null +++ b/strtouh.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +unsigned short int +libsimple_strtouh(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + signed long int r = strtoul(nptr, end, base); + if(r > USHRT_MAX) { + r = USHRT_MAX; + errno = ERANGE; + } + return (unsigned short int)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtouhh.c b/strtouhh.c new file mode 100644 index 0000000..b13800d --- /dev/null +++ b/strtouhh.c @@ -0,0 +1,27 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +unsigned char +libsimple_strtouhh(const char *restrict nptr, char **restrict end, int base) /* TODO test, man */ +{ + signed long int r = strtoul(nptr, end, base); + if(r > UCHAR_MAX) { + r = UCHAR_MAX; + errno = ERANGE; + } + return (unsigned char)r; +} + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtouz.c b/strtouz.c new file mode 100644 index 0000000..2885600 --- /dev/null +++ b/strtouz.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +extern inline size_t libsimple_strtouz(const char *restrict nptr, char **restrict end, int base); /* TODO test, man */ + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif diff --git a/strtoz.c b/strtoz.c new file mode 100644 index 0000000..dbaccad --- /dev/null +++ b/strtoz.c @@ -0,0 +1,18 @@ +/* See LICENSE file for copyright and license details. */ +#include "libsimple.h" +#ifndef TEST + + +extern inline ssize_t libsimple_strtoz(const char *restrict nptr, char **restrict end, int base); /* TODO test, man */ + + +#else +#include "test.h" + +int +main(void) +{ + return 0; +} + +#endif -- cgit v1.2.3-70-g09d2