Diff: src/utils.c

Revision:

1:b497f235115a

Parent:

0:aad43948c45c

--- a/src/utils.c	Thu Apr 09 22:42:15 2015 +0000
+++ b/src/utils.c	Fri Aug 07 21:54:11 2015 +0000
@@ -1,4 +1,3 @@
-#define HAVE_STRNLEN    0
 /*-
  * Copyright (c) 2013 Jan Breuer
  *                    Richard.hmm
@@ -42,7 +41,8 @@
 #include <string.h>
 #include <ctype.h>
 
-#include "scpi/utils_private.h"
+#include "utils_private.h"
+#include "scpi/utils.h"
 
 static size_t patternSeparatorShortPos(const char * pattern, size_t len);
 static size_t patternSeparatorPos(const char * pattern, size_t len);
@@ -55,7 +55,7 @@
  * @param set
  * @return 
  */
-const char * strnpbrk(const char *str, size_t size, const char *set) {
+char * strnpbrk(const char *str, size_t size, const char *set) {
     const char *scanp;
     long c, sc;
     const char * strend = str + size;
@@ -63,7 +63,7 @@
     while ((strend != str) && ((c = *str++) != 0)) {
         for (scanp = set; (sc = *scanp++) != '\0';)
             if (sc == c)
-                return str - 1;
+                return ((char *) (str - 1));
     }
     return (NULL);
 }
@@ -73,35 +73,63 @@
  * @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 longToStr(int32_t val, char * str, size_t len) {
-    uint32_t x = 1000000000L;
+size_t SCPI_LongToStr(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)
+    uint32_t x = 0;
     int_fast8_t digit;
     size_t pos = 0;
+    uint32_t uval = val;
 
-    if (val == 0) {
-        if (pos < len) str[pos++] = '0';
+    if (uval == 0) {
+        ADD_CHAR('0');
     } else {
-        if (val < 0) {
-            val = -val;
-            if (pos < len) str[pos++] = '-';
+
+        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;
         }
 
-        while ((val / x) == 0) {
-            x /= 10;
+        // 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) (val / x);
-            if (pos < len) str[pos++] = digit + '0';
-            val -= digit * x;
-            x /= 10;
+            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
 }
 
 /**
@@ -111,8 +139,8 @@
  * @param len   string buffer length
  * @return number of bytes written to str (without '\0')
  */
-size_t doubleToStr(double val, char * str, size_t len) {
-    return snprintf(str, len, "%lg", val);
+size_t SCPI_DoubleToStr(double val, char * str, size_t len) {
+    return SCPIDEFINE_doubleToStr(val, str, len);
 }
 
 /**
@@ -121,9 +149,9 @@
  * @param val   32bit integer result
  * @return      number of bytes used in string
  */
-size_t strToLong(const char * str, int32_t * val) {
+size_t strToLong(const char * str, int32_t * val, int8_t base) {
     char * endptr;
-    *val = strtol(str, &endptr, 0);
+    *val = strtol(str, &endptr, base);
     return endptr - str;
 }
 
@@ -152,7 +180,7 @@
         return FALSE;
     }
 
-    if (SCPI_strncasecmp(str1, str2, len2) == 0) {
+    if (SCPIDEFINE_strncasecmp(str1, str2, len2) == 0) {
         return TRUE;
     }
 
@@ -167,7 +195,7 @@
  * @param len2
  * @return TRUE if strings match
  */
-scpi_bool_t compareStrAndNum(const char * str1, size_t len1, const char * str2, size_t len2) {
+scpi_bool_t compareStrAndNum(const char * str1, size_t len1, const char * str2, size_t len2, int32_t * num) {
     scpi_bool_t result = FALSE;
     size_t i;
 
@@ -175,222 +203,34 @@
         return FALSE;
     }
 
-    if (SCPI_strncasecmp(str1, str2, len1) == 0) {
+    if (SCPIDEFINE_strncasecmp(str1, str2, len1) == 0) {
         result = TRUE;
-    }
 
-    for (i = len1; i<len2; i++) {
-        if (!isdigit((int) str2[i])) {
-            result = FALSE;
-            break;
+        if (num) {
+            if (len1 == len2) {
+                *num = 1;
+            } else {
+                int32_t tmpNum;
+                i = len1 + strToLong(str2 + len1, &tmpNum, 10);
+                if (i != len2) {
+                    result = FALSE;
+                } else {
+                    *num = tmpNum;
+                }
+            }
+        } else {
+            for (i = len1; i<len2; i++) {
+                if (!isdigit((int) str2[i])) {
+                    result = FALSE;
+                    break;
+                }
+            }
         }
     }
 
     return result;
 }
 
-enum _locate_text_states {
-    STATE_FIRST_WHITESPACE,
-    STATE_TEXT_QUOTED,
-    STATE_TEXT,
-    STATE_LAST_WHITESPACE,
-    STATE_COMMA,
-    STATE_ERROR
-};
-typedef enum _locate_text_states locate_text_states;
-
-struct _locate_text_nfa {
-    locate_text_states state;
-    int32_t startIdx;
-    int32_t stopIdx;
-    size_t i;
-};
-typedef struct _locate_text_nfa locate_text_nfa;
-
-/**
- * Test locate text state, if it is correct final state
- */
-static scpi_bool_t isFinalState(locate_text_states state) {
-    return (
-        ((state) == STATE_COMMA)
-        || ((state) == STATE_LAST_WHITESPACE)
-        || ((state) == STATE_TEXT) ||
-        ((state) == STATE_FIRST_WHITESPACE)
-    );
-}
-
-/**
- * Perform locateText automaton to search string pattern
- * @param nfa stores automaton state
- * @param c current char processed
- */
-static scpi_bool_t locateTextAutomaton(locate_text_nfa * nfa, unsigned char c) {
-    switch(nfa->state) {
-        /* first state locating only white spaces */
-        case STATE_FIRST_WHITESPACE:
-            if(isspace(c)) {
-                nfa->startIdx = nfa->stopIdx = nfa->i + 1;
-            } else if (c == ',') {
-                nfa->state = STATE_COMMA;
-            } else if (c == '"') {
-                nfa->startIdx = nfa->i + 1;
-                nfa->state = STATE_TEXT_QUOTED;
-            } else {
-                nfa->startIdx = nfa->i;
-                nfa->stopIdx = nfa->i + 1;
-                nfa->state = STATE_TEXT;
-            }
-            break;
-        /* state locating any text inside "" */
-        case STATE_TEXT_QUOTED:
-            if(c == '"') {
-                nfa->state = STATE_LAST_WHITESPACE;
-                nfa->stopIdx = nfa->i;
-            }
-            break;
-        /* locate text ignoring quotes */
-        case STATE_TEXT:
-            if (c == ',') {
-                nfa->state = STATE_COMMA;
-            } else if (!isspace(c)) {
-                nfa->stopIdx = nfa->i + 1;
-            }
-            break;
-        /* locating text after last quote */
-        case STATE_LAST_WHITESPACE:
-            if (c == ',') {
-                nfa->state = STATE_COMMA;
-            } else if (!isspace(c)) {
-                nfa->state = STATE_ERROR;
-            }
-            break;
-
-        default:
-            break;
-    }
-
-    /* if it is terminating state, break from for loop */
-    if ((nfa->state == STATE_COMMA) || (nfa->state == STATE_ERROR)) {
-        return FALSE;
-    } else {
-        return TRUE;
-    }
-}
-
-/**
- * Locate text in string. Text is separated by two ""
- *   example: "text", next parameter
- *   regexp: ^[ \t\r\n]*"([^"]*)"[ \t\r\n]*,?
- *   regexp: ^[ \t\r\n]*([^,]*)[ \t\r\n]*,?
- * @param str1 string to be searched
- * @param len1 length of string
- * @param str2 result
- * @param len2 length of result
- * @return string str1 contains text and str2 was set
- */
-scpi_bool_t locateText(const char * str1, size_t len1, const char ** str2, size_t * len2) {
-    locate_text_nfa nfa;
-    nfa.state = STATE_FIRST_WHITESPACE;
-    nfa.startIdx = 0;
-    nfa.stopIdx = 0;
-
-    for (nfa.i = 0; nfa.i < len1; nfa.i++) {
-        if(FALSE == locateTextAutomaton(&nfa, str1[nfa.i])) {
-            break;
-        }
-    }
-
-    if (isFinalState(nfa.state)) {
-
-        if (str2) {
-            *str2 = &str1[nfa.startIdx];
-        }
-
-        if (len2) {
-            *len2 = nfa.stopIdx - nfa.startIdx;
-        }
-        return TRUE;
-    }
-    return FALSE;
-}
-
-/**
- * Perform locateStr automaton to search string pattern
- * @param nfa stores automaton state
- * @param c current char processed
- */
-static scpi_bool_t locateStrAutomaton(locate_text_nfa * nfa, unsigned char c) {
-    switch(nfa->state) {
-        /* first state locating only white spaces */
-        case STATE_FIRST_WHITESPACE:
-            if(isspace(c)) {
-                nfa->startIdx = nfa->stopIdx = nfa->i + 1;
-            } else if (c == ',') {
-                nfa->state = STATE_COMMA;
-            } else {
-                nfa->startIdx = nfa->i;
-                nfa->stopIdx = nfa->i + 1;
-                nfa->state = STATE_TEXT;
-            }
-            break;
-        /* locate text ignoring quotes */
-        case STATE_TEXT:
-            if (c == ',') {
-                nfa->state = STATE_COMMA;
-            } else if (!isspace(c)) {
-                nfa->stopIdx = nfa->i + 1;
-            }
-            break;
-
-        default:
-            break;            
-    }
-
-    /* if it is terminating state, break from for loop */
-    if ((nfa->state == STATE_COMMA) || (nfa->state == STATE_ERROR)) {
-        return FALSE;
-    } else {
-        return TRUE;
-    }
-}
-
-/**
- * Locate string in string.
- *   regexp: ^[ \t\r\n]*([^,]*)[ \t\r\n]*,?
- * @param str1 string to be searched
- * @param len1 length of string
- * @param str2 result
- * @param len2 length of result
- * @return string str1 contains text and str2 was set
- */
-scpi_bool_t locateStr(const char * str1, size_t len1, const char ** str2, size_t * len2) {
-    locate_text_nfa nfa;
-    nfa.state = STATE_FIRST_WHITESPACE;
-    nfa.startIdx = 0;
-    nfa.stopIdx = 0;
-
-
-    for (nfa.i = 0; nfa.i < len1; nfa.i++) {
-        if(FALSE == locateStrAutomaton(&nfa, str1[nfa.i])) {
-            break;
-        }
-    }
-
-    if (isFinalState(nfa.state)) {
-
-        if (str2) {
-            *str2 = &str1[nfa.startIdx];
-        }
-
-        if (len2) {
-            *len2 = nfa.stopIdx - nfa.startIdx;
-        }
-        return TRUE;
-    }
-    return FALSE;
-}
-
-
 /**
  * Count white spaces from the beggining
  * @param cmd - command
@@ -414,7 +254,7 @@
  * @param len - max search length
  * @return position of separator or len
  */
-size_t patternSeparatorShortPos(const char * pattern, size_t len) {
+static size_t patternSeparatorShortPos(const char * pattern, size_t len) {
     size_t i;
     for (i = 0; (i < len) && pattern[i]; i++) {
         if (islower((unsigned char) pattern[i])) {
@@ -430,9 +270,9 @@
  * @param len - max search length
  * @return position of separator or len
  */
-size_t patternSeparatorPos(const char * pattern, size_t len) {
+static size_t patternSeparatorPos(const char * pattern, size_t len) {
 
-    const char * separator = strnpbrk(pattern, len, "?:[]");
+    char * separator = strnpbrk(pattern, len, "?:[]");
     if (separator == NULL) {
         return len;
     } else {
@@ -446,8 +286,8 @@
  * @param len - max search length
  * @return position of separator or len
  */
-size_t cmdSeparatorPos(const char * cmd, size_t len) {
-    const char * separator = strnpbrk(cmd, len, ":?");
+static size_t cmdSeparatorPos(const char * cmd, size_t len) {
+    char * separator = strnpbrk(cmd, len, ":?");
     size_t result;
     if (separator == NULL) {
         result = len;
@@ -466,7 +306,7 @@
  * @param str_len
  * @return 
  */
-scpi_bool_t matchPattern(const char * pattern, size_t pattern_len, const char * str, size_t str_len) {
+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] == '#') {
@@ -474,8 +314,8 @@
 
         pattern_sep_pos_short = patternSeparatorShortPos(pattern, new_pattern_len);
 
-        return compareStrAndNum(pattern, new_pattern_len, str, str_len) ||
-                compareStrAndNum(pattern, pattern_sep_pos_short, str, str_len);
+        return compareStrAndNum(pattern, new_pattern_len, str, str_len, num) ||
+                compareStrAndNum(pattern, pattern_sep_pos_short, str, str_len, num);
     } else {
 
         pattern_sep_pos_short = patternSeparatorShortPos(pattern, pattern_len);
@@ -492,18 +332,21 @@
  * @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) {
+scpi_bool_t matchCommand(const char * pattern, const char * cmd, size_t len, int32_t *numbers, size_t numbers_len) {
     scpi_bool_t result = FALSE;
     int leftFlag = 0; // flag for '[' on left
     int rightFlag = 0; // flag for ']' on right
     int cmd_sep_pos = 0;
 
+    size_t numbers_idx = 0;
+    int32_t *number_ptr = NULL;
+
     const char * pattern_ptr = pattern;
     int pattern_len = strlen(pattern);
     const char * pattern_end = pattern + pattern_len;
 
     const char * cmd_ptr = cmd;
-    size_t cmd_len = SCPI_strnlen(cmd, len);
+    size_t cmd_len = SCPIDEFINE_strnlen(cmd, len);
     const char * cmd_end = cmd + cmd_len;
 
     /* now support optional keywords in pattern style, e.g. [:MEASure]:VOLTage:DC? */
@@ -519,7 +362,7 @@
 
     if (cmd_ptr[0] == ':') {
         /* handle errornouse ":*IDN?" */
-        if((cmd_len >= 2) && (cmd_ptr[1] != '*')) {
+        if ((cmd_len >= 2) && (cmd_ptr[1] != '*')) {
             cmd_len--;
             cmd_ptr++;
         }
@@ -535,7 +378,19 @@
             cmd_sep_pos = cmdSeparatorPos(cmd_ptr, cmd_end - cmd_ptr);
         }
 
-        if (matchPattern(pattern_ptr, pattern_sep_pos, cmd_ptr, cmd_sep_pos)) {
+        if (pattern_ptr[pattern_sep_pos - 1] == '#') {
+            if (numbers && (numbers_idx < numbers_len)) {
+                number_ptr = numbers + numbers_idx;
+                *number_ptr = 1; // default value
+            } else {
+                number_ptr = NULL;
+            }
+            numbers_idx++;
+        } else {
+            number_ptr = NULL;
+        }
+
+        if (matchPattern(pattern_ptr, pattern_sep_pos, cmd_ptr, cmd_sep_pos, number_ptr)) {
             pattern_ptr = pattern_ptr + pattern_sep_pos;
             cmd_ptr = cmd_ptr + cmd_sep_pos;
             result = TRUE;
@@ -619,74 +474,45 @@
 
 /**
  * Compose command from previsou command anc current command
- * 
- * @param ptr_prev pointer to previous command
- * @param len_prev length of previous command
- * @param pptr pointer to pointer of current command
- * @param plen pointer to length of current command
- * 
- * ptr_prev and ptr should be in the same memory buffer
- * 
- * Function will add part of previous command prior to ptr_prev
- * 
- * char * cmd = "meas:volt:dc?;ac?"
- * char * ptr_prev = cmd;
- * size_t len_prev = 13;
- * char * ptr = cmd + 14;
- * size_t len = 3;
- * 
- * composeCompoundCommand(ptr_prev, len_prev, &ptr, &len);
- * 
- * after calling this
- * 
- * 
- * 
+ *
+ * @param prev pointer to previous command
+ * @param current pointer of current command
+ *
+ * prev and current should be in the same memory buffer
  */
-scpi_bool_t composeCompoundCommand(char * ptr_prev, size_t len_prev,
-                              char ** pptr, size_t * plen) {
-    char * ptr;
-    size_t len;
+scpi_bool_t composeCompoundCommand(const scpi_token_t * prev, scpi_token_t * current) {
     size_t i;
 
     /* Invalid input */
-    if (pptr == NULL || plen == NULL)
+    if (current == NULL || current->ptr == NULL || current->len == 0)
         return FALSE;
 
     /* no previous command - nothing to do*/
-    if (ptr_prev == NULL || len_prev == 0)
+    if (prev->ptr == NULL || prev->len == 0)
         return TRUE;
-       
-    ptr = *pptr;
-    len = *plen;
-    
-    /* No current command */
-    if (len == 0 || ptr == NULL)
-        return FALSE;
-    
+
     /* Common command or command root - nothing to do */
-    if (ptr[0] == '*' || ptr[0] == ':')
+    if (current->ptr[0] == '*' || current->ptr[0] == ':')
         return TRUE;
-        
+
     /* Previsou command was common command - nothing to do */
-    if (ptr_prev[0] == '*')
+    if (prev->ptr[0] == '*')
         return TRUE;
-        
+
     /* Find last occurence of ':' */
-    for (i = len_prev; i > 0; i--) {
-        if (ptr_prev[i-1] == ':') {
+    for (i = prev->len; i > 0; i--) {
+        if (prev->ptr[i - 1] == ':') {
             break;
         }
     }
-    
+
     /* Previous command was simple command - nothing to do*/
     if (i == 0)
         return TRUE;
-    
-    ptr -= i;
-    len += i;
-    memmove(ptr, ptr_prev, i);
-    *plen = len;
-    *pptr = ptr;
+
+    current->ptr -= i;
+    current->len += i;
+    memmove(current->ptr, prev->ptr, i);
     return TRUE;
 }
 
@@ -712,20 +538,20 @@
 #endif
 
 #if !HAVE_STRNCASECMP && !HAVE_STRNICMP
+
 int OUR_strncasecmp(const char *s1, const char *s2, size_t n) {
     unsigned char c1, c2;
 
-    for(; n != 0; n--) {
-        c1 = tolower((unsigned char)*s1++);
-        c2 = tolower((unsigned char)*s2++);
+    for (; n != 0; n--) {
+        c1 = tolower((unsigned char) *s1++);
+        c2 = tolower((unsigned char) *s2++);
         if (c1 != c2) {
             return c1 - c2;
         }
-        if (c1 = '\0') {
+        if (c1 == '\0') {
             return 0;
         }
     }
     return 0;
 }
 #endif
-