Solve #16 Multiple Identical Capabilities

Jan Breuer

2015-04-25 94ccbc305cac38eb9c54384b9f47d3da6527299b

 libscpi/src/parser.c

@@ -39,19 +39,21 @@

#include "scpi/config.h"
#include "scpi/parser.h"
#include "utils.h"
#include "scpi/utils_private.h"
#include "scpi/utils.h"
#include "scpi/error.h"
#include "scpi/constants.h"


static size_t cmdTerminatorPos(const char * cmd, size_t len);
static size_t cmdlineSeparatorPos(const char * cmd, size_t len);
static const char * cmdlineSeparator(const char * cmd, size_t len);
static const char * cmdlineTerminator(const char * cmd, size_t len);
static const char * cmdlineNext(const char * cmd, size_t len);
static size_t skipCmdLine(const char * cmd, size_t len);

static void paramSkipBytes(scpi_t * context, size_t num);
static void paramSkipWhitespace(scpi_t * context);
static bool_t paramNext(scpi_t * context, bool_t mandatory);
static scpi_bool_t paramNext(scpi_t * context, scpi_bool_t mandatory);

/*
int _strnicmp(const char* s1, const char* s2, size_t len) {
@@ -125,14 +127,14 @@
 * Find next part of command
 * @param cmd - input command
 * @param len - max search length
 * @return Pointer to next part of command
 * @return number of characters to be skipped
 */
const char * cmdlineNext(const char * cmd, size_t len) {
size_t skipCmdLine(const char * cmd, size_t len) {
    const char * separator = cmdlineSeparator(cmd, len);
    if (separator == NULL) {
        return cmd + len;
        return len;
    } else {
        return separator + 1;
        return separator + 1 - cmd;
    }
}

@@ -190,6 +192,19 @@
}

/**
 * Conditionaly write ";"
 * @param context
 * @return number of characters written
 */
static size_t writeSemicolon(scpi_t * context) {
    if (context->output_count > 0) {
        return writeData(context, ";", 1);
    } else {
        return 0;
    }
}

/**
 * Process command
 * @param context
 */
@@ -197,6 +212,10 @@
    const scpi_command_t * cmd = context->paramlist.cmd;

    context->cmd_error = FALSE;

    /* conditionaly write ; */
    writeSemicolon(context);

    context->output_count = 0;
    context->input_count = 0;

@@ -207,9 +226,6 @@
            SCPI_ErrorPush(context, SCPI_ERROR_EXECUTION_ERROR);
        }
    }

    /* conditionaly write new line */
    writeNewLine(context);

    /* skip all whitespaces */
    paramSkipWhitespace(context);
@@ -225,16 +241,19 @@
 * @param context
 * @result TRUE if context->paramlist is filled with correct values
 */
