added most new function declarations, replaced all usecases for old functio...

Iztok Jeras

2015-10-02 e9785c888dddb7449e741ed53796e995f0efa9f7

added most new function declarations, replaced all usecases for old functions, missing are most new implementations

 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;
}

 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;
}

 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);

 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

 libscpi/src/expression.c

@@ -143,9 +143,9 @@
    res = SCPI_ExprNumericListEntry(context, param, index, &range, &paramFrom, &paramTo);
    if (res == SCPI_EXPR_OK) {
        *isRange = range;
        SCPI_ParamToInt(context, &paramFrom, valueFrom);
        SCPI_ParamToInt32(context, &paramFrom, valueFrom);
        if (range) {
            SCPI_ParamToInt(context, &paramTo, valueTo);
            SCPI_ParamToInt32(context, &paramTo, valueTo);
        }
    }


 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;
}


 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;

 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, &param, mandatory);
    if (result) {
        if (SCPI_ParamIsNumber(&param, FALSE)) {
            result = ParamToInt(context, &param, value, sign);
            result = ParamToInt32(context, &param, value, sign);
        } else if (SCPI_ParamIsNumber(&param, 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, &param, &intval);
            SCPI_ParamToInt32(context, &param, &intval);
            *value = intval ? TRUE : FALSE;
        } else {
            result = SCPI_ParamToChoice(context, &param, bool_options, &intval);

 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

 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;

 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;
}

 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');
    CU_ASSERT_STRING_EQUAL(str, "1");
    CU_ASSERT(str[len] == '\0');
    
    len = SCPI_LongToStr(10, str, 32, 8);
    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,13 +335,13 @@
    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)                                          \
@@ -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))