Add runtime endiannes test

Jan Breuer

2015-11-11 e0ca2f1cad67ac32fe8796fbb537125074eb849e

 libscpi/src/parser.c

@@ -118,9 +118,10 @@
 * Process command
 * @param context
 */
static void processCommand(scpi_t * context) {
static scpi_bool_t processCommand(scpi_t * context) {
    const scpi_command_t * cmd = context->param_list.cmd;
    lex_state_t * state = &context->param_list.lex_state;
    scpi_bool_t result = TRUE;

    /* conditionaly write ; */
    writeSemicolon(context);
@@ -128,18 +129,29 @@
    context->cmd_error = FALSE;
    context->output_count = 0;
    context->input_count = 0;
    context->arbitrary_reminding = 0;

    /* if callback exists - call command callback */
    if (cmd->callback != NULL) {
        if ((cmd->callback(context) != SCPI_RES_OK) && !context->cmd_error) {
            SCPI_ErrorPush(context, SCPI_ERROR_EXECUTION_ERROR);
        if ((cmd->callback(context) != SCPI_RES_OK)) {
            if (!context->cmd_error) {
                SCPI_ErrorPush(context, SCPI_ERROR_EXECUTION_ERROR);
            }
            result = FALSE;
        } else {
            if (context->cmd_error) {
                result = FALSE;
            }
        }
    }

    /* set error if command callback did not read all parameters */
    if (state->pos < (state->buffer + state->len) && !context->cmd_error) {
        SCPI_ErrorPush(context, SCPI_ERROR_PARAMETER_NOT_ALLOWED);
        result = FALSE;
    }

    return result;
}

/**
@@ -166,28 +178,27 @@
 * @param context
 * @param data - complete command line
 * @param len - command line length
 * @return 1 if the last evaluated command was found
 * @return FALSE if there was some error during evaluation of commands
 */
int SCPI_Parse(scpi_t * context, char * data, int len) {
    int result = 0;
scpi_bool_t SCPI_Parse(scpi_t * context, char * data, int len) {
    scpi_bool_t result = TRUE;
    scpi_parser_state_t * state;
    int r;
    scpi_token_t cmd_prev = {SCPI_TOKEN_UNKNOWN, NULL, 0};

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

    state = &context->parser_state;
    context->output_count = 0;

    while (1) {
        result = 0;

        r = scpiParser_detectProgramMessageUnit(state, data, len);

        if (state->programHeader.type == SCPI_TOKEN_INVALID) {
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_CHARACTER);
            result = FALSE;
        } else if (state->programHeader.len > 0) {

            composeCompoundCommand(&cmd_prev, &state->programHeader);
@@ -201,12 +212,11 @@
                context->param_list.cmd_raw.position = 0;
                context->param_list.cmd_raw.length = state->programHeader.len;

                processCommand(context);

                result = 1;
                result &= processCommand(context);
                cmd_prev = state->programHeader;
            } else {
                SCPI_ErrorPush(context, SCPI_ERROR_UNDEFINED_HEADER);
                result = FALSE;
            }
        }

@@ -260,8 +270,8 @@
 * @param len - length of data
 * @return
 */
int SCPI_Input(scpi_t * context, const char * data, int len) {
    int result = 0;
scpi_bool_t SCPI_Input(scpi_t * context, const char * data, int len) {
    scpi_bool_t result = TRUE;
    size_t totcmdlen = 0;
    int cmdlen = 0;

@@ -274,7 +284,11 @@

        buffer_free = context->buffer.length - context->buffer.position;
        if (len > (buffer_free - 1)) {
            return -1;
            /* Input buffer overrun - invalidate buffer */
            context->buffer.position = 0;
            context->buffer.data[context->buffer.position] = 0;
            SCPI_ErrorPush(context, SCPI_ERROR_INPUT_BUFFER_OVERRUN);
            return FALSE;
        }
        memcpy(&context->buffer.data[context->buffer.position], data, len);
        context->buffer.position += len;
@@ -473,14 +487,12 @@
}

/**
 * Write arbitrary block program data to the result
 * Write arbitrary block header with length
 * @param context
 * @param data
 * @param len
 * @return
 */
size_t SCPI_ResultArbitraryBlock(scpi_t * context, const char * data, size_t len) {
    size_t result = 0;
size_t SCPI_ResultArbitraryBlockHeader(scpi_t * context, size_t len) {
    char block_header[12];
    size_t header_len;
    block_header[0] = '#';
@@ -489,10 +501,44 @@
    header_len = strlen(block_header + 2);
    block_header[1] = (char) (header_len + '0');

    result += writeData(context, block_header, header_len + 2);
    result += writeData(context, data, len);
    context->arbitrary_reminding = len;
    return writeData(context, block_header, header_len + 2);
}

    context->output_count++;
/**
 * Add data to arbitrary block
 * @param context
 * @param data
 * @param len
 * @return
 */
size_t SCPI_ResultArbitraryBlockData(scpi_t * context, const void * data, size_t len) {

    if (context->arbitrary_reminding < len) {
        SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
        return 0;
    }

    context->arbitrary_reminding -= len;

    if (context->arbitrary_reminding == 0) {
        context->output_count++;
    }

    return writeData(context, (const char *) data, len);
}

/**
 * Write arbitrary block program data to the result
 * @param context
 * @param data
 * @param len
 * @return
 */
size_t SCPI_ResultArbitraryBlock(scpi_t * context, const void * data, size_t len) {
    size_t result = 0;
    result += SCPI_ResultArbitraryBlockHeader(context, len);
    result += SCPI_ResultArbitraryBlockData(context, data, len);
    return result;
}

@@ -1337,6 +1383,8 @@
    return matchCommand(pattern, cmd, strlen(cmd), NULL, 0, 0);
}

#if USE_COMMAND_TAGS

/**
 * Return the .tag field of the matching scpi_command_t
 * @param context
@@ -1349,6 +1397,7 @@
        return 0;
    }
}
#endif /* USE_COMMAND_TAGS */

scpi_bool_t SCPI_Match(const char * pattern, const char * value, size_t len) {
    return matchCommand(pattern, value, len, NULL, 0, 0);
@@ -1376,3 +1425,204 @@
scpi_bool_t SCPI_ParamErrorOccurred(scpi_t * context) {
    return context->cmd_error;
}

/**
 * Result binary array and swap bytes if needed (native endiannes != required endiannes)
 * @param context
 * @param array
 * @param count
 * @param item_size
 * @param format
 * @return 
 */
static size_t parserResultArrayBinary(scpi_t * context, const void * array, size_t count, size_t item_size, scpi_array_format_t format) {

    if (SCPI_GetNativeFormat() == format) {
        switch (item_size) {
            case 1:
            case 2:
            case 4:
            case 8:
                return SCPI_ResultArbitraryBlock(context, array, count * item_size);
            default:
                SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
                return 0;
        }
    } else {
        size_t result = 0;
        size_t i;
        switch (item_size) {
            case 1:
            case 2:
            case 4:
            case 8:
                result += SCPI_ResultArbitraryBlockHeader(context, count * item_size);
            default:
                SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR);
                return 0;
        }

        switch (item_size) {
            case 1:
                result += SCPI_ResultArbitraryBlockData(context, array, count);
                break;
            case 2:
                for (i = 0; i < count; i++) {
                    uint16_t val = SCPI_Swap16(((uint16_t*)array)[i]);
                    result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
                }
                break;
            case 4:
                for (i = 0; i < count; i++) {
                    uint32_t val = SCPI_Swap32(((uint32_t*)array)[i]);
                    result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
                }
                break;
            case 8:
                for (i = 0; i < count; i++) {
                    uint64_t val = SCPI_Swap64(((uint64_t*)array)[i]);
                    result += SCPI_ResultArbitraryBlockData(context, &val, item_size);
                }
                break;
        }

        return result;
    }
}


#define RESULT_ARRAY(func) do {\
    size_t result;\
    if (format == SCPI_FORMAT_ASCII) {\
        size_t i;\
        for (i = 0; i < count; i++) {\
            result += func(context, array[i]);\
        }\
        if (count > 0) {\
            result += count - 1; /* add length of commas */\
        }\
    } else {\
        result = parserResultArrayBinary(context, array, count, sizeof(*array), format);\
    }\
    return result;\
} while(0)

/**
 * Result array of signed 8bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return
 */
size_t SCPI_ResultArrayInt8(scpi_t * context, const int8_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt8);
}

/**
 * Result array of unsigned 8bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return
 */
size_t SCPI_ResultArrayUInt8(scpi_t * context, const uint8_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt8);
}

/**
 * Result array of signed 16bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayInt16(scpi_t * context, const int16_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt16);
}

/**
 * Result array of unsigned 16bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayUInt16(scpi_t * context, const uint16_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt16);
}

/**
 * Result array of signed 32bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayInt32(scpi_t * context, const int32_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt32);
}

/**
 * Result array of unsigned 32bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayUInt32(scpi_t * context, const uint32_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt32);
}

/**
 * Result array of signed 64bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayInt64(scpi_t * context, const int64_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultInt64);
}

/**
 * Result array of unsigned 64bit integers
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayUInt64(scpi_t * context, const uint64_t * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultUInt64);
}

/**
 * Result array of floats
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayFloat(scpi_t * context, const float * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultFloat);
}

/**
 * Result array of doubles
 * @param context
 * @param array
 * @param count
 * @param format
 * @return 
 */
size_t SCPI_ResultArrayDouble(scpi_t * context, const double * array, size_t count, scpi_array_format_t format) {
    RESULT_ARRAY(SCPI_ResultDouble);
}