static bool_t findCommand(scpi_t * context, const char * cmdline_ptr, size_t cmdline_len, size_t cmd_len) {
static scpi_bool_t findCommand(scpi_t * context, const char * cmdline_ptr, size_t cmdline_len, size_t cmd_len) {
    int32_t i;
    const scpi_command_t * cmd;

    for (i = 0; context->cmdlist[i].pattern != NULL; i++) {
        cmd = &context->cmdlist[i];
        if (matchCommand(cmd->pattern, cmdline_ptr, cmd_len)) {
        if (matchCommand(cmd->pattern, cmdline_ptr, cmd_len, NULL, 0)) {
            context->paramlist.cmd = cmd;
            context->paramlist.parameters = cmdline_ptr + cmd_len;
            context->paramlist.length = cmdline_len - cmd_len;
            context->paramlist.cmd_raw.data = cmdline_ptr;
            context->paramlist.cmd_raw.length = cmd_len;
            context->paramlist.cmd_raw.position = 0;
            return TRUE;
        }
    }
@@ -248,32 +267,44 @@
 * @param len - command line length
 * @return 1 if the last evaluated command was found
 */
int SCPI_Parse(scpi_t * context, const char * data, size_t len) {
int SCPI_Parse(scpi_t * context, char * data, size_t len) {
    int result = 0;
    const char * cmdline_end = data + len;
    const char * cmdline_ptr = data;
    char * cmdline_ptr = data;
    size_t cmd_len;
    size_t cmdline_len;
    char * cmdline_ptr_prev = NULL;
    size_t cmd_len_prev = 0;

    if (context == NULL) {
        return -1;
    }

    context->output_count = 0;

    while (cmdline_ptr < cmdline_end) {
        result = 0;
        cmd_len = cmdTerminatorPos(cmdline_ptr, cmdline_end - cmdline_ptr);
        cmdline_len = cmdlineSeparatorPos(cmdline_ptr, cmdline_end - cmdline_ptr);
        if (cmd_len > 0) {
            composeCompoundCommand(cmdline_ptr_prev, cmd_len_prev,
                                    &cmdline_ptr, &cmd_len);
            cmdline_len = cmdlineSeparatorPos(cmdline_ptr, cmdline_end - cmdline_ptr);
            if(findCommand(context, cmdline_ptr, cmdline_len, cmd_len)) {
                processCommand(context);
                result = 1;
                cmdline_ptr_prev = cmdline_ptr;
                cmd_len_prev = cmd_len;
            } else {
                SCPI_ErrorPush(context, SCPI_ERROR_UNDEFINED_HEADER);
            }
        }
        cmdline_ptr = cmdlineNext(cmdline_ptr, cmdline_end - cmdline_ptr);
        cmdline_ptr += skipCmdLine(cmdline_ptr, cmdline_end - cmdline_ptr);
        cmdline_ptr += skipWhitespace(cmdline_ptr, cmdline_end - cmdline_ptr);
    }

    /* conditionaly write new line */
    writeNewLine(context);

    return result;
}

@@ -285,6 +316,19 @@
 * @param interface
 */
void SCPI_Init(scpi_t * context) {
    if (context->idn[0] == NULL) {
        context->idn[0] = SCPI_DEFAULT_1_MANUFACTURE;
    }
    if (context->idn[1] == NULL) {
        context->idn[1] = SCPI_DEFAULT_2_MODEL;
    }
    if (context->idn[2] == NULL) {
        context->idn[2] = SCPI_DEFAULT_3;
    }
    if (context->idn[3] == NULL) {
        context->idn[3] = SCPI_DEFAULT_4_REVISION;
    }
    
    context->buffer.position = 0;
    SCPI_ErrorInit(context);
}
@@ -319,11 +363,14 @@

        ws = skipWhitespace(context->buffer.data, context->buffer.position);
        cmd_term = cmdlineTerminator(context->buffer.data + ws, context->buffer.position - ws);
        if (cmd_term != NULL) {
        while (cmd_term != NULL) {
            int curr_len = cmd_term - context->buffer.data;
            result = SCPI_Parse(context, context->buffer.data + ws, curr_len - ws);
            memmove(context->buffer.data, cmd_term, context->buffer.position - curr_len);
            context->buffer.position -= curr_len;
    
            ws = skipWhitespace(context->buffer.data, context->buffer.position);
            cmd_term = cmdlineTerminator(context->buffer.data + ws, context->buffer.position - ws);
        }
    }

@@ -356,7 +403,7 @@
size_t SCPI_ResultInt(scpi_t * context, int32_t val) {
    char buffer[12];
    size_t result = 0;
    size_t len = longToStr(val, buffer, sizeof (buffer));
    size_t len = SCPI_LongToStr(val, buffer, sizeof (buffer), 10);
    result += writeDelimiter(context);
    result += writeData(context, buffer, len);
    context->output_count++;
@@ -369,7 +416,7 @@
 * @param val
 * @return 
 */
size_t SCPI_ResultBool(scpi_t * context, bool_t val) {
size_t SCPI_ResultBool(scpi_t * context, scpi_bool_t val) {
   return SCPI_ResultInt(context, val ? 1 : 0);
}

@@ -382,7 +429,7 @@
size_t SCPI_ResultDouble(scpi_t * context, double val) {
    char buffer[32];
    size_t result = 0;
    size_t len = doubleToStr(val, buffer, sizeof (buffer));
    size_t len = SCPI_DoubleToStr(val, buffer, sizeof (buffer));
    result += writeDelimiter(context);
    result += writeData(context, buffer, len);
    context->output_count++;
@@ -436,7 +483,7 @@
 * @param mandatory
 * @return 
 */
bool_t paramNext(scpi_t * context, bool_t mandatory) {
scpi_bool_t paramNext(scpi_t * context, scpi_bool_t mandatory) {
    paramSkipWhitespace(context);
    if (context->paramlist.length == 0) {
        if (mandatory) {
@@ -464,7 +511,7 @@
 * @param mandatory
 * @return 
 */
bool_t SCPI_ParamInt(scpi_t * context, int32_t * value, bool_t mandatory) {
scpi_bool_t SCPI_ParamInt(scpi_t * context, int32_t * value, scpi_bool_t mandatory) {
    const char * param;
    size_t param_len;
    size_t num_len;
@@ -494,7 +541,7 @@
 * @param mandatory
 * @return 
 */
bool_t SCPI_ParamDouble(scpi_t * context, double * value, bool_t mandatory) {
scpi_bool_t SCPI_ParamDouble(scpi_t * context, double * value, scpi_bool_t mandatory) {
    const char * param;
    size_t param_len;
    size_t num_len;
@@ -520,12 +567,12 @@
/**
 * Parse string parameter
 * @param context
 * @param value
 * @param len
 * @param value Pointer to string buffer where pointer to non-null terminated string will be returned
 * @param len Length of returned non-null terminated string
 * @param mandatory
 * @return 
 */
bool_t SCPI_ParamString(scpi_t * context, const char ** value, size_t * len, bool_t mandatory) {
scpi_bool_t SCPI_ParamString(scpi_t * context, const char ** value, size_t * len, scpi_bool_t mandatory) {
    size_t length;

    if (!value || !len) {
@@ -551,12 +598,12 @@
/**
 * Parse text parameter (can be inside "")
 * @param context
 * @param value
 * @param len
 * @param value Pointer to string buffer where pointer to non-null terminated string will be returned
 * @param len Length of returned non-null terminated string
 * @param mandatory
 * @return 
 */
bool_t SCPI_ParamText(scpi_t * context, const char ** value, size_t * len, bool_t mandatory) {
scpi_bool_t SCPI_ParamText(scpi_t * context, const char ** value, size_t * len, scpi_bool_t mandatory) {
    size_t length;

    if (!value || !len) {
@@ -567,8 +614,10 @@
        return FALSE;
    }

    paramSkipWhitespace(context);
    if (locateText(context->paramlist.parameters, context->paramlist.length, value, &length)) {
        paramSkipBytes(context, length);
        paramSkipBytes(context, length + 2);
        paramSkipWhitespace(context);
        if (len) {
            *len = length;
        }
@@ -579,13 +628,13 @@
}

/**
 * Parse boolean parameter
 * Parse boolean parameter as described in the spec SCPI-99 7.3 Boolean Program Data
 * @param context
 * @param value
 * @param mandatory
 * @return 
 */
bool_t SCPI_ParamBool(scpi_t * context, bool_t * value, bool_t mandatory) {
scpi_bool_t SCPI_ParamBool(scpi_t * context, scpi_bool_t * value, scpi_bool_t mandatory) {
    const char * param;
    size_t param_len;
    size_t num_len;
@@ -599,9 +648,9 @@
        return FALSE;
    }

    if (matchPattern("ON", 2, param, param_len)) {
    if (matchPattern("ON", 2, param, param_len, NULL)) {
        *value = TRUE;
    } else if (matchPattern("OFF", 3, param, param_len)) {
    } else if (matchPattern("OFF", 3, param, param_len, NULL)) {
        *value = FALSE;
    } else {
        num_len = strToLong(param, &i);
@@ -625,7 +674,7 @@
 * @param mandatory
 * @return 
 */
bool_t SCPI_ParamChoice(scpi_t * context, const char * options[], size_t * value, bool_t mandatory) {
scpi_bool_t SCPI_ParamChoice(scpi_t * context, const char * options[], int32_t * value, scpi_bool_t mandatory) {
    const char * param;
    size_t param_len;
    size_t res;
@@ -638,14 +687,30 @@
        return FALSE;
    }

   for (res = 0; options[res]; ++res) {
       if (matchPattern(options[res], strlen(options[res]), param, param_len)) {
         *value = res;
         return TRUE;
      }
    for (res = 0; options[res]; ++res) {
        if (matchPattern(options[res], strlen(options[res]), param, param_len, NULL)) {
            *value = res;
            return TRUE;
        }
    }

   SCPI_ErrorPush(context, SCPI_ERROR_ILLEGAL_PARAMETER_VALUE);
    SCPI_ErrorPush(context, SCPI_ERROR_ILLEGAL_PARAMETER_VALUE);
    return FALSE;
}

scpi_bool_t SCPI_IsCmd(scpi_t * context, const char * cmd) {
    if (! context->paramlist.cmd) {
        return FALSE;
    }

    const char * pattern = context->paramlist.cmd->pattern;
    return matchCommand (pattern, cmd, strlen (cmd), NULL, 0);
}

scpi_bool_t SCPI_Match(const char * pattern, const char * value, size_t len) {
    return matchCommand (pattern, value, len, NULL, 0);
}

scpi_bool_t SCPI_CommandNumbers(scpi_t * context, int32_t * numbers, size_t len) {
    return matchCommand (context->paramlist.cmd->pattern,  context->paramlist.cmd_raw.data, context->paramlist.cmd_raw.length, numbers, len);
}