X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fstrutil.c;h=c22c71757f30e42aa08b9e567eb11eeb9a802850;hp=fd9a438e647a6210e63091050b78c7790ffe97be;hb=22fdb67fa0714c11cc0a58ee1423f55d18a4f080;hpb=b5df922e4fbe30d04882658778d2900939e869fe

diff --git a/src/strutil.c b/src/strutil.c
index fd9a438e..c22c7175 100644
--- a/src/strutil.c
+++ b/src/strutil.c
@@ -17,7 +17,19 @@
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+/* Needed for POSIX.1-2008 locale functions */
+/** @cond PRIVATE */
+#define _XOPEN_SOURCE 700
+/** @endcond */
 #include <config.h>
+#include <ctype.h>
+#include <locale.h>
+#if defined(__FreeBSD__) || defined(__APPLE__)
+#include <xlocale.h>
+#endif
+#if defined(__FreeBSD__)
+#include <sys/param.h>
+#endif
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -45,8 +57,6 @@
  */
 
 /**
- * @private
- *
  * Convert a string representation of a numeric value (base 10) to a long integer. The
  * conversion is strict and will fail if the complete string does not represent
  * a valid long integer. The function sets errno according to the details of the
@@ -57,6 +67,8 @@
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atol(const char *str, long *ret)
 {
@@ -66,6 +78,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;
@@ -77,8 +92,114 @@ SR_PRIV int sr_atol(const char *str, long *ret)
 }
 
 /**
+ * Convert a text to a number including support for non-decimal bases.
+ * Also optionally returns the position after the number, where callers
+ * can either error out, or support application specific suffixes.
+ *
+ * @param[in] str The input text to convert.
+ * @param[out] ret The conversion result.
+ * @param[out] end The position after the number.
+ * @param[in] base The number format's base, can be 0.
+ *
+ * @retval SR_OK Conversion successful.
+ * @retval SR_ERR Conversion failed.
+ *
+ * @private
+ *
+ * This routine is more general than @ref sr_atol(), which strictly
+ * expects the input text to contain just a decimal number, and nothing
+ * else in addition. The @ref sr_atol_base() routine accepts trailing
+ * text after the number, and supports non-decimal numbers (bin, hex),
+ * including automatic detection from prefix text.
+ */
+SR_PRIV int sr_atol_base(const char *str, long *ret, char **end, int base)
+{
+	long num;
+	char *endptr;
+
+	/* Add "0b" prefix support which strtol(3) may be missing. */
+	while (str && isspace(*str))
+		str++;
+	if (!base && strncmp(str, "0b", strlen("0b")) == 0) {
+		str += strlen("0b");
+		base = 2;
+	}
+
+	/* Run the number conversion. Quick bail out if that fails. */
+	errno = 0;
+	endptr = NULL;
+	num = strtol(str, &endptr, base);
+	if (!endptr || errno) {
+		if (!errno)
+			errno = EINVAL;
+		return SR_ERR;
+	}
+	*ret = num;
+
+	/* Advance to optional non-space trailing suffix. */
+	while (endptr && isspace(*endptr))
+		endptr++;
+	if (end)
+		*end = endptr;
+
+	return SR_OK;
+}
+
+/**
+ * Convert a text to a number including support for non-decimal bases.
+ * Also optionally returns the position after the number, where callers
+ * can either error out, or support application specific suffixes.
+ *
+ * @param[in] str The input text to convert.
+ * @param[out] ret The conversion result.
+ * @param[out] end The position after the number.
+ * @param[in] base The number format's base, can be 0.
+ *
+ * @retval SR_OK Conversion successful.
+ * @retval SR_ERR Conversion failed.
+ *
  * @private
  *
+ * This routine is more general than @ref sr_atol(), which strictly
+ * expects the input text to contain just a decimal number, and nothing
+ * else in addition. The @ref sr_atoul_base() routine accepts trailing
+ * text after the number, and supports non-decimal numbers (bin, hex),
+ * including automatic detection from prefix text.
+ */
+SR_PRIV int sr_atoul_base(const char *str, unsigned long *ret, char **end, int base)
+{
+	unsigned long num;
+	char *endptr;
+
+	/* Add "0b" prefix support which strtol(3) may be missing. */
+	while (str && isspace(*str))
+		str++;
+	if (!base && strncmp(str, "0b", strlen("0b")) == 0) {
+		str += strlen("0b");
+		base = 2;
+	}
+
+	/* Run the number conversion. Quick bail out if that fails. */
+	errno = 0;
+	endptr = NULL;
+	num = strtoul(str, &endptr, base);
+	if (!endptr || errno) {
+		if (!errno)
+			errno = EINVAL;
+		return SR_ERR;
+	}
+	*ret = num;
+
+	/* Advance to optional non-space trailing suffix. */
+	while (endptr && isspace(*endptr))
+		endptr++;
+	if (end)
+		*end = endptr;
+
+	return SR_OK;
+}
+
+/**
  * Convert a string representation of a numeric value (base 10) to an integer. The
  * conversion is strict and will fail if the complete string does not represent
  * a valid integer. The function sets errno according to the details of the
@@ -89,6 +210,8 @@ SR_PRIV int sr_atol(const char *str, long *ret)
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atoi(const char *str, int *ret)
 {
@@ -107,8 +230,6 @@ SR_PRIV int sr_atoi(const char *str, int *ret)
 }
 
 /**
- * @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
@@ -119,6 +240,8 @@ SR_PRIV int sr_atoi(const char *str, int *ret)
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atod(const char *str, double *ret)
 {
@@ -128,6 +251,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;
@@ -139,8 +265,6 @@ SR_PRIV int sr_atod(const char *str, double *ret)
 }
 
 /**
- * @private
- *
  * Convert a string representation of a numeric value to a float. The
  * conversion is strict and will fail if the complete string does not represent
  * a valid float. The function sets errno according to the details of the
@@ -151,6 +275,8 @@ SR_PRIV int sr_atod(const char *str, double *ret)
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atof(const char *str, float *ret)
 {
@@ -169,8 +295,109 @@ SR_PRIV int sr_atof(const char *str, float *ret)
 }
 
 /**
+ * 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.
+ *
  * @private
+ */
+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;
+}
+
+/**
+ * Convert text to a floating point value, and get its precision.
+ *
+ * @param[in] str The input text to convert.
+ * @param[out] ret The conversion result, a double precision float number.
+ * @param[out] digits The number of significant decimals.
+ *
+ * @returns SR_OK in case of successful text to number conversion.
+ * @returns SR_ERR when conversion fails.
  *
+ * @since 0.6.0
+ */
+SR_PRIV int sr_atod_ascii_digits(const char *str, double *ret, int *digits)
+{
+	const char *p;
+	int *dig_ref, m_dig, exp;
+	char c;
+	double f;
+
+	/*
+	 * Convert floating point text to the number value, _and_ get
+	 * the value's precision in the process. Steps taken to do it:
+	 * - Skip leading whitespace.
+	 * - Count the number of decimals after the mantissa's period.
+	 * - Get the exponent's signed value.
+	 *
+	 * This implementation still uses common code for the actual
+	 * conversion, but "violates API layers" by duplicating the
+	 * text scan, to get the number of significant digits.
+	 */
+	p = str;
+	while (*p && isspace(*p))
+		p++;
+	if (*p == '-' || *p == '+')
+		p++;
+	m_dig = 0;
+	exp = 0;
+	dig_ref = NULL;
+	while (*p) {
+		c = *p++;
+		if (toupper(c) == 'E') {
+			exp = strtol(p, NULL, 10);
+			break;
+		}
+		if (c == '.') {
+			m_dig = 0;
+			dig_ref = &m_dig;
+			continue;
+		}
+		if (isdigit(c)) {
+			if (dig_ref)
+				(*dig_ref)++;
+			continue;
+		}
+		/* Need not warn, conversion will fail. */
+		break;
+	}
+	sr_spew("atod digits: txt \"%s\" -> m %d, e %d -> digits %d",
+		str, m_dig, exp, m_dig + -exp);
+	m_dig += -exp;
+
+	if (sr_atod_ascii(str, &f) != SR_OK)
+		return SR_ERR;
+	if (ret)
+		*ret = f;
+	if (digits)
+		*digits = m_dig;
+
+	return SR_OK;
+}
+
+/**
  * Convert a string representation of a numeric value to a float. The
  * conversion is strict and will fail if the complete string does not represent
  * a valid float. The function sets errno according to the details of the
@@ -181,6 +408,8 @@ SR_PRIV int sr_atof(const char *str, float *ret)
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atof_ascii(const char *str, float *ret)
 {
@@ -210,6 +439,378 @@ SR_PRIV int sr_atof_ascii(const char *str, float *ret)
 	return SR_OK;
 }
 
+/**
+ * Compose a string with a format string in the buffer pointed to by buf.
+ *
+ * It is up to the caller to ensure that the allocated buffer is large enough
+ * to hold the formatted result.
+ *
+ * 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 current 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 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,
+ *         not counting the terminating NUL character.
+ *
+ * @since 0.6.0
+ */
+SR_API int sr_sprintf_ascii(char *buf, const char *format, ...)
+{
+	int ret;
+	va_list args;
+
+	va_start(args, format);
+	ret = sr_vsprintf_ascii(buf, format, args);
+	va_end(args);
+
+	return ret;
+}
+
+/**
+ * Compose a string with a format string in the buffer pointed to by buf.
+ *
+ * It is up to the caller to ensure that the allocated buffer is large enough
+ * to hold the formatted result.
+ *
+ * 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, args 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 current 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 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,
+ *         not counting the terminating NUL character.
+ *
+ * @since 0.6.0
+ */
+SR_API int sr_vsprintf_ascii(char *buf, 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!
+	 * See: https://msdn.microsoft.com/en-us/en-en/library/1kt27hek.aspx
+	 */
+	_locale_t locale;
+
+	locale = _create_locale(LC_NUMERIC, "C");
+	ret = _vsprintf_l(buf, format, locale, args);
+	_free_locale(locale);
+#endif
+
+	/* vsprintf() uses the current locale, may not work correctly for floats. */
+	ret = vsprintf(buf, 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 = vsprintf_l(buf, 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 = vsprintf_l(buf, 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 = vsprintf(buf, 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 = vsprintf(buf, 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 = vsprintf(buf, format, args);
+
+	return ret;
+#else
+	/* No implementation for unknown systems! */
+	return -1;
+#endif
+}
+
+/**
+ * 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 current 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 current 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!.
+	 * See: https://msdn.microsoft.com/en-us/en-en/library/1kt27hek.aspx
+	 */
+	_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 sequence of bytes to its textual representation ("hex dump").
+ *
+ * Callers should free the allocated GString. See sr_hexdump_free().
+ *
+ * @param[in] data Pointer to the byte sequence to print.
+ * @param[in] len Number of bytes to print.
+ *
+ * @return NULL upon error, newly allocated GString pointer otherwise.
+ *
+ * @private
+ */
+SR_PRIV GString *sr_hexdump_new(const uint8_t *data, const size_t len)
+{
+	GString *s;
+	size_t i;
+
+	s = g_string_sized_new(3 * len);
+	for (i = 0; i < len; i++) {
+		if (i)
+			g_string_append_c(s, ' ');
+		g_string_append_printf(s, "%02x", data[i]);
+	}
+
+	return s;
+}
+
+/**
+ * Free a hex dump text that was created by sr_hexdump_new().
+ *
+ * @param[in] s Pointer to the GString to release.
+ *
+ * @private
+ */
+SR_PRIV void sr_hexdump_free(GString *s)
+{
+	if (s)
+		g_string_free(s, TRUE);
+}
+
 /**
  * Convert a string representation of a numeric value to a sr_rational.
  *
@@ -233,21 +834,49 @@ SR_API int sr_parse_rational(const char *str, struct sr_rational *ret)
 	int64_t denominator = 1;
 	int32_t fractional_len = 0;
 	int32_t exponent = 0;
+	gboolean is_negative = FALSE;
+	gboolean no_integer, no_fractional;
+
+	while (isspace(*str))
+		str++;
 
 	errno = 0;
 	integral = g_ascii_strtoll(str, &endptr, 10);
 
-	if (errno)
+	if (str == endptr && (str[0] == '-' || str[0] == '+') && str[1] == '.') {
+		endptr += 1;
+		no_integer = TRUE;
+	} else if (str == endptr && str[0] == '.') {
+		no_integer = TRUE;
+	} else if (errno) {
 		return SR_ERR;
+	} else {
+		no_integer = FALSE;
+	}
+
+	if (integral < 0 || str[0] == '-')
+		is_negative = TRUE;
 
+	errno = 0;
 	if (*endptr == '.') {
-		const char* start = endptr + 1;
+		gboolean is_exp, is_eos;
+		const char *start = endptr + 1;
 		fractional = g_ascii_strtoll(start, &endptr, 10);
+		is_exp = *endptr == 'E' || *endptr == 'e';
+		is_eos = *endptr == '\0';
+		if (endptr == start && (is_exp || is_eos)) {
+			fractional = 0;
+			errno = 0;
+		}
 		if (errno)
 			return SR_ERR;
+		no_fractional = endptr == start;
+		if (no_integer && no_fractional)
+			return SR_ERR;
 		fractional_len = endptr - start;
 	}
 
+	errno = 0;
 	if ((*endptr == 'E') || (*endptr == 'e')) {
 		exponent = g_ascii_strtoll(endptr + 1, &endptr, 10);
 		if (errno)
@@ -261,7 +890,7 @@ SR_API int sr_parse_rational(const char *str, struct sr_rational *ret)
 		integral *= 10;
 	exponent -= fractional_len;
 
-	if (integral >= 0)
+	if (!is_negative)
 		integral += fractional;
 	else
 		integral -= fractional;
@@ -438,7 +1067,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;
 
@@ -465,6 +1095,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--;
@@ -474,8 +1116,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;
@@ -562,11 +1205,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"))