From e9785c888dddb7449e741ed53796e995f0efa9f7 Mon Sep 17 00:00:00 2001
From: Iztok Jeras <iztok.jeras@redpitaya.com>
Date: ćšć, 08 10æ 2015 03:00:33 +0800
Subject: [PATCH] added most new function declarations, replaced all usecases for old functions, missing are most new implementations
---
libscpi/src/ieee488.c | 16
libscpi/src/minimal.c | 12
libscpi/src/parser.c | 214 ++++++++++++++--
libscpi/test/test_scpi_utils.c | 279 +++++++++++++++++++--
libscpi/src/expression.c | 4
libscpi/src/utils_private.h | 6
libscpi/inc/scpi/parser.h | 29 +
libscpi/test/test_parser.c | 4
examples/common/scpi-def.cpp | 4
libscpi/inc/scpi/utils.h | 6
libscpi/src/utils.c | 188 ++++++++++++++
examples/common/scpi-def.c | 4
12 files changed, 669 insertions(+), 97 deletions(-)
diff --git a/examples/common/scpi-def.c b/examples/common/scpi-def.c
index d53cd48..91658e6 100644
--- a/examples/common/scpi-def.c
+++ b/examples/common/scpi-def.c
@@ -151,7 +151,7 @@
SCPI_ChoiceToName(trigger_source, param, &name);
fprintf(stderr, "\tP1=%s (%ld)\r\n", name, (long int)param);
- SCPI_ResultInt(context, param);
+ SCPI_ResultInt32(context, param);
return SCPI_RES_OK;
}
@@ -200,7 +200,7 @@
*/
static scpi_result_t My_CoreTstQ(scpi_t * context) {
- SCPI_ResultInt(context, 0);
+ SCPI_ResultInt32(context, 0);
return SCPI_RES_OK;
}
diff --git a/examples/common/scpi-def.cpp b/examples/common/scpi-def.cpp
index c69af2e..720318e 100644
--- a/examples/common/scpi-def.cpp
+++ b/examples/common/scpi-def.cpp
@@ -151,7 +151,7 @@
SCPI_ChoiceToName(trigger_source, param, &name);
fprintf(stderr, "\tP1=%s (%ld)\r\n", name, (long int)param);
- SCPI_ResultInt(context, param);
+ SCPI_ResultInt32(context, param);
return SCPI_RES_OK;
}
@@ -197,7 +197,7 @@
*/
scpi_result_t My_CoreTstQ(scpi_t * context) {
- SCPI_ResultInt(context, 0);
+ SCPI_ResultInt32(context, 0);
return SCPI_RES_OK;
}
diff --git a/libscpi/inc/scpi/parser.h b/libscpi/inc/scpi/parser.h
index 6b669da..35e3123 100644
--- a/libscpi/inc/scpi/parser.h
+++ b/libscpi/inc/scpi/parser.h
@@ -51,26 +51,43 @@
size_t SCPI_ResultCharacters(scpi_t * context, const char * data, size_t len);
#define SCPI_ResultMnemonic(context, data) SCPI_ResultCharacters((context), (data), strlen(data))
- size_t SCPI_ResultInt(scpi_t * context, int32_t val);
- size_t SCPI_ResultIntBase(scpi_t * context, int32_t val, int8_t base);
+ size_t SCPI_ResultInt32(scpi_t * context, int32_t val);
+#define SCPI_ResultInt(context, val) SCPI_ResultInt32 ((context), (val))
+ size_t SCPI_ResultInt32Base(scpi_t * context, int32_t val, int8_t base);
+#define SCPI_ResultIntBase(context, val, base) SCPI_ResultInt32Base ((context), (val), (base))
+ size_t SCPI_ResultUInt32(scpi_t * context, uint32_t val);
+ size_t SCPI_ResultUInt32Base(scpi_t * context, uint32_t val, int8_t base);
+ size_t SCPI_ResultInt64(scpi_t * context, int64_t val);
+ size_t SCPI_ResultInt64Base(scpi_t * context, int64_t val, int8_t base);
+ size_t SCPI_ResultUInt64(scpi_t * context, uint64_t val);
+ size_t SCPI_ResultUInt64Base(scpi_t * context, uint64_t val, int8_t base);
size_t SCPI_ResultDouble(scpi_t * context, double val);
size_t SCPI_ResultText(scpi_t * context, const char * data);
size_t SCPI_ResultArbitraryBlock(scpi_t * context, const char * data, size_t len);
size_t SCPI_ResultBool(scpi_t * context, scpi_bool_t val);
+
scpi_bool_t SCPI_Parameter(scpi_t * context, scpi_parameter_t * parameter, scpi_bool_t mandatory);
scpi_bool_t SCPI_ParamIsValid(scpi_parameter_t * parameter);
scpi_bool_t SCPI_ParamErrorOccurred(scpi_t * context);
scpi_bool_t SCPI_ParamIsNumber(scpi_parameter_t * parameter, scpi_bool_t suffixAllowed);
- scpi_bool_t SCPI_ParamToInt(scpi_t * context, scpi_parameter_t * parameter, int32_t * value);
- scpi_bool_t SCPI_ParamToUnsignedInt(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value);
+ scpi_bool_t SCPI_ParamToInt32(scpi_t * context, scpi_parameter_t * parameter, int32_t * value);
+#define SCPI_ParamToInt(context, parameter, value) SCPI_ParamToInt32((context), (parameter), (value))
+ scpi_bool_t SCPI_ParamToUInt32(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value);
+#define SCPI_ParamToUnsignedInt(context, parameter, value) SCPI_ParamToUInt32((context), (parameter), (value))
+ scpi_bool_t SCPI_ParamToInt64(scpi_t * context, scpi_parameter_t * parameter, int64_t * value);
+ scpi_bool_t SCPI_ParamToUInt64(scpi_t * context, scpi_parameter_t * parameter, uint64_t * value);
scpi_bool_t SCPI_ParamToDouble(scpi_t * context, scpi_parameter_t * parameter, double * value);
scpi_bool_t SCPI_ParamToChoice(scpi_t * context, scpi_parameter_t * parameter, const scpi_choice_def_t * options, int32_t * value);
scpi_bool_t SCPI_ChoiceToName(const scpi_choice_def_t * options, int32_t tag, const char ** text);
- scpi_bool_t SCPI_ParamInt(scpi_t * context, int32_t * value, scpi_bool_t mandatory);
- scpi_bool_t SCPI_ParamUnsignedInt(scpi_t * context, uint32_t * value, scpi_bool_t mandatory);
+ scpi_bool_t SCPI_ParamInt32(scpi_t * context, int32_t * value, scpi_bool_t mandatory);
+#define SCPI_ParamInt(context, value, mandatory) SCPI_ParamInt32((context), (value), (mandatory))
+ scpi_bool_t SCPI_ParamUInt32(scpi_t * context, uint32_t * value, scpi_bool_t mandatory);
+#define SCPI_ParamUnsignedInt(context, value, mandatory) SCPI_ParamUInt32((context), (value), (mandatory))
+ scpi_bool_t SCPI_ParamInt64(scpi_t * context, int64_t * value, scpi_bool_t mandatory);
+ scpi_bool_t SCPI_ParamUInt64(scpi_t * context, uint64_t * value, scpi_bool_t mandatory);
scpi_bool_t SCPI_ParamDouble(scpi_t * context, double * value, scpi_bool_t mandatory);
scpi_bool_t SCPI_ParamCharacters(scpi_t * context, const char ** value, size_t * len, scpi_bool_t mandatory);
scpi_bool_t SCPI_ParamArbitraryBlock(scpi_t * context, const char ** value, size_t * len, scpi_bool_t mandatory);
diff --git a/libscpi/inc/scpi/utils.h b/libscpi/inc/scpi/utils.h
index 1731d0e..ba80b8e 100644
--- a/libscpi/inc/scpi/utils.h
+++ b/libscpi/inc/scpi/utils.h
@@ -43,7 +43,11 @@
extern "C" {
#endif
- size_t SCPI_LongToStr(int32_t val, char * str, size_t len, int8_t base);
+ size_t SCPI_Int32ToStr(int32_t val, char * str, size_t len, int8_t base);
+#define SCPI_LongToStr(val, str, len, base) SCPI_Int32ToStr((val), (str), (len), (base))
+ size_t SCPI_UInt32ToStr(uint32_t val, char * str, size_t len, int8_t base);
+ size_t SCPI_Int64ToStr(int64_t val, char * str, size_t len, int8_t base);
+ size_t SCPI_UInt64ToStr(uint64_t val, char * str, size_t len, int8_t base);
size_t SCPI_DoubleToStr(double val, char * str, size_t len);
#ifdef __cplusplus
diff --git a/libscpi/src/expression.c b/libscpi/src/expression.c
index 109e853..ffbdf39 100644
--- a/libscpi/src/expression.c
+++ b/libscpi/src/expression.c
@@ -143,9 +143,9 @@
res = SCPI_ExprNumericListEntry(context, param, index, &range, ¶mFrom, ¶mTo);
if (res == SCPI_EXPR_OK) {
*isRange = range;
- SCPI_ParamToInt(context, ¶mFrom, valueFrom);
+ SCPI_ParamToInt32(context, ¶mFrom, valueFrom);
if (range) {
- SCPI_ParamToInt(context, ¶mTo, valueTo);
+ SCPI_ParamToInt32(context, ¶mTo, valueTo);
}
}
diff --git a/libscpi/src/ieee488.c b/libscpi/src/ieee488.c
index 0593d23..5212c05 100644
--- a/libscpi/src/ieee488.c
+++ b/libscpi/src/ieee488.c
@@ -211,7 +211,7 @@
*/
scpi_result_t SCPI_CoreEse(scpi_t * context) {
int32_t new_ESE;
- if (SCPI_ParamInt(context, &new_ESE, TRUE)) {
+ if (SCPI_ParamInt32(context, &new_ESE, TRUE)) {
SCPI_RegSet(context, SCPI_REG_ESE, (scpi_reg_val_t)new_ESE);
}
return SCPI_RES_OK;
@@ -223,7 +223,7 @@
* @return
*/
scpi_result_t SCPI_CoreEseQ(scpi_t * context) {
- SCPI_ResultInt(context, SCPI_RegGet(context, SCPI_REG_ESE));
+ SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_ESE));
return SCPI_RES_OK;
}
@@ -233,7 +233,7 @@
* @return
*/
scpi_result_t SCPI_CoreEsrQ(scpi_t * context) {
- SCPI_ResultInt(context, SCPI_RegGet(context, SCPI_REG_ESR));
+ SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_ESR));
SCPI_RegSet(context, SCPI_REG_ESR, 0);
return SCPI_RES_OK;
}
@@ -278,7 +278,7 @@
*/
scpi_result_t SCPI_CoreOpcQ(scpi_t * context) {
/* Operation is always completed */
- SCPI_ResultInt(context, 1);
+ SCPI_ResultInt32(context, 1);
return SCPI_RES_OK;
}
@@ -301,7 +301,7 @@
*/
scpi_result_t SCPI_CoreSre(scpi_t * context) {
int32_t new_SRE;
- if (SCPI_ParamInt(context, &new_SRE, TRUE)) {
+ if (SCPI_ParamInt32(context, &new_SRE, TRUE)) {
SCPI_RegSet(context, SCPI_REG_SRE, (scpi_reg_val_t)new_SRE);
}
return SCPI_RES_OK;
@@ -313,7 +313,7 @@
* @return
*/
scpi_result_t SCPI_CoreSreQ(scpi_t * context) {
- SCPI_ResultInt(context, SCPI_RegGet(context, SCPI_REG_SRE));
+ SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_SRE));
return SCPI_RES_OK;
}
@@ -323,7 +323,7 @@
* @return
*/
scpi_result_t SCPI_CoreStbQ(scpi_t * context) {
- SCPI_ResultInt(context, SCPI_RegGet(context, SCPI_REG_STB));
+ SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_STB));
return SCPI_RES_OK;
}
@@ -334,7 +334,7 @@
*/
scpi_result_t SCPI_CoreTstQ(scpi_t * context) {
(void) context;
- SCPI_ResultInt(context, 0);
+ SCPI_ResultInt32(context, 0);
return SCPI_RES_OK;
}
diff --git a/libscpi/src/minimal.c b/libscpi/src/minimal.c
index dd18ba1..fcfc500 100644
--- a/libscpi/src/minimal.c
+++ b/libscpi/src/minimal.c
@@ -57,7 +57,7 @@
* @return
*/
scpi_result_t SCPI_StubQ(scpi_t * context) {
- SCPI_ResultInt(context, 0);
+ SCPI_ResultInt32(context, 0);
return SCPI_RES_OK;
}
@@ -79,7 +79,7 @@
scpi_result_t SCPI_SystemErrorNextQ(scpi_t * context) {
int16_t err = SCPI_ErrorPop(context);
- SCPI_ResultInt(context, err);
+ SCPI_ResultInt32(context, err);
SCPI_ResultText(context, SCPI_ErrorTranslate(err));
return SCPI_RES_OK;
@@ -91,7 +91,7 @@
* @return
*/
scpi_result_t SCPI_SystemErrorCountQ(scpi_t * context) {
- SCPI_ResultInt(context, SCPI_ErrorCount(context));
+ SCPI_ResultInt32(context, SCPI_ErrorCount(context));
return SCPI_RES_OK;
}
@@ -103,7 +103,7 @@
*/
scpi_result_t SCPI_StatusQuestionableEventQ(scpi_t * context) {
/* return value */
- SCPI_ResultInt(context, SCPI_RegGet(context, SCPI_REG_QUES));
+ SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_QUES));
/* clear register */
SCPI_RegSet(context, SCPI_REG_QUES, 0);
@@ -118,7 +118,7 @@
*/
scpi_result_t SCPI_StatusQuestionableEnableQ(scpi_t * context) {
/* return value */
- SCPI_ResultInt(context, SCPI_RegGet(context, SCPI_REG_QUESE));
+ SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_QUESE));
return SCPI_RES_OK;
}
@@ -130,7 +130,7 @@
*/
scpi_result_t SCPI_StatusQuestionableEnable(scpi_t * context) {
int32_t new_QUESE;
- if (SCPI_ParamInt(context, &new_QUESE, TRUE)) {
+ if (SCPI_ParamInt32(context, &new_QUESE, TRUE)) {
SCPI_RegSet(context, SCPI_REG_QUESE, (scpi_reg_val_t)new_QUESE);
}
return SCPI_RES_OK;
diff --git a/libscpi/src/parser.c b/libscpi/src/parser.c
index c9d63f4..dbba29e 100644
--- a/libscpi/src/parser.c
+++ b/libscpi/src/parser.c
@@ -317,13 +317,43 @@
}
/**
- * Write integer value to the result
+ * Write signed 32 bit integer value to the result
* @param context
* @param val
* @return
*/
-size_t SCPI_ResultInt(scpi_t * context, int32_t val) {
- return SCPI_ResultIntBase(context, val, 10);
+size_t SCPI_ResultInt32(scpi_t * context, int32_t val) {
+ return SCPI_ResultInt32Base(context, val, 10);
+}
+
+/**
+ * Write unsigned 32 bit integer value to the result
+ * @param context
+ * @param val
+ * @return
+ */
+size_t SCPI_ResultUInt32(scpi_t * context, uint32_t val) {
+ return SCPI_ResultUInt32Base(context, val, 10);
+}
+
+/**
+ * Write signed 64 bit integer value to the result
+ * @param context
+ * @param val
+ * @return
+ */
+size_t SCPI_ResultInt64(scpi_t * context, int64_t val) {
+ return SCPI_ResultInt64Base(context, val, 10);
+}
+
+/**
+ * Write unsigned 64 bit integer value to the result
+ * @param context
+ * @param val
+ * @return
+ */
+size_t SCPI_ResultUInt64(scpi_t * context, uint64_t val) {
+ return SCPI_ResultUInt64Base(context, val, 10);
}
/**
@@ -341,19 +371,19 @@
}
/**
- * Write integer value in specific base to the result
+ * Write signed 32 bit integer value in specific base to the result
* @param context
* @param val
* @param base
* @return
*/
-size_t SCPI_ResultIntBase(scpi_t * context, int32_t val, int8_t base) {
+size_t SCPI_ResultInt32Base(scpi_t * context, int32_t val, int8_t base) {
char buffer[33];
const char * basePrefix;
size_t result = 0;
size_t len;
- len = SCPI_LongToStr(val, buffer, sizeof (buffer), base);
+ len = SCPI_Int32ToStr(val, buffer, sizeof (buffer), base);
basePrefix = getBasePrefix(base);
result += writeDelimiter(context);
@@ -366,7 +396,82 @@
}
/**
- * Write double walue to the result
+ * Write unsigned 32 bit integer value in specific base to the result
+ * @param context
+ * @param val
+ * @param base
+ * @return
+ */
+size_t SCPI_ResultUInt32Base(scpi_t * context, uint32_t val, int8_t base) {
+ char buffer[33];
+ const char * basePrefix;
+ size_t result = 0;
+ size_t len;
+
+ len = SCPI_UInt32ToStr(val, buffer, sizeof (buffer), base);
+ basePrefix = getBasePrefix(base);
+
+ result += writeDelimiter(context);
+ if (basePrefix != NULL) {
+ result += writeData(context, basePrefix, 2);
+ }
+ result += writeData(context, buffer, len);
+ context->output_count++;
+ return result;
+}
+
+/**
+ * Write signed 64 bit integer value in specific base to the result
+ * @param context
+ * @param val
+ * @param base
+ * @return
+ */
+size_t SCPI_ResultInt64Base(scpi_t * context, int64_t val, int8_t base) {
+ char buffer[33]; //TODO
+ const char * basePrefix;
+ size_t result = 0;
+ size_t len;
+
+ len = SCPI_Int64ToStr(val, buffer, sizeof (buffer), base);
+ basePrefix = getBasePrefix(base);
+
+ result += writeDelimiter(context);
+ if (basePrefix != NULL) {
+ result += writeData(context, basePrefix, 2);
+ }
+ result += writeData(context, buffer, len);
+ context->output_count++;
+ return result;
+}
+
+/**
+ * Write unsigned 64 bit integer value in specific base to the result
+ * @param context
+ * @param val
+ * @param base
+ * @return
+ */
+size_t SCPI_ResultUInt64Base(scpi_t * context, uint64_t val, int8_t base) {
+ char buffer[33]; //TODO
+ const char * basePrefix;
+ size_t result = 0;
+ size_t len;
+
+ len = SCPI_UInt64ToStr(val, buffer, sizeof (buffer), base);
+ basePrefix = getBasePrefix(base);
+
+ result += writeDelimiter(context);
+ if (basePrefix != NULL) {
+ result += writeData(context, basePrefix, 2);
+ }
+ result += writeData(context, buffer, len);
+ context->output_count++;
+ return result;
+}
+
+/**
+ * Write double value to the result
* @param context
* @param val
* @return
@@ -411,7 +516,7 @@
char block_header[12];
size_t header_len;
block_header[0] = '#';
- SCPI_LongToStr(len, block_header + 2, 10, 10);
+ SCPI_Int32ToStr(len, block_header + 2, 10, 10);
header_len = strlen(block_header + 2);
block_header[1] = (char)(header_len + '0');
@@ -430,7 +535,7 @@
* @return
*/
size_t SCPI_ResultBool(scpi_t * context, scpi_bool_t val) {
- return SCPI_ResultIntBase(context, val ? 1 : 0, 10);
+ return SCPI_ResultInt32Base(context, val ? 1 : 0, 10);
}
/* parsing parameters */
@@ -526,13 +631,13 @@
}
/**
- * Convert parameter to integer
+ * Convert parameter to signed/unsigned 32 bit integer
* @param context
* @param parameter
* @param value result
* @return TRUE if succesful
*/
-static scpi_bool_t ParamToInt(scpi_t * context, scpi_parameter_t * parameter, int32_t * value, scpi_bool_t sign) {
+static scpi_bool_t ParamToInt32(scpi_t * context, scpi_parameter_t * parameter, int32_t * value, scpi_bool_t sign) {
if (!value) {
SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
@@ -541,44 +646,75 @@
switch (parameter->type) {
case SCPI_TOKEN_HEXNUM:
- return strToULong(parameter->ptr, (uint32_t *)value, 16) > 0 ? TRUE : FALSE;
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 16) > 0 ? TRUE : FALSE;
case SCPI_TOKEN_OCTNUM:
- return strToULong(parameter->ptr, (uint32_t *)value, 8) > 0 ? TRUE : FALSE;
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 8) > 0 ? TRUE : FALSE;
case SCPI_TOKEN_BINNUM:
- return strToULong(parameter->ptr, (uint32_t *)value, 2) > 0 ? TRUE : FALSE;
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 2) > 0 ? TRUE : FALSE;
case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
if (sign) {
- return strToLong(parameter->ptr, value, 10) > 0 ? TRUE : FALSE;
+ return strToInt32(parameter->ptr, value, 10) > 0 ? TRUE : FALSE;
} else {
- return strToULong(parameter->ptr, (uint32_t *)value, 10) > 0 ? TRUE : FALSE;
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 10) > 0 ? TRUE : FALSE;
}
default:
return FALSE;
}
}
-
/**
- * Convert parameter to integer
+ * Convert parameter to signed 32 bit integer
* @param context
* @param parameter
* @param value result
* @return TRUE if succesful
*/
-scpi_bool_t SCPI_ParamToInt(scpi_t * context, scpi_parameter_t * parameter, int32_t * value) {
- return ParamToInt(context, parameter, value, TRUE);
+scpi_bool_t SCPI_ParamToInt32(scpi_t * context, scpi_parameter_t * parameter, int32_t * value) {
+ return ParamToInt32(context, parameter, value, TRUE);
}
/**
- * Convert parameter to unsigned integer
+ * Convert parameter to unsigned 32 bit integer
* @param context
* @param parameter
* @param value result
* @return TRUE if succesful
*/
-scpi_bool_t SCPI_ParamToUnsignedInt(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value) {
- return ParamToInt(context, parameter, (int32_t *)value, FALSE);
+static scpi_bool_t ParamToUInt32(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value, scpi_bool_t sign) {
+
+ if (!value) {
+ SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
+ return FALSE;
+ }
+
+ switch (parameter->type) {
+ case SCPI_TOKEN_HEXNUM:
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 16) > 0 ? TRUE : FALSE;
+ case SCPI_TOKEN_OCTNUM:
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 8) > 0 ? TRUE : FALSE;
+ case SCPI_TOKEN_BINNUM:
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 2) > 0 ? TRUE : FALSE;
+ case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
+ case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
+ if (sign) {
+ return strToInt32(parameter->ptr, value, 10) > 0 ? TRUE : FALSE;
+ } else {
+ return strToUInt32(parameter->ptr, (uint32_t *)value, 10) > 0 ? TRUE : FALSE;
+ }
+ }
+ return FALSE;
+}
+
+/**
+ * Convert parameter to unsigned 32 bit integer
+ * @param context
+ * @param parameter
+ * @param value result
+ * @return TRUE if succesful
+ */
+scpi_bool_t SCPI_ParamToUInt32(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value) {
+ return ParamToInt32(context, parameter, (int32_t *)value, FALSE);
}
/**
@@ -602,7 +738,7 @@
case SCPI_TOKEN_HEXNUM:
case SCPI_TOKEN_OCTNUM:
case SCPI_TOKEN_BINNUM:
- result = SCPI_ParamToUnsignedInt(context, parameter, &valint);
+ result = SCPI_ParamToUInt32(context, parameter, &valint);
*value = valint;
break;
case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
@@ -647,13 +783,13 @@
}
/**
- * Read integer parameter
+ * Read signed/unsigned 32 bit integer parameter
* @param context
* @param value
* @param mandatory
* @return
*/
-static scpi_bool_t ParamInt(scpi_t * context, int32_t * value, scpi_bool_t mandatory, scpi_bool_t sign) {
+static scpi_bool_t ParamInt32(scpi_t * context, int32_t * value, scpi_bool_t mandatory, scpi_bool_t sign) {
scpi_bool_t result;
scpi_parameter_t param;
@@ -665,7 +801,7 @@
result = SCPI_Parameter(context, ¶m, mandatory);
if (result) {
if (SCPI_ParamIsNumber(¶m, FALSE)) {
- result = ParamToInt(context, ¶m, value, sign);
+ result = ParamToInt32(context, ¶m, value, sign);
} else if (SCPI_ParamIsNumber(¶m, TRUE)) {
SCPI_ErrorPush(context, SCPI_ERROR_SUFFIX_NOT_ALLOWED);
result = FALSE;
@@ -677,12 +813,26 @@
return result;
}
-scpi_bool_t SCPI_ParamInt(scpi_t * context, int32_t * value, scpi_bool_t mandatory) {
- return ParamInt(context, value, mandatory, TRUE);
+/**
+ * Read signed 32 bit integer parameter
+ * @param context
+ * @param value
+ * @param mandatory
+ * @return
+ */
+scpi_bool_t SCPI_ParamInt32(scpi_t * context, int32_t * value, scpi_bool_t mandatory) {
+ return ParamInt32(context, value, mandatory, TRUE);
}
-scpi_bool_t SCPI_ParamUnsignedInt(scpi_t * context, uint32_t * value, scpi_bool_t mandatory) {
- return ParamInt(context, (int32_t *)value, mandatory, FALSE);
+/**
+ * Read unsigned 32 bit integer parameter
+ * @param context
+ * @param value
+ * @param mandatory
+ * @return
+ */
+scpi_bool_t SCPI_ParamUInt32(scpi_t * context, uint32_t * value, scpi_bool_t mandatory) {
+ return ParamInt32(context, (int32_t *)value, mandatory, FALSE);
}
/**
@@ -879,7 +1029,7 @@
if (result) {
if (param.type == SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA) {
- SCPI_ParamToInt(context, ¶m, &intval);
+ SCPI_ParamToInt32(context, ¶m, &intval);
*value = intval ? TRUE : FALSE;
} else {
result = SCPI_ParamToChoice(context, ¶m, bool_options, &intval);
diff --git a/libscpi/src/utils.c b/libscpi/src/utils.c
index 47295c4..c0f26ff 100644
--- a/libscpi/src/utils.c
+++ b/libscpi/src/utils.c
@@ -76,7 +76,7 @@
* @param base output base
* @return number of bytes written to str (without '\0')
*/
-size_t SCPI_LongToStr(int32_t val, char * str, size_t len, int8_t base) {
+size_t SCPI_Int32ToStr(int32_t val, char * str, size_t len, int8_t base) {
const char digits[] = "0123456789ABCDEF";
#define ADD_CHAR(c) if (pos < len) str[pos++] = (c)
@@ -133,6 +133,184 @@
}
/**
+ * Converts unsigned 32b integer value to string
+ * @param val integer value
+ * @param str converted textual representation
+ * @param len string buffer length
+ * @param base output base
+ * @return number of bytes written to str (without '\0')
+ */
+size_t SCPI_UInt32ToStr(uint32_t val, char * str, size_t len, int8_t base) {
+ const char digits[] = "0123456789ABCDEF";
+
+#define ADD_CHAR(c) if (pos < len) str[pos++] = (c)
+ uint32_t x = 0;
+ int_fast8_t digit;
+ size_t pos = 0;
+
+ if (val == 0) {
+ ADD_CHAR('0');
+ } else {
+
+ switch (base) {
+ case 2:
+ x = 0x80000000L;
+ break;
+ case 8:
+ x = 0x40000000L;
+ break;
+ case 10:
+ x = 1000000000L;
+ break;
+ case 0x10:
+ x = 0x10000000L;
+ break;
+ default:
+ x = 1000000000L;
+ base = 10;
+ break;
+ }
+
+ // remove leading zeros
+ while ((val / x) == 0) {
+ x /= base;
+ }
+
+ do {
+ digit = (uint8_t) (val / x);
+ ADD_CHAR(digits[digit]);
+ val -= digit * x;
+ x /= base;
+ } while (x && (pos < len));
+ }
+
+ if (pos < len) str[pos] = 0;
+ return pos;
+#undef ADD_CHAR
+}
+
+/**
+ * Converts signed 64b integer value to string
+ * @param val integer value
+ * @param str converted textual representation
+ * @param len string buffer length
+ * @param base output base
+ * @return number of bytes written to str (without '\0')
+ */
+size_t SCPI_Int64ToStr(int64_t val, char * str, size_t len, int8_t base) {
+ const char digits[] = "0123456789ABCDEF";
+
+#define ADD_CHAR(c) if (pos < len) str[pos++] = (c)
+ uint64_t x = 0;
+ int_fast8_t digit;
+ size_t pos = 0;
+ uint64_t uval = val;
+
+ if (uval == 0) {
+ ADD_CHAR('0');
+ } else {
+
+ switch (base) {
+ case 2:
+ x = 0x8000000000000000LL;
+ break;
+ case 8:
+ x = 0x4000000000000000LL;
+ break;
+ case 10:
+ x = 100000000000000000LL;
+ break;
+ case 0x10:
+ x = 0x1000000000000000LL;
+ break;
+ default:
+ x = 100000000000000000LL;
+ base = 10;
+ break;
+ }
+
+ // add sign for numbers in base 10
+ if ((val < 0) && (base == 10)) {
+ uval = -val;
+ ADD_CHAR('-');
+ }
+
+ // remove leading zeros
+ while ((uval / x) == 0) {
+ x /= base;
+ }
+
+ do {
+ digit = (uint8_t) (uval / x);
+ ADD_CHAR(digits[digit]);
+ uval -= digit * x;
+ x /= base;
+ } while (x && (pos < len));
+ }
+
+ if (pos < len) str[pos] = 0;
+ return pos;
+#undef ADD_CHAR
+}
+
+/**
+ * Converts unsigned 64b integer value to string
+ * @param val integer value
+ * @param str converted textual representation
+ * @param len string buffer length
+ * @param base output base
+ * @return number of bytes written to str (without '\0')
+ */
+size_t SCPI_UInt64ToStr(uint64_t val, char * str, size_t len, int8_t base) {
+ const char digits[] = "0123456789ABCDEF";
+
+#define ADD_CHAR(c) if (pos < len) str[pos++] = (c)
+ uint64_t x = 0;
+ int_fast8_t digit;
+ size_t pos = 0;
+
+ if (val == 0) {
+ ADD_CHAR('0');
+ } else {
+
+ switch (base) {
+ case 2:
+ x = 0x8000000000000000LL;
+ break;
+ case 8:
+ x = 0x4000000000000000LL;
+ break;
+ case 10:
+ x = 100000000000000000LL;
+ break;
+ case 0x10:
+ x = 0x1000000000000000LL;
+ break;
+ default:
+ x = 1000000000L;
+ base = 10;
+ break;
+ }
+
+ // remove leading zeros
+ while ((val / x) == 0) {
+ x /= base;
+ }
+
+ do {
+ digit = (uint8_t) (val / x);
+ ADD_CHAR(digits[digit]);
+ val -= digit * x;
+ x /= base;
+ } while (x && (pos < len));
+ }
+
+ if (pos < len) str[pos] = 0;
+ return pos;
+#undef ADD_CHAR
+}
+
+/**
* Converts double value to string
* @param val double value
* @param str converted textual representation
@@ -149,7 +327,7 @@
* @param val 32bit integer result
* @return number of bytes used in string
*/
-size_t strToLong(const char * str, int32_t * val, int8_t base) {
+size_t strToInt32(const char * str, int32_t * val, int8_t base) {
char * endptr;
*val = strtol(str, &endptr, base);
return endptr - str;
@@ -161,7 +339,7 @@
* @param val 32bit integer result
* @return number of bytes used in string
*/
-size_t strToULong(const char * str, uint32_t * val, int8_t base) {
+size_t strToUInt32(const char * str, uint32_t * val, int8_t base) {
char * endptr;
*val = strtoul(str, &endptr, base);
return endptr - str;
@@ -224,7 +402,7 @@
//*num = 1;
} else {
int32_t tmpNum;
- i = len1 + strToLong(str2 + len1, &tmpNum, 10);
+ i = len1 + strToInt32(str2 + len1, &tmpNum, 10);
if (i != len2) {
result = FALSE;
} else {
@@ -494,7 +672,7 @@
}
/**
- * Compose command from previsou command anc current command
+ * Compose command from previous command anc current command
*
* @param prev pointer to previous command
* @param current pointer of current command
diff --git a/libscpi/src/utils_private.h b/libscpi/src/utils_private.h
index d454494..5e91276 100644
--- a/libscpi/src/utils_private.h
+++ b/libscpi/src/utils_private.h
@@ -54,8 +54,10 @@
char * strnpbrk(const char *str, size_t size, const char *set) LOCAL;
scpi_bool_t compareStr(const char * str1, size_t len1, const char * str2, size_t len2) LOCAL;
scpi_bool_t compareStrAndNum(const char * str1, size_t len1, const char * str2, size_t len2, int32_t * num) LOCAL;
- size_t strToLong(const char * str, int32_t * val, int8_t base) LOCAL;
- size_t strToULong(const char * str, uint32_t * val, int8_t base) LOCAL;
+ size_t strToInt32(const char * str, int32_t * val, int8_t base) LOCAL;
+ size_t strToUInt32(const char * str, uint32_t * val, int8_t base) LOCAL;
+ size_t strToInt64(const char * str, int64_t * val, int8_t base) LOCAL;
+ size_t strToUInt64(const char * str, uint64_t * val, int8_t base) LOCAL;
size_t strToDouble(const char * str, double * val) LOCAL;
scpi_bool_t locateText(const char * str1, size_t len1, const char ** str2, size_t * len2) LOCAL;
scpi_bool_t locateStr(const char * str1, size_t len1, const char ** str2, size_t * len2) LOCAL;
diff --git a/libscpi/test/test_parser.c b/libscpi/test/test_parser.c
index cbef1af..3ab2640 100644
--- a/libscpi/test/test_parser.c
+++ b/libscpi/test/test_parser.c
@@ -32,14 +32,14 @@
static scpi_result_t test_treeA(scpi_t* context) {
- SCPI_ResultInt(context, 10);
+ SCPI_ResultInt32(context, 10);
return SCPI_RES_OK;
}
static scpi_result_t test_treeB(scpi_t* context) {
- SCPI_ResultInt(context, 20);
+ SCPI_ResultInt32(context, 20);
return SCPI_RES_OK;
}
diff --git a/libscpi/test/test_scpi_utils.c b/libscpi/test/test_scpi_utils.c
index 0e9a8d5..3c637b7 100644
--- a/libscpi/test/test_scpi_utils.c
+++ b/libscpi/test/test_scpi_utils.c
@@ -66,33 +66,251 @@
}
-static void test_longToStr() {
- char str[32];
+static void test_Int32ToStr() {
+ const size_t max=32+1;
+ char str[max];
size_t len;
- len = SCPI_LongToStr(10, str, 32, 10);
- CU_ASSERT(len == 2);
- CU_ASSERT_STRING_EQUAL(str, "10");
+ // test conversion to decimal numbers
+ len = SCPI_Int32ToStr(0, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
CU_ASSERT(str[len] == '\0');
- len = SCPI_LongToStr(10, str, 32, 2);
- CU_ASSERT(len == 4);
- CU_ASSERT(str[0] == '1');
- CU_ASSERT(str[1] == '0');
- CU_ASSERT(str[2] == '1');
- CU_ASSERT(str[3] == '0');
- CU_ASSERT(str[4] == '\0');
-
- len = SCPI_LongToStr(10, str, 32, 16);
+ len = SCPI_Int32ToStr(1, str, max, 10);
CU_ASSERT(len == 1);
- CU_ASSERT(str[0] == 'A');
- CU_ASSERT(str[1] == '\0');
-
- len = SCPI_LongToStr(10, str, 32, 8);
+ CU_ASSERT_STRING_EQUAL(str, "1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(-1, str, max, 10);
CU_ASSERT(len == 2);
- CU_ASSERT(str[0] == '1');
- CU_ASSERT(str[1] == '2');
- CU_ASSERT(str[2] == '\0');
+ CU_ASSERT_STRING_EQUAL(str, "-1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0x7fffffff, str, max, 10);
+ CU_ASSERT(len == 10);
+ CU_ASSERT_STRING_EQUAL(str, "2147483647");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0x80000000, str, max, 10);
+ CU_ASSERT(len == 11);
+ CU_ASSERT_STRING_EQUAL(str, "-2147483648");
+ CU_ASSERT(str[len] == '\0');
+
+ // test conversion to binary numbers
+ len = SCPI_Int32ToStr(0, str, max, 2);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(1, str, max, 2);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(-1, str, max, 2);
+ CU_ASSERT(len == 32);
+ CU_ASSERT_STRING_EQUAL(str, "11111111111111111111111111111111");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0x01234567, str, max, 2);
+ CU_ASSERT(len == 25);
+ CU_ASSERT_STRING_EQUAL(str, "1001000110100010101100111");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0x89abcdef, str, max, 2);
+ CU_ASSERT(len == 32);
+ CU_ASSERT_STRING_EQUAL(str, "10001001101010111100110111101111");
+ CU_ASSERT(str[len] == '\0');
+
+ // test conversion to hexadecimal numbers
+ len = SCPI_Int32ToStr(0x0, str, max, 16);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0x01234567, str, max, 16);
+ CU_ASSERT(len == 7);
+ CU_ASSERT_STRING_EQUAL(str, "1234567");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0x89ABCDEF, str, max, 16);
+ CU_ASSERT(len == 8);
+ CU_ASSERT_STRING_EQUAL(str, "89ABCDEF");
+ CU_ASSERT(str[len] == '\0');
+
+ // test conversion to octal numbers
+ len = SCPI_Int32ToStr(0, str, max, 8);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(0xffffffff, str, max, 8);
+ CU_ASSERT(len == 11);
+ CU_ASSERT_STRING_EQUAL(str, "37777777777");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int32ToStr(076543210, str, max, 8);
+ CU_ASSERT(len == 8);
+ CU_ASSERT_STRING_EQUAL(str, "76543210");
+ CU_ASSERT(str[len] == '\0');
+}
+
+static void test_UInt32ToStr() {
+ const size_t max=32+1;
+ char str[max];
+ size_t len;
+
+ // test conversion to decimal numbers
+ len = SCPI_UInt32ToStr(0, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt32ToStr(1, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt32ToStr(-1, str, max, 10);
+ CU_ASSERT(len == 10);
+ CU_ASSERT_STRING_EQUAL(str, "4294967295");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt32ToStr(0x7fffffff, str, max, 10);
+ CU_ASSERT(len == 10);
+ CU_ASSERT_STRING_EQUAL(str, "2147483647");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt32ToStr(0x80000000, str, max, 10);
+ CU_ASSERT(len == 10);
+ CU_ASSERT_STRING_EQUAL(str, "2147483648");
+ CU_ASSERT(str[len] == '\0');
+}
+
+static void test_Int64ToStr() {
+ const size_t max=64+1;
+ char str[max];
+ size_t len;
+
+ // test conversion to decimal numbers
+ len = SCPI_Int64ToStr(0, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(1, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(-1, str, max, 10);
+ CU_ASSERT(len == 2);
+ CU_ASSERT_STRING_EQUAL(str, "-1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(0x7fffffffffffffff, str, max, 10);
+ CU_ASSERT(len == 19);
+ CU_ASSERT_STRING_EQUAL(str, "9223372036854775807");
+ CU_ASSERT(str[len] == '\0');
+ printf("\n");
+ printf(str);
+ printf("\n");
+
+ len = SCPI_Int64ToStr(0x8000000000000000, str, max, 10);
+ CU_ASSERT(len == 20);
+ CU_ASSERT_STRING_EQUAL(str, "-9223372036854775808");
+ CU_ASSERT(str[len] == '\0');
+
+ // test conversion to binary numbers
+ len = SCPI_Int64ToStr(0, str, max, 2);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(1, str, max, 2);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(-1, str, max, 2);
+ CU_ASSERT(len == 64);
+ CU_ASSERT_STRING_EQUAL(str, "1111111111111111111111111111111111111111111111111111111111111111");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(0x0123456789abcdef, str, max, 2);
+ CU_ASSERT(len == 57);
+ CU_ASSERT_STRING_EQUAL(str, "100100011010001010110011110001001101010111100110111101111");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(0xfedcba9876543210, str, max, 2);
+ CU_ASSERT(len == 64);
+ CU_ASSERT_STRING_EQUAL(str, "1111111011011100101110101001100001110110010101000011001000010000");
+ CU_ASSERT(str[len] == '\0');
+
+ // test conversion to hexadecimal numbers
+ len = SCPI_Int64ToStr(0x0, str, max, 16);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(0x0123456789abcdef, str, max, 16);
+ CU_ASSERT(len == 15);
+ CU_ASSERT_STRING_EQUAL(str, "123456789ABCDEF");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(0xfedcba9876543210, str, max, 16);
+ CU_ASSERT(len == 16);
+ CU_ASSERT_STRING_EQUAL(str, "FEDCBA9876543210");
+ CU_ASSERT(str[len] == '\0');
+
+ // test conversion to octal numbers
+ len = SCPI_Int64ToStr(0, str, max, 8);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(0xffffffffffffffff, str, max, 8);
+ CU_ASSERT(len == 22);
+ CU_ASSERT_STRING_EQUAL(str, "1777777777777777777777");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_Int64ToStr(076543210, str, max, 8);
+ CU_ASSERT(len == 8);
+ CU_ASSERT_STRING_EQUAL(str, "76543210");
+ CU_ASSERT(str[len] == '\0');
+}
+
+static void test_UInt64ToStr() {
+ const size_t max=64+1;
+ char str[max];
+ size_t len;
+
+ // test conversion to decimal numbers
+ len = SCPI_UInt64ToStr(0, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "0");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt64ToStr(1, str, max, 10);
+ CU_ASSERT(len == 1);
+ CU_ASSERT_STRING_EQUAL(str, "1");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt64ToStr(-1, str, max, 10);
+ CU_ASSERT(len == 20);
+ CU_ASSERT_STRING_EQUAL(str, "18446744073709551615");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt64ToStr(0x7fffffffffffffff, str, max, 10);
+ CU_ASSERT(len == 19);
+ CU_ASSERT_STRING_EQUAL(str, "9223372036854775807");
+ CU_ASSERT(str[len] == '\0');
+
+ len = SCPI_UInt64ToStr(0x8000000000000000, str, max, 10);
+ CU_ASSERT(len == 19);
+ CU_ASSERT_STRING_EQUAL(str, "9223372036854775808");
+ CU_ASSERT(str[len] == '\0');
}
static void test_doubleToStr() {
@@ -117,17 +335,17 @@
TEST_DOUBLE_TO_STR(-1.3e-30, 8, "-1.3e-30");
}
-static void test_strToLong() {
+static void test_strToInt32() {
size_t result;
int32_t val;
#define TEST_STR_TO_LONG(s, r, v, b) \
do { \
- result = strToLong(s, &val, b); \
+ result = strToInt32(s, &val, b); \
CU_ASSERT_EQUAL(val, v); \
CU_ASSERT_EQUAL(result, r); \
} while(0) \
-
+
TEST_STR_TO_LONG("", 0, 0, 10);
TEST_STR_TO_LONG("1", 1, 1, 10);
TEST_STR_TO_LONG("10", 2, 10, 10);
@@ -142,13 +360,13 @@
TEST_STR_TO_LONG("18", 1, 1, 8); // octal 1, 8 is ignored
}
-static void test_strToULong() {
+static void test_strToUInt32() {
size_t result;
uint32_t val;
#define TEST_STR_TO_ULONG(s, r, v, b) \
do { \
- result = strToULong(s, &val, b); \
+ result = strToUInt32(s, &val, b); \
CU_ASSERT_EQUAL(val, v); \
CU_ASSERT_EQUAL(result, r); \
} while(0) \
@@ -479,10 +697,13 @@
/* Add the tests to the suite */
if (0
|| (NULL == CU_add_test(pSuite, "strnpbrk", test_strnpbrk))
- || (NULL == CU_add_test(pSuite, "longToStr", test_longToStr))
+ || (NULL == CU_add_test(pSuite, "Int32ToStr", test_Int32ToStr))
+ || (NULL == CU_add_test(pSuite, "UInt32ToStr", test_UInt32ToStr))
+ || (NULL == CU_add_test(pSuite, "Int64ToStr", test_Int64ToStr))
+ || (NULL == CU_add_test(pSuite, "UInt64ToStr", test_UInt64ToStr))
|| (NULL == CU_add_test(pSuite, "doubleToStr", test_doubleToStr))
- || (NULL == CU_add_test(pSuite, "strToLong", test_strToLong))
- || (NULL == CU_add_test(pSuite, "strToULong", test_strToULong))
+ || (NULL == CU_add_test(pSuite, "strToInt32", test_strToInt32))
+ || (NULL == CU_add_test(pSuite, "strToUInt32", test_strToUInt32))
|| (NULL == CU_add_test(pSuite, "strToDouble", test_strToDouble))
|| (NULL == CU_add_test(pSuite, "compareStr", test_compareStr))
|| (NULL == CU_add_test(pSuite, "compareStrAndNum", test_compareStrAndNum))
--
Gitblit v1.9.1