/*- * Copyright (c) 2013 Jan Breuer * Richard.hmm * Copyright (c) 2012 Jan Breuer * * All Rights Reserved * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * 1. Redistributions of source code must retain the above copyright notice, * this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /** * @file scpi_utils.c * @date Thu Nov 15 10:58:45 UTC 2012 * * @brief Conversion routines and string manipulation routines * * */ #include #include #include #include #include "utils.h" static size_t patternSeparatorShortPos(const char * pattern, size_t len); static size_t patternSeparatorPos(const char * pattern, size_t len); static size_t cmdSeparatorPos(const char * cmd, size_t len); /** * Find the first occurrence in str of a character in set. * @param str * @param size * @param set * @return */ char * strnpbrk(const char *str, size_t size, const char *set) { const char *scanp; long c, sc; const char * strend = str + size; while ((strend != str) && ((c = *str++) != 0)) { for (scanp = set; (sc = *scanp++) != '\0';) if (sc == c) return ((char *) (str - 1)); } return (NULL); } /** * Converts signed 32b integer value to string * @param val integer value * @param str converted textual representation * @param len string buffer length * @return number of bytes written to str (without '\0') */ // TODO: add support for other bases size_t longToStr(int32_t val, char * str, size_t len, int8_t base) { uint32_t x = 1000000000L; int_fast8_t digit; size_t pos = 0; if (val == 0) { if (pos < len) str[pos++] = '0'; } else { if (val < 0) { val = -val; if (pos < len) str[pos++] = '-'; } while ((val / x) == 0) { x /= 10; } do { digit = (uint8_t) (val / x); if (pos < len) str[pos++] = digit + '0'; val -= digit * x; x /= 10; } while (x && (pos < len)); } if (pos < len) str[pos] = 0; return pos; } /** * Converts double value to string * @param val double value * @param str converted textual representation * @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); } /** * Converts string to signed 32bit integer representation * @param str string value * @param val 32bit integer result * @return number of bytes used in string */ size_t strToLong(const char * str, int32_t * val, int8_t base) { char * endptr; *val = strtol(str, &endptr, base); return endptr - str; } /** * Converts string to double representation * @param str string value * @param val double result * @return number of bytes used in string */ size_t strToDouble(const char * str, double * val) { char * endptr; *val = strtod(str, &endptr); return endptr - str; } /** * Compare two strings with exact length * @param str1 * @param len1 * @param str2 * @param len2 * @return TRUE if len1==len2 and "len" characters of both strings are equal */ bool_t compareStr(const char * str1, size_t len1, const char * str2, size_t len2) { if (len1 != len2) { return FALSE; } if (SCPI_strncasecmp(str1, str2, len2) == 0) { return TRUE; } return FALSE; } /** * Count white spaces from the beggining * @param cmd - command * @param len - max search length * @return number of white spaces */ size_t skipWhitespace(const char * cmd, size_t len) { size_t i; for (i = 0; i < len; i++) { if (!isspace((unsigned char) cmd[i])) { return i; } } return len; } /** * Pattern is composed from upper case an lower case letters. This function * search the first lowercase letter * @param pattern * @param len - max search length * @return position of separator or len */ 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])) { return i; } } return i; } /** * Find pattern separator position * @param pattern * @param len - max search length * @return position of separator or len */ size_t patternSeparatorPos(const char * pattern, size_t len) { char * separator = strnpbrk(pattern, len, "?:[]"); if (separator == NULL) { return len; } else { return separator - pattern; } } /** * Find command separator position * @param cmd - input command * @param len - max search length * @return position of separator or len */ size_t cmdSeparatorPos(const char * cmd, size_t len) { char * separator = strnpbrk(cmd, len, ":?"); size_t result; if (separator == NULL) { result = len; } else { result = separator - cmd; } return result; } /** * Match pattern and str. Pattern is in format UPPERCASElowercase * @param pattern * @param pattern_len * @param str * @param str_len * @return */ bool_t matchPattern(const char * pattern, size_t pattern_len, const char * str, size_t str_len) { int pattern_sep_pos_short = patternSeparatorShortPos(pattern, pattern_len); return compareStr(pattern, pattern_len, str, str_len) || compareStr(pattern, pattern_sep_pos_short, str, str_len); } /** * Compare pattern and command * @param pattern eg. [:MEASure]:VOLTage:DC? * @param cmd - command * @param len - max search length * @return TRUE if pattern matches, FALSE otherwise */ bool_t matchCommand(const char * pattern, const char * cmd, size_t len) { bool_t result = FALSE; int leftFlag = 0; // flag for '[' on left int rightFlag = 0; // flag for ']' on right int cmd_sep_pos = 0; 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); const char * cmd_end = cmd + cmd_len; /* now support optional keywords in pattern style, e.g. [:MEASure]:VOLTage:DC? */ if (pattern_ptr[0] == '[') { // skip first '[' pattern_len--; pattern_ptr++; leftFlag++; } if (pattern_ptr[0] == ':') { // skip first ':' pattern_len--; pattern_ptr++; } if (cmd_ptr[0] == ':') { /* handle errornouse ":*IDN?" */ if((cmd_len >= 2) && (cmd_ptr[1] != '*')) { cmd_len--; cmd_ptr++; } } while (1) { int pattern_sep_pos = patternSeparatorPos(pattern_ptr, pattern_end - pattern_ptr); if ((leftFlag > 0) && (rightFlag > 0)) { leftFlag--; rightFlag--; } else { cmd_sep_pos = cmdSeparatorPos(cmd_ptr, cmd_end - cmd_ptr); } if (matchPattern(pattern_ptr, pattern_sep_pos, cmd_ptr, cmd_sep_pos)) { pattern_ptr = pattern_ptr + pattern_sep_pos; cmd_ptr = cmd_ptr + cmd_sep_pos; result = TRUE; /* command is complete */ if ((pattern_ptr == pattern_end) && (cmd_ptr >= cmd_end)) { break; } /* pattern complete, but command not */ if ((pattern_ptr == pattern_end) && (cmd_ptr < cmd_end)) { result = FALSE; break; } /* command complete, but pattern not */ if (cmd_ptr >= cmd_end) { if (cmd_end == cmd_ptr) { if (cmd_ptr[0] == pattern_ptr[pattern_end - pattern_ptr - 1]) { break; /* exist optional keyword, command is complete */ } if (']' == pattern_ptr[pattern_end - pattern_ptr - 1]) { break; /* exist optional keyword, command is complete */ } } result = FALSE; break; } /* 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; cmd_ptr = cmd_ptr + 1; } else if ((pattern_ptr[1] == cmd_ptr[0]) && (pattern_ptr[0] == '[') && (pattern_ptr[1] == ':')) { pattern_ptr = pattern_ptr + 2; // for skip '[' in "[:" cmd_ptr = cmd_ptr + 1; leftFlag++; } else if ((pattern_ptr[1] == cmd_ptr[0]) && (pattern_ptr[0] == ']') && (pattern_ptr[1] == ':')) { pattern_ptr = pattern_ptr + 2; // for skip ']' in "]:" cmd_ptr = cmd_ptr + 1; } else if ((pattern_ptr[2] == cmd_ptr[0]) && (pattern_ptr[0] == ']') && (pattern_ptr[1] == '[') && (pattern_ptr[2] == ':')) { pattern_ptr = pattern_ptr + 3; // for skip '][' in "][:" cmd_ptr = cmd_ptr + 1; leftFlag++; } else if (((pattern_ptr[0] == ']') || (pattern_ptr[0] == '[')) && (*(pattern_end - 1) == '?') // last is '?' && (cmd_ptr[0] == '?')) { result = TRUE; // exist optional keyword, and they are end with '?' break; // command is complete OK } else { result = FALSE; break; } } else { pattern_ptr = pattern_ptr + 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 rightFlag++; } else if ((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 rightFlag++; } else { result = FALSE; break; } } } return result; } #if !HAVE_STRNLEN /* use FreeBSD strnlen */ /*- * Copyright (c) 2009 David Schultz * All rights reserved. */ size_t BSD_strnlen(const char *s, size_t maxlen) { size_t len; for (len = 0; len < maxlen; len++, s++) { if (!*s) break; } return (len); } #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++); if (c1 != c2) { return c1 - c2; } if (c1 = '\0') { return 0; } } return 0; } #endif