From 007889b4128e8656c55ba31404a698e98719c262 Mon Sep 17 00:00:00 2001 From: Jan Breuer <jan.breuer@mobatime.cz> Date: 周六, 14 7月 2018 01:57:31 +0800 Subject: [PATCH] Fix license wordings to correspond with BSD-2-Clause --- libscpi/src/parser.c | 1025 ++++++++++++++++++++++++++++++++++++++++++++++++++------ 1 files changed, 906 insertions(+), 119 deletions(-) diff --git a/libscpi/src/parser.c b/libscpi/src/parser.c index dfe84d7..0e85599 100644 --- a/libscpi/src/parser.c +++ b/libscpi/src/parser.c @@ -1,28 +1,29 @@ /*- - * Copyright (c) 2012-2013 Jan Breuer, + * BSD 2-Clause License * - * All Rights Reserved + * Copyright (c) 2012-2018, 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. + * modification, are permitted provided that the following conditions are met: * - * 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. + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER 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. */ /** @@ -53,7 +54,11 @@ * @return number of bytes written */ static size_t writeData(scpi_t * context, const char * data, size_t len) { - return context->interface->write(context, data, len); + if (len > 0) { + return context->interface->write(context, data, len); + } else { + return 0; + } } /** @@ -118,9 +123,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 +134,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; } /** @@ -153,7 +170,7 @@ for (i = 0; context->cmdlist[i].pattern != NULL; i++) { cmd = &context->cmdlist[i]; - if (matchCommand(cmd->pattern, header, len, NULL, 0)) { + if (matchCommand(cmd->pattern, header, len, NULL, 0, 0)) { context->param_list.cmd = cmd; return TRUE; } @@ -166,28 +183,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 +217,15 @@ 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); + /* place undefined header with error */ + /* calculate length of errornouse header and trim \r\n */ + size_t r2 = r; + while (r2 > 0 && (data[r2 - 1] == '\r' || data[r2 - 1] == '\n')) r2--; + SCPI_ErrorPushEx(context, SCPI_ERROR_UNDEFINED_HEADER, data, r2); + result = FALSE; } } @@ -228,27 +247,53 @@ /** * Initialize SCPI context structure * @param context - * @param command_list - * @param buffer + * @param commands * @param interface + * @param units + * @param idn1 + * @param idn2 + * @param idn3 + * @param idn4 + * @param input_buffer + * @param input_buffer_length + * @param error_queue_data + * @param error_queue_size */ -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; - } - +void SCPI_Init(scpi_t * context, + const scpi_command_t * commands, + scpi_interface_t * interface, + const scpi_unit_def_t * units, + const char * idn1, const char * idn2, const char * idn3, const char * idn4, + char * input_buffer, size_t input_buffer_length, + scpi_error_t * error_queue_data, int16_t error_queue_size) { + memset(context, 0, sizeof (*context)); + context->cmdlist = commands; + context->interface = interface; + context->units = units; + context->idn[0] = idn1; + context->idn[1] = idn2; + context->idn[2] = idn3; + context->idn[3] = idn4; + context->buffer.data = input_buffer; + context->buffer.length = input_buffer_length; context->buffer.position = 0; - SCPI_ErrorInit(context); + SCPI_ErrorInit(context, error_queue_data, error_queue_size); } + +#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION && !USE_MEMORY_ALLOCATION_FREE + +/** + * Initialize context's + * @param context + * @param data + * @param len + * @return + */ +void SCPI_InitHeap(scpi_t * context, + char * error_info_heap, size_t error_info_heap_length) { + scpiheap_init(&context->error_info_heap, error_info_heap, error_info_heap_length); +} +#endif /** * Interface to the application. Adds data to system buffer and try to search @@ -260,8 +305,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 +319,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; @@ -317,16 +366,6 @@ } /** - * Write integer value to the result - * @param context - * @param val - * @return - */ -size_t SCPI_ResultInt(scpi_t * context, int32_t val) { - return SCPI_ResultIntBase(context, val, 10); -} - -/** * Return prefix of nondecimal base * @param base * @return @@ -341,19 +380,20 @@ } /** - * Write integer value in specific base to the result + * Write signed/unsigned 32 bit integer value in specific base to the result * @param context * @param val * @param base + * @param sign * @return */ -size_t SCPI_ResultIntBase(scpi_t * context, int32_t val, int8_t base) { - char buffer[33]; +static size_t resultUInt32BaseSign(scpi_t * context, uint32_t val, int8_t base, scpi_bool_t sign) { + char buffer[32 + 1]; const char * basePrefix; size_t result = 0; size_t len; - len = SCPI_LongToStr(val, buffer, sizeof (buffer), base); + len = UInt32ToStrBaseSign(val, buffer, sizeof (buffer), base, sign); basePrefix = getBasePrefix(base); result += writeDelimiter(context); @@ -366,7 +406,90 @@ } /** - * Write double walue to the result + * Write signed/unsigned 64 bit integer value in specific base to the result + * @param context + * @param val + * @param base + * @param sign + * @return + */ +static size_t resultUInt64BaseSign(scpi_t * context, uint64_t val, int8_t base, scpi_bool_t sign) { + char buffer[64 + 1]; + const char * basePrefix; + size_t result = 0; + size_t len; + + len = UInt64ToStrBaseSign(val, buffer, sizeof (buffer), base, sign); + basePrefix = getBasePrefix(base); + + result += writeDelimiter(context); + if (basePrefix != NULL) { + result += writeData(context, basePrefix, 2); + } + result += writeData(context, buffer, len); + context->output_count++; + return result; +} + +/** + * Write signed 32 bit integer value to the result + * @param context + * @param val + * @return + */ +size_t SCPI_ResultInt32(scpi_t * context, int32_t val) { + return resultUInt32BaseSign(context, val, 10, TRUE); +} + +/** + * Write unsigned 32 bit integer value in specific base to the result + * Write signed/unsigned 32 bit integer value in specific base to the result + * @param context + * @param val + * @return + */ +size_t SCPI_ResultUInt32Base(scpi_t * context, uint32_t val, int8_t base) { + return resultUInt32BaseSign(context, val, base, FALSE); +} + +/** + * Write signed 64 bit integer value to the result + * @param context + * @param val + * @return + */ +size_t SCPI_ResultInt64(scpi_t * context, int64_t val) { + return resultUInt64BaseSign(context, val, 10, TRUE); +} + +/** + * Write unsigned 64 bit integer value in specific base to the result + * @param context + * @param val + * @return + */ +size_t SCPI_ResultUInt64Base(scpi_t * context, uint64_t val, int8_t base) { + return resultUInt64BaseSign(context, val, base, FALSE); +} + +/** + * Write float (32 bit) value to the result + * @param context + * @param val + * @return + */ +size_t SCPI_ResultFloat(scpi_t * context, float val) { + char buffer[32]; + size_t result = 0; + size_t len = SCPI_FloatToStr(val, buffer, sizeof (buffer)); + result += writeDelimiter(context); + result += writeData(context, buffer, len); + context->output_count++; + return result; +} + +/** + * Write double (64bit) value to the result * @param context * @param val * @return @@ -379,7 +502,6 @@ result += writeData(context, buffer, len); context->output_count++; return result; - } /** @@ -390,13 +512,132 @@ */ size_t SCPI_ResultText(scpi_t * context, const char * data) { size_t result = 0; + size_t len = strlen(data); + const char * quote; result += writeDelimiter(context); result += writeData(context, "\"", 1); - // TODO: convert " to "" - result += writeData(context, data, strlen(data)); + while ((quote = strnpbrk(data, len, "\""))) { + result += writeData(context, data, quote - data + 1); + result += writeData(context, "\"", 1); + len -= quote - data + 1; + data = quote + 1; + } + result += writeData(context, data, len); result += writeData(context, "\"", 1); context->output_count++; return result; +} + +/** + * SCPI-99:21.8 Device-dependent error information. + * Write error information with the following syntax: + * <Error/event_number>,"<Error/event_description>[;<Device-dependent_info>]" + * The maximum string length of <Error/event_description> plus <Device-dependent_info> + * is SCPI_STD_ERROR_DESC_MAX_STRING_LENGTH (255) characters. + * + * @param context + * @param error + * @return + */ +size_t SCPI_ResultError(scpi_t * context, scpi_error_t * error) { + size_t result = 0; + size_t outputlimit = SCPI_STD_ERROR_DESC_MAX_STRING_LENGTH; + size_t step = 0; + const char * quote; + + const char * data[SCPIDEFINE_DESCRIPTION_MAX_PARTS]; + size_t len[SCPIDEFINE_DESCRIPTION_MAX_PARTS]; + size_t i; + + data[0] = SCPI_ErrorTranslate(error->error_code); + len[0] = strlen(data[0]); + +#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION + data[1] = error->device_dependent_info; +#if USE_MEMORY_ALLOCATION_FREE + len[1] = error->device_dependent_info ? strlen(data[1]) : 0; +#else + SCPIDEFINE_get_parts(&context->error_info_heap, data[1], &len[1], &data[2], &len[2]); +#endif +#endif + + result += SCPI_ResultInt32(context, error->error_code); + result += writeDelimiter(context); + result += writeData(context, "\"", 1); + + for (i = 0; (i < SCPIDEFINE_DESCRIPTION_MAX_PARTS) && data[i] && outputlimit; i++) { + if (i == 1) { + result += writeSemicolon(context); + outputlimit -= 1; + } + if (len[i] > outputlimit) { + len[i] = outputlimit; + } + + while ((quote = strnpbrk(data[i], len[i], "\""))) { + if ((step = quote - data[i] + 1) >= outputlimit) { + len[i] -= 1; + outputlimit -= 1; + break; + } + result += writeData(context, data[i], step); + result += writeData(context, "\"", 1); + len[i] -= step; + outputlimit -= step + 1; + data[i] = quote + 1; + if (len[i] > outputlimit) { + len[i] = outputlimit; + } + } + + result += writeData(context, data[i], len[i]); + outputlimit -= len[i]; + } + result += writeData(context, "\"", 1); + + return result; +} + +/** + * Write arbitrary block header with length + * @param context + * @param len + * @return + */ +size_t SCPI_ResultArbitraryBlockHeader(scpi_t * context, size_t len) { + char block_header[12]; + size_t header_len; + block_header[0] = '#'; + SCPI_UInt32ToStrBase((uint32_t) len, block_header + 2, 10, 10); + + header_len = strlen(block_header + 2); + block_header[1] = (char) (header_len + '0'); + + context->arbitrary_reminding = len; + return writeData(context, block_header, header_len + 2); +} + +/** + * 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); } /** @@ -406,20 +647,10 @@ * @param len * @return */ -size_t SCPI_ResultArbitraryBlock(scpi_t * context, const char * data, size_t len) { +size_t SCPI_ResultArbitraryBlock(scpi_t * context, const void * data, size_t len) { size_t result = 0; - char block_header[12]; - size_t header_len; - block_header[0] = '#'; - SCPI_LongToStr(len, block_header + 2, 10, 10); - - 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->output_count++; + result += SCPI_ResultArbitraryBlockHeader(context, len); + result += SCPI_ResultArbitraryBlockData(context, data, len); return result; } @@ -430,7 +661,7 @@ * @return */ size_t SCPI_ResultBool(scpi_t * context, scpi_bool_t val) { - return SCPI_ResultIntBase(context, val ? 1 : 0, 10); + return resultUInt32BaseSign(context, val ? 1 : 0, 10, FALSE); } /* parsing parameters */ @@ -469,7 +700,7 @@ if (mandatory) { SCPI_ErrorPush(context, SCPI_ERROR_MISSING_PARAMETER); } else { - parameter->type = SCPI_TOKEN_PROGRAM_MNEMONIC; // TODO: select something different + parameter->type = SCPI_TOKEN_PROGRAM_MNEMONIC; /* TODO: select something different */ } return FALSE; } @@ -526,13 +757,14 @@ } /** - * Convert parameter to integer + * Convert parameter to signed/unsigned 32 bit integer * @param context * @param parameter * @param value result + * @param sign * @return TRUE if succesful */ -scpi_bool_t SCPI_ParamToInt(scpi_t * context, scpi_parameter_t * parameter, int32_t * value) { +static scpi_bool_t ParamSignToUInt32(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value, scpi_bool_t sign) { if (!value) { SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); @@ -541,28 +773,144 @@ switch (parameter->type) { case SCPI_TOKEN_HEXNUM: - return strToLong(parameter->ptr, value, 16) > 0 ? TRUE : FALSE; + return strBaseToUInt32(parameter->ptr, value, 16) > 0 ? TRUE : FALSE; case SCPI_TOKEN_OCTNUM: - return strToLong(parameter->ptr, value, 8) > 0 ? TRUE : FALSE; + return strBaseToUInt32(parameter->ptr, value, 8) > 0 ? TRUE : FALSE; case SCPI_TOKEN_BINNUM: - return strToLong(parameter->ptr, value, 2) > 0 ? TRUE : FALSE; + return strBaseToUInt32(parameter->ptr, value, 2) > 0 ? TRUE : FALSE; case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA: case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX: - return strToLong(parameter->ptr, value, 10) > 0 ? TRUE : FALSE; + if (sign) { + return strBaseToInt32(parameter->ptr, (int32_t *) value, 10) > 0 ? TRUE : FALSE; + } else { + return strBaseToUInt32(parameter->ptr, value, 10) > 0 ? TRUE : FALSE; + } + default: + return FALSE; } - return FALSE; } /** - * Convert parameter to double + * Convert parameter to signed/unsigned 64 bit integer + * @param context + * @param parameter + * @param value result + * @param sign + * @return TRUE if succesful + */ +static scpi_bool_t ParamSignToUInt64(scpi_t * context, scpi_parameter_t * parameter, uint64_t * value, scpi_bool_t sign) { + + if (!value) { + SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); + return FALSE; + } + + switch (parameter->type) { + case SCPI_TOKEN_HEXNUM: + return strBaseToUInt64(parameter->ptr, value, 16) > 0 ? TRUE : FALSE; + case SCPI_TOKEN_OCTNUM: + return strBaseToUInt64(parameter->ptr, value, 8) > 0 ? TRUE : FALSE; + case SCPI_TOKEN_BINNUM: + return strBaseToUInt64(parameter->ptr, value, 2) > 0 ? TRUE : FALSE; + case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA: + case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX: + if (sign) { + return strBaseToInt64(parameter->ptr, (int64_t *) value, 10) > 0 ? TRUE : FALSE; + } else { + return strBaseToUInt64(parameter->ptr, value, 10) > 0 ? TRUE : FALSE; + } + default: + return FALSE; + } +} + +/** + * Convert parameter to signed 32 bit integer + * @param context + * @param parameter + * @param value result + * @return TRUE if succesful + */ +scpi_bool_t SCPI_ParamToInt32(scpi_t * context, scpi_parameter_t * parameter, int32_t * value) { + return ParamSignToUInt32(context, parameter, (uint32_t *) value, TRUE); +} + +/** + * Convert parameter to unsigned 32 bit integer + * @param context + * @param parameter + * @param value result + * @return TRUE if succesful + */ +scpi_bool_t SCPI_ParamToUInt32(scpi_t * context, scpi_parameter_t * parameter, uint32_t * value) { + return ParamSignToUInt32(context, parameter, value, FALSE); +} + +/** + * Convert parameter to signed 64 bit integer + * @param context + * @param parameter + * @param value result + * @return TRUE if succesful + */ +scpi_bool_t SCPI_ParamToInt64(scpi_t * context, scpi_parameter_t * parameter, int64_t * value) { + return ParamSignToUInt64(context, parameter, (uint64_t *) value, TRUE); +} + +/** + * Convert parameter to unsigned 32 bit integer + * @param context + * @param parameter + * @param value result + * @return TRUE if succesful + */ +scpi_bool_t SCPI_ParamToUInt64(scpi_t * context, scpi_parameter_t * parameter, uint64_t * value) { + return ParamSignToUInt64(context, parameter, value, FALSE); +} + +/** + * Convert parameter to float (32 bit) + * @param context + * @param parameter + * @param value result + * @return TRUE if succesful + */ +scpi_bool_t SCPI_ParamToFloat(scpi_t * context, scpi_parameter_t * parameter, float * value) { + scpi_bool_t result; + uint32_t valint; + + if (!value) { + SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); + return FALSE; + } + + switch (parameter->type) { + case SCPI_TOKEN_HEXNUM: + case SCPI_TOKEN_OCTNUM: + case SCPI_TOKEN_BINNUM: + result = SCPI_ParamToUInt32(context, parameter, &valint); + *value = valint; + break; + case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA: + case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX: + result = strToFloat(parameter->ptr, value) > 0 ? TRUE : FALSE; + break; + default: + result = FALSE; + } + return result; +} + +/** + * Convert parameter to double (64 bit) * @param context * @param parameter * @param value result * @return TRUE if succesful */ scpi_bool_t SCPI_ParamToDouble(scpi_t * context, scpi_parameter_t * parameter, double * value) { - scpi_bool_t result = FALSE; - int32_t valint; + scpi_bool_t result; + uint64_t valint; if (!value) { SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); @@ -573,19 +921,52 @@ case SCPI_TOKEN_HEXNUM: case SCPI_TOKEN_OCTNUM: case SCPI_TOKEN_BINNUM: - result = SCPI_ParamToInt(context, parameter, &valint); + result = SCPI_ParamToUInt64(context, parameter, &valint); *value = valint; break; case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA: case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX: result = strToDouble(parameter->ptr, value) > 0 ? TRUE : FALSE; break; + default: + result = FALSE; } return result; } /** - * Read floating point parameter + * Read floating point float (32 bit) parameter + * @param context + * @param value + * @param mandatory + * @return + */ +scpi_bool_t SCPI_ParamFloat(scpi_t * context, float * value, scpi_bool_t mandatory) { + scpi_bool_t result; + scpi_parameter_t param; + + if (!value) { + SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); + return FALSE; + } + + result = SCPI_Parameter(context, ¶m, mandatory); + if (result) { + if (SCPI_ParamIsNumber(¶m, FALSE)) { + SCPI_ParamToFloat(context, ¶m, value); + } else if (SCPI_ParamIsNumber(¶m, TRUE)) { + SCPI_ErrorPush(context, SCPI_ERROR_SUFFIX_NOT_ALLOWED); + result = FALSE; + } else { + SCPI_ErrorPush(context, SCPI_ERROR_DATA_TYPE_ERROR); + result = FALSE; + } + } + return result; +} + +/** + * Read floating point double (64 bit) parameter * @param context * @param value * @param mandatory @@ -616,13 +997,14 @@ } /** - * Read integer parameter + * Read signed/unsigned 32 bit integer parameter * @param context * @param value * @param mandatory + * @param sign * @return */ -scpi_bool_t SCPI_ParamInt(scpi_t * context, int32_t * value, scpi_bool_t mandatory) { +static scpi_bool_t ParamSignUInt32(scpi_t * context, uint32_t * value, scpi_bool_t mandatory, scpi_bool_t sign) { scpi_bool_t result; scpi_parameter_t param; @@ -634,7 +1016,7 @@ result = SCPI_Parameter(context, ¶m, mandatory); if (result) { if (SCPI_ParamIsNumber(¶m, FALSE)) { - SCPI_ParamToInt(context, ¶m, value); + result = ParamSignToUInt32(context, ¶m, value, sign); } else if (SCPI_ParamIsNumber(¶m, TRUE)) { SCPI_ErrorPush(context, SCPI_ERROR_SUFFIX_NOT_ALLOWED); result = FALSE; @@ -644,6 +1026,82 @@ } } return result; +} + +/** + * Read signed/unsigned 64 bit integer parameter + * @param context + * @param value + * @param mandatory + * @param sign + * @return + */ +static scpi_bool_t ParamSignUInt64(scpi_t * context, uint64_t * value, scpi_bool_t mandatory, scpi_bool_t sign) { + scpi_bool_t result; + scpi_parameter_t param; + + if (!value) { + SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); + return FALSE; + } + + result = SCPI_Parameter(context, ¶m, mandatory); + if (result) { + if (SCPI_ParamIsNumber(¶m, FALSE)) { + result = ParamSignToUInt64(context, ¶m, value, sign); + } else if (SCPI_ParamIsNumber(¶m, TRUE)) { + SCPI_ErrorPush(context, SCPI_ERROR_SUFFIX_NOT_ALLOWED); + result = FALSE; + } else { + SCPI_ErrorPush(context, SCPI_ERROR_DATA_TYPE_ERROR); + result = FALSE; + } + } + return result; +} + +/** + * Read signed 32 bit integer parameter + * @param context + * @param value + * @param mandatory + * @return + */ +scpi_bool_t SCPI_ParamInt32(scpi_t * context, int32_t * value, scpi_bool_t mandatory) { + return ParamSignUInt32(context, (uint32_t *) value, mandatory, TRUE); +} + +/** + * Read unsigned 32 bit integer parameter + * @param context + * @param value + * @param mandatory + * @return + */ +scpi_bool_t SCPI_ParamUInt32(scpi_t * context, uint32_t * value, scpi_bool_t mandatory) { + return ParamSignUInt32(context, value, mandatory, FALSE); +} + +/** + * Read signed 64 bit integer parameter + * @param context + * @param value + * @param mandatory + * @return + */ +scpi_bool_t SCPI_ParamInt64(scpi_t * context, int64_t * value, scpi_bool_t mandatory) { + return ParamSignUInt64(context, (uint64_t *) value, mandatory, TRUE); +} + +/** + * Read unsigned 64 bit integer parameter + * @param context + * @param value + * @param mandatory + * @return + */ +scpi_bool_t SCPI_ParamUInt64(scpi_t * context, uint64_t * value, scpi_bool_t mandatory) { + return ParamSignUInt64(context, value, mandatory, FALSE); } /** @@ -665,10 +1123,19 @@ result = SCPI_Parameter(context, ¶m, mandatory); if (result) { - *value = param.ptr; - *len = param.len; + switch (param.type) { + case SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA: + case SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA: + *value = param.ptr + 1; + *len = param.len - 2; + break; + default: + *value = param.ptr; + *len = param.len; + break; + } - // TODO: return also parameter type (ProgramMnemonic, ArbitraryBlockProgramData, SingleQuoteProgramData, DoubleQuoteProgramData + /* TODO: return also parameter type (ProgramMnemonic, ArbitraryBlockProgramData, SingleQuoteProgramData, DoubleQuoteProgramData */ } return result; @@ -724,7 +1191,7 @@ case SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA: case SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA: quote = param.type == SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA ? '\'' : '"'; - for (i_from = 0, i_to = 0; i_from < (size_t) param.len; i_from++) { + for (i_from = 1, i_to = 0; i_from < (size_t) (param.len - 1); i_from++) { if (i_from >= buffer_len) { break; } @@ -733,6 +1200,10 @@ if (param.ptr[i_from] == quote) { i_from++; } + } + *copy_len = i_to; + if (i_to < buffer_len) { + buffer[i_to] = 0; } break; default: @@ -800,6 +1271,15 @@ return FALSE; } +/* + * Definition of BOOL choice list + */ +const scpi_choice_def_t scpi_bool_def[] = { + {"OFF", 0}, + {"ON", 1}, + SCPI_CHOICE_LIST_END /* termination of option list */ +}; + /** * Read BOOL parameter (0,1,ON,OFF) * @param context @@ -812,12 +1292,6 @@ scpi_parameter_t param; int32_t intval; - scpi_choice_def_t bool_options[] = { - {"OFF", 0}, - {"ON", 1}, - SCPI_CHOICE_LIST_END /* termination of option list */ - }; - if (!value) { SCPI_ErrorPush(context, SCPI_ERROR_SYSTEM_ERROR); return FALSE; @@ -827,10 +1301,10 @@ if (result) { if (param.type == SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA) { - SCPI_ParamToInt(context, ¶m, &intval); + SCPI_ParamToInt32(context, ¶m, &intval); *value = intval ? TRUE : FALSE; } else { - result = SCPI_ParamToChoice(context, ¶m, bool_options, &intval); + result = SCPI_ParamToChoice(context, ¶m, scpi_bool_def, &intval); if (result) { *value = intval ? TRUE : FALSE; } @@ -1021,8 +1495,10 @@ } pattern = context->param_list.cmd->pattern; - return matchCommand (pattern, cmd, strlen (cmd), NULL, 0); + return matchCommand(pattern, cmd, strlen(cmd), NULL, 0, 0); } + +#if USE_COMMAND_TAGS /** * Return the .tag field of the matching scpi_command_t @@ -1036,11 +1512,322 @@ 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); + return matchCommand(pattern, value, len, NULL, 0, 0); } -scpi_bool_t SCPI_CommandNumbers(scpi_t * context, int32_t * numbers, size_t len) { - return matchCommand (context->param_list.cmd->pattern, context->param_list.cmd_raw.data, context->param_list.cmd_raw.length, numbers, len); +scpi_bool_t SCPI_CommandNumbers(scpi_t * context, int32_t * numbers, size_t len, int32_t default_value) { + return matchCommand(context->param_list.cmd->pattern, context->param_list.cmd_raw.data, context->param_list.cmd_raw.length, numbers, len, default_value); +} + +/** + * If SCPI_Parameter() returns FALSE, this function can detect, if the parameter + * is just missing (TRUE) or if there was an error during processing of the command (FALSE) + * @param parameter + * @return + */ +scpi_bool_t SCPI_ParamIsValid(scpi_parameter_t * parameter) { + return parameter->type == SCPI_TOKEN_UNKNOWN ? FALSE : TRUE; +} + +/** + * Returns TRUE if there was an error during parameter handling + * @param context + * @return + */ +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 produceResultArrayBinary(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); + break; + 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 = 0;\ + if (format == SCPI_FORMAT_ASCII) {\ + size_t i;\ + for (i = 0; i < count; i++) {\ + result += func(context, array[i]);\ + }\ + } else {\ + result = produceResultArrayBinary(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); +} + +/* + * Template macro to generate all SCPI_ParamArrayXYZ function + */ +#define PARAM_ARRAY_TEMPLATE(func) do{\ + if (format != SCPI_FORMAT_ASCII) return FALSE;\ + for (*o_count = 0; *o_count < i_count; (*o_count)++) {\ + if (!func(context, &data[*o_count], mandatory)) {\ + break;\ + }\ + mandatory = FALSE;\ + }\ + return mandatory ? FALSE : TRUE;\ +}while(0) + +/** + * Read list of values up to i_count + * @param context + * @param data - array to fill + * @param i_count - number of elements of data + * @param o_count - real number of filled elements + * @param mandatory + * @return TRUE on success + */ +scpi_bool_t SCPI_ParamArrayInt32(scpi_t * context, int32_t *data, size_t i_count, size_t *o_count, scpi_array_format_t format, scpi_bool_t mandatory) { + PARAM_ARRAY_TEMPLATE(SCPI_ParamInt32); +} + +/** + * Read list of values up to i_count + * @param context + * @param data - array to fill + * @param i_count - number of elements of data + * @param o_count - real number of filled elements + * @param mandatory + * @return TRUE on success + */ +scpi_bool_t SCPI_ParamArrayUInt32(scpi_t * context, uint32_t *data, size_t i_count, size_t *o_count, scpi_array_format_t format, scpi_bool_t mandatory) { + PARAM_ARRAY_TEMPLATE(SCPI_ParamUInt32); +} + +/** + * Read list of values up to i_count + * @param context + * @param data - array to fill + * @param i_count - number of elements of data + * @param o_count - real number of filled elements + * @param mandatory + * @return TRUE on success + */ +scpi_bool_t SCPI_ParamArrayInt64(scpi_t * context, int64_t *data, size_t i_count, size_t *o_count, scpi_array_format_t format, scpi_bool_t mandatory) { + PARAM_ARRAY_TEMPLATE(SCPI_ParamInt64); +} + +/** + * Read list of values up to i_count + * @param context + * @param data - array to fill + * @param i_count - number of elements of data + * @param o_count - real number of filled elements + * @param mandatory + * @return TRUE on success + */ +scpi_bool_t SCPI_ParamArrayUInt64(scpi_t * context, uint64_t *data, size_t i_count, size_t *o_count, scpi_array_format_t format, scpi_bool_t mandatory) { + PARAM_ARRAY_TEMPLATE(SCPI_ParamUInt64); +} + +/** + * Read list of values up to i_count + * @param context + * @param data - array to fill + * @param i_count - number of elements of data + * @param o_count - real number of filled elements + * @param mandatory + * @return TRUE on success + */ +scpi_bool_t SCPI_ParamArrayFloat(scpi_t * context, float *data, size_t i_count, size_t *o_count, scpi_array_format_t format, scpi_bool_t mandatory) { + PARAM_ARRAY_TEMPLATE(SCPI_ParamFloat); +} + +/** + * Read list of values up to i_count + * @param context + * @param data - array to fill + * @param i_count - number of elements of data + * @param o_count - real number of filled elements + * @param mandatory + * @return TRUE on success + */ +scpi_bool_t SCPI_ParamArrayDouble(scpi_t * context, double *data, size_t i_count, size_t *o_count, scpi_array_format_t format, scpi_bool_t mandatory) { + PARAM_ARRAY_TEMPLATE(SCPI_ParamDouble); } -- Gitblit v1.9.1