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

diff --git a/src/strutil.c b/src/strutil.c
index 73c9fc6a..c22c7175 100644
--- a/src/strutil.c
+++ b/src/strutil.c
@@ -18,7 +18,9 @@
  */
 
 /* Needed for POSIX.1-2008 locale functions */
+/** @cond PRIVATE */
 #define _XOPEN_SOURCE 700
+/** @endcond */
 #include <config.h>
 #include <ctype.h>
 #include <locale.h>
@@ -55,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
@@ -67,6 +67,8 @@
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atol(const char *str, long *ret)
 {
@@ -90,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
@@ -102,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)
 {
@@ -120,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
@@ -132,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)
 {
@@ -155,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
@@ -167,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)
 {
@@ -185,8 +295,6 @@ SR_PRIV int sr_atof(const char *str, float *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
@@ -197,6 +305,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_atod_ascii(const char *str, double *ret)
 {
@@ -217,8 +327,77 @@ SR_PRIV int sr_atod_ascii(const char *str, double *ret)
 }
 
 /**
- * @private
+ * 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
@@ -229,6 +408,8 @@ SR_PRIV int sr_atod_ascii(const char *str, double *ret)
  *
  * @retval SR_OK Conversion successful.
  * @retval SR_ERR Failure.
+ *
+ * @private
  */
 SR_PRIV int sr_atof_ascii(const char *str, float *ret)
 {
@@ -590,6 +771,46 @@ SR_API int sr_vsnprintf_ascii(char *buf, size_t buf_size,
 #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.
  *