Iztok Jeras
2015-10-05 c81d00810317502a7a97a2ee466dad00afb29955
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 = 0x8000000000000000LL;
                break;
            case 10:
                x = 1000000000000000000LL;
                break;
            case 0x10:
                x = 0x1000000000000000LL;
                break;
            default:
                x = 1000000000000000000LL;
                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 = 0x8000000000000000ULL;
                break;
            case 8:
                x = 0x8000000000000000ULL;
                break;
            case 10:
                x = 10000000000000000000ULL;
                break;
            case 0x10:
                x = 0x1000000000000000ULL;
                break;
            default:
                x = 10000000000000000000ULL;
                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,11 +327,24 @@
 * @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;
}
/**
 * Converts string to unsigned 32bit integer representation
 * @param str   string value
 * @param val   32bit integer result
 * @return      number of bytes used in string
 */
size_t strToUInt32(const char * str, uint32_t * val, int8_t base) {
    char * endptr;
    *val = strtoul(str, &endptr, base);
    return endptr - str;
}
/**
 * Converts string to double representation
@@ -208,10 +399,10 @@
        if (num) {
            if (len1 == len2) {
                *num = 1;
                //*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 {
@@ -309,7 +500,7 @@
scpi_bool_t matchPattern(const char * pattern, size_t pattern_len, const char * str, size_t str_len, int32_t * num) {
    int pattern_sep_pos_short;
    if (pattern[pattern_len - 1] == '#') {
    if ((pattern_len > 0) && pattern[pattern_len - 1] == '#') {
        size_t new_pattern_len = pattern_len - 1;
        pattern_sep_pos_short = patternSeparatorShortPos(pattern, new_pattern_len);
@@ -332,7 +523,7 @@
 * @param len - max search length
 * @return TRUE if pattern matches, FALSE otherwise
 */
scpi_bool_t matchCommand(const char * pattern, const char * cmd, size_t len, int32_t *numbers, size_t numbers_len) {
scpi_bool_t matchCommand(const char * pattern, const char * cmd, size_t len, int32_t *numbers, size_t numbers_len, int32_t default_value) {
    scpi_bool_t result = FALSE;
    int leftFlag = 0; // flag for '[' on left
    int rightFlag = 0; // flag for ']' on right
@@ -378,10 +569,10 @@
            cmd_sep_pos = cmdSeparatorPos(cmd_ptr, cmd_end - cmd_ptr);
        }
        if (pattern_ptr[pattern_sep_pos - 1] == '#') {
        if ((pattern_sep_pos > 0) && pattern_ptr[pattern_sep_pos - 1] == '#') {
            if (numbers && (numbers_idx < numbers_len)) {
                number_ptr = numbers + numbers_idx;
                *number_ptr = 1; // default value
                *number_ptr = default_value; // default value
            } else {
                number_ptr = NULL;
            }
@@ -391,7 +582,8 @@
        }
        if (matchPattern(pattern_ptr, pattern_sep_pos, cmd_ptr, cmd_sep_pos, number_ptr)) {
            pattern_ptr = pattern_ptr + pattern_sep_pos;
            pattern_ptr += pattern_sep_pos;
            pattern_len -= pattern_sep_pos;
            cmd_ptr = cmd_ptr + cmd_sep_pos;
            result = TRUE;
@@ -422,24 +614,28 @@
            /* both command and patter contains command separator at this position */
            if ((pattern_ptr[0] == cmd_ptr[0]) && ((pattern_ptr[0] == ':') || (pattern_ptr[0] == '?'))) {
                pattern_ptr = pattern_ptr + 1;
                pattern_ptr += 1;
                pattern_len -= 1;
                cmd_ptr = cmd_ptr + 1;
            } else if ((pattern_ptr[1] == cmd_ptr[0])
            } else if ((pattern_len > 1) && (pattern_ptr[1] == cmd_ptr[0])
                    && (pattern_ptr[0] == '[')
                    && (pattern_ptr[1] == ':')) {
                pattern_ptr = pattern_ptr + 2; // for skip '[' in "[:"
                pattern_ptr += 2; // for skip '[' in "[:"
                pattern_len -= 2;
                cmd_ptr = cmd_ptr + 1;
                leftFlag++;
            } else if ((pattern_ptr[1] == cmd_ptr[0])
            } else if ((pattern_len > 1) &&  (pattern_ptr[1] == cmd_ptr[0])
                    && (pattern_ptr[0] == ']')
                    && (pattern_ptr[1] == ':')) {
                pattern_ptr = pattern_ptr + 2; // for skip ']' in "]:"
                pattern_ptr += 2; // for skip ']' in "]:"
                pattern_len -= 2;
                cmd_ptr = cmd_ptr + 1;
            } else if ((pattern_ptr[2] == cmd_ptr[0])
            } else if ((pattern_len > 2) && (pattern_ptr[2] == cmd_ptr[0])
                    && (pattern_ptr[0] == ']')
                    && (pattern_ptr[1] == '[')
                    && (pattern_ptr[2] == ':')) {
                pattern_ptr = pattern_ptr + 3; // for skip '][' in "][:"
                pattern_ptr += 3; // for skip '][' in "][:"
                pattern_len -= 3;
                cmd_ptr = cmd_ptr + 1;
                leftFlag++;
            } else if (((pattern_ptr[0] == ']')
@@ -453,14 +649,17 @@
                break;
            }
        } else {
            pattern_ptr = pattern_ptr + pattern_sep_pos;
            pattern_ptr += pattern_sep_pos;
            pattern_len -= pattern_sep_pos;
            if ((pattern_ptr[0] == ']') && (pattern_ptr[1] == ':')) {
                pattern_ptr = pattern_ptr + 2; // for skip ']' in "]:" , pattern_ptr continue, while cmd_ptr remain unchanged
                pattern_ptr += 2; // for skip ']' in "]:" , pattern_ptr continue, while cmd_ptr remain unchanged
                pattern_len -= 2;
                rightFlag++;
            } else if ((pattern_ptr[0] == ']')
            } else if ((pattern_len > 2) && (pattern_ptr[0] == ']')
                    && (pattern_ptr[1] == '[')
                    && (pattern_ptr[2] == ':')) {
                pattern_ptr = pattern_ptr + 3; // for skip ']' in "][:" , pattern_ptr continue, while cmd_ptr remain unchanged
                pattern_ptr += 3; // for skip ']' in "][:" , pattern_ptr continue, while cmd_ptr remain unchanged
                pattern_len -= 3;
                rightFlag++;
            } else {
                result = FALSE;
@@ -473,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