X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fstrutil.c;h=1b57302867832885663c5c605d0a027c5e172932;hb=e1b115bd4d5ed195b46daf604c35a33c7a760533;hp=5f0deb7708f374327b6c5d33e7649ca3da342948;hpb=1f488f50b91a67ffc85aa36cea63f09b580aa36e;p=libsigrok.git diff --git a/src/strutil.c b/src/strutil.c index 5f0deb77..1b573028 100644 --- a/src/strutil.c +++ b/src/strutil.c @@ -17,7 +17,17 @@ * along with this program; if not, see . */ +/* Needed for POSIX.1-2008 locale functions */ +#define _XOPEN_SOURCE 700 #include +#include +#include +#if defined(__FreeBSD__) || defined(__APPLE__) +#include +#endif +#if defined(__FreeBSD__) +#include +#endif #include #include #include @@ -67,6 +77,9 @@ SR_PRIV int sr_atol(const char *str, long *ret) errno = 0; tmp = strtol(str, &endptr, 10); + while (endptr && isspace(*endptr)) + endptr++; + if (!endptr || *endptr || errno) { if (!errno) errno = EINVAL; @@ -129,6 +142,9 @@ SR_PRIV int sr_atod(const char *str, double *ret) errno = 0; tmp = strtof(str, &endptr); + while (endptr && isspace(*endptr)) + endptr++; + if (!endptr || *endptr || errno) { if (!errno) errno = EINVAL; @@ -169,6 +185,38 @@ SR_PRIV int sr_atof(const char *str, float *ret) return SR_OK; } +/** + * @private + * + * Convert a string representation of a numeric value to a double. The + * conversion is strict and will fail if the complete string does not represent + * a valid double. The function sets errno according to the details of the + * failure. This version ignores the locale. + * + * @param str The string representation to convert. + * @param ret Pointer to double where the result of the conversion will be stored. + * + * @retval SR_OK Conversion successful. + * @retval SR_ERR Failure. + */ +SR_PRIV int sr_atod_ascii(const char *str, double *ret) +{ + double tmp; + char *endptr = NULL; + + errno = 0; + tmp = g_ascii_strtod(str, &endptr); + + if (!endptr || *endptr || errno) { + if (!errno) + errno = EINVAL; + return SR_ERR; + } + + *ret = tmp; + return SR_OK; +} + /** * @private * @@ -211,6 +259,178 @@ SR_PRIV int sr_atof_ascii(const char *str, float *ret) return SR_OK; } +/** + * Composes a string with a format string (like printf) in the buffer pointed + * by buf (taking buf_size as the maximum buffer capacity to fill). + * If the resulting string would be longer than n - 1 characters, the remaining + * characters are discarded and not stored, but counted for the value returned + * by the function. + * A terminating NUL character is automatically appended after the content + * written. + * After the format parameter, the function expects at least as many additional + * arguments as needed for format. + * + * This version ignores the actual locale and uses the locale "C" for Linux, + * FreeBSD, OSX and Android. + * + * @param buf Pointer to a buffer where the resulting C string is stored. + * @param buf_size Maximum number of bytes to be used in the buffer. The + * generated string has a length of at most buf_size - 1, leaving space + * for the additional terminating NUL character. + * @param format C string that contains a format string (see printf). + * @param ... A sequence of additional arguments, each containing a value to be + * used to replace a format specifier in the format string. + * + * @return On success, the number of characters that would have been written if + * buf_size had been sufficiently large, not counting the terminating + * NUL character. On failure, a negative number is returned. + * Notice that only when this returned value is non-negative and less + * than buf_size, the string has been completely written. + * + * @since 0.6.0 + */ +SR_API int sr_snprintf_ascii(char *buf, size_t buf_size, + const char *format, ...) +{ + int ret; + va_list args; + + va_start(args, format); + ret = sr_vsnprintf_ascii(buf, buf_size, format, args); + va_end(args); + + return ret; +} + +/** + * Composes a string with a format string (like printf) in the buffer pointed + * by buf (taking buf_size as the maximum buffer capacity to fill). + * If the resulting string would be longer than n - 1 characters, the remaining + * characters are discarded and not stored, but counted for the value returned + * by the function. + * A terminating NUL character is automatically appended after the content + * written. + * Internally, the function retrieves arguments from the list identified by + * args as if va_arg was used on it, and thus the state of args is likely to + * be altered by the call. + * In any case, arg should have been initialized by va_start at some point + * before the call, and it is expected to be released by va_end at some point + * after the call. + * + * This version ignores the actual locale and uses the locale "C" for Linux, + * FreeBSD, OSX and Android. + * + * @param buf Pointer to a buffer where the resulting C string is stored. + * @param buf_size Maximum number of bytes to be used in the buffer. The + * generated string has a length of at most buf_size - 1, leaving space + * for the additional terminating NUL character. + * @param format C string that contains a format string (see printf). + * @param args A value identifying a variable arguments list initialized with + * va_start. + * + * @return On success, the number of characters that would have been written if + * buf_size had been sufficiently large, not counting the terminating + * NUL character. On failure, a negative number is returned. + * Notice that only when this returned value is non-negative and less + * than buf_size, the string has been completely written. + * + * @since 0.6.0 + */ +SR_API int sr_vsnprintf_ascii(char *buf, size_t buf_size, + const char *format, va_list args) +{ +#if defined(_WIN32) + int ret; + +#if 0 + /* + * TODO: This part compiles with mingw-w64 but doesn't run with Win7. + * Doesn't start because of "Procedure entry point _create_locale + * not found in msvcrt.dll". + * mingw-w64 should link to msvcr100.dll not msvcrt.dll!. + */ + _locale_t locale; + + locale = _create_locale(LC_NUMERIC, "C"); + ret = _vsnprintf_l(buf, buf_size, format, locale, args); + _free_locale(locale); +#endif + + /* vsprintf uses the current locale, may cause issues for floats. */ + ret = vsnprintf(buf, buf_size, format, args); + + return ret; +#elif defined(__APPLE__) + /* + * See: + * https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man3/printf_l.3.html + * https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man3/xlocale.3.html + */ + int ret; + locale_t locale; + + locale = newlocale(LC_NUMERIC_MASK, "C", NULL); + ret = vsnprintf_l(buf, buf_size, locale, format, args); + freelocale(locale); + + return ret; +#elif defined(__FreeBSD__) && __FreeBSD_version >= 901000 + /* + * See: + * https://www.freebsd.org/cgi/man.cgi?query=printf_l&apropos=0&sektion=3&manpath=FreeBSD+9.1-RELEASE + * https://www.freebsd.org/cgi/man.cgi?query=xlocale&apropos=0&sektion=3&manpath=FreeBSD+9.1-RELEASE + */ + int ret; + locale_t locale; + + locale = newlocale(LC_NUMERIC_MASK, "C", NULL); + ret = vsnprintf_l(buf, buf_size, locale, format, args); + freelocale(locale); + + return ret; +#elif defined(__ANDROID__) + /* + * The Bionic libc only has two locales ("C" aka "POSIX" and "C.UTF-8" + * aka "en_US.UTF-8"). The decimal point is hard coded as ".". + * See: https://android.googlesource.com/platform/bionic/+/master/libc/bionic/locale.cpp + */ + int ret; + + ret = vsnprintf(buf, buf_size, format, args); + + return ret; +#elif defined(__linux__) + int ret; + locale_t old_locale, temp_locale; + + /* Switch to C locale for proper float/double conversion. */ + temp_locale = newlocale(LC_NUMERIC, "C", NULL); + old_locale = uselocale(temp_locale); + + ret = vsnprintf(buf, buf_size, format, args); + + /* Switch back to original locale. */ + uselocale(old_locale); + freelocale(temp_locale); + + return ret; +#elif defined(__unix__) || defined(__unix) + /* + * This is a fallback for all other BSDs, *nix and FreeBSD <= 9.0, by + * using the current locale for snprintf(). This may not work correctly + * for floats! + */ + int ret; + + ret = vsnprintf(buf, buf_size, format, args); + + return ret; +#else + /* No implementation for unknown systems! */ + return -1; +#endif +} + /** * Convert a string representation of a numeric value to a sr_rational. * @@ -445,7 +665,8 @@ SR_API char *sr_voltage_string(uint64_t v_p, uint64_t v_q) */ SR_API int sr_parse_sizestring(const char *sizestring, uint64_t *size) { - int multiplier, done; + uint64_t multiplier; + int done; double frac_part; char *s; @@ -472,6 +693,18 @@ SR_API int sr_parse_sizestring(const char *sizestring, uint64_t *size) case 'G': multiplier = SR_GHZ(1); break; + case 't': + case 'T': + multiplier = SR_GHZ(1000); + break; + case 'p': + case 'P': + multiplier = SR_GHZ(1000 * 1000); + break; + case 'e': + case 'E': + multiplier = SR_GHZ(1000 * 1000 * 1000); + break; default: done = TRUE; s--; @@ -481,8 +714,9 @@ SR_API int sr_parse_sizestring(const char *sizestring, uint64_t *size) if (multiplier > 0) { *size *= multiplier; *size += frac_part * multiplier; - } else + } else { *size += frac_part; + } if (s && *s && g_ascii_strcasecmp(s, "Hz")) return SR_ERR; @@ -569,11 +803,11 @@ SR_API int sr_parse_period(const char *periodstr, uint64_t *p, uint64_t *q) while (*s == ' ') s++; if (!strcmp(s, "fs")) - *q = 1000000000000000ULL; + *q = UINT64_C(1000000000000000); else if (!strcmp(s, "ps")) - *q = 1000000000000ULL; + *q = UINT64_C(1000000000000); else if (!strcmp(s, "ns")) - *q = 1000000000ULL; + *q = UINT64_C(1000000000); else if (!strcmp(s, "us")) *q = 1000000; else if (!strcmp(s, "ms"))