完成了SCPI命令语法分析器的完整规则

nancy.liao

1 天以前 11f2f2e329ef404d0e9c022cb2f9fbbb45bae285

 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.
 */

/**
@@ -36,6 +37,7 @@

#include <ctype.h>
#include <string.h>
#include "scpi/externinterface.h"

#include "scpi/config.h"
#include "scpi/parser.h"
@@ -44,17 +46,18 @@
#include "scpi/error.h"
#include "scpi/constants.h"
#include "scpi/utils.h"

#include "scpi/externinterface.h"
/**
 * Write data to SCPI output
 * @param context
 * @param data
 * @param len - lenght of data to be written
 * @param len - length of data to be written
 * @return number of bytes written
 */
static size_t writeData(scpi_t * context, const char * data, size_t len) {
    if (len > 0) {
        return context->interface->write(context, data, len);
    if ((len > 0) && (data != NULL)) {
        return 0;
       // return context->interface->write(context, data, len);
    } else {
        return 0;
    }
@@ -92,7 +95,7 @@
 * @return number of characters written
 */
static size_t writeNewLine(scpi_t * context) {
    if (context->output_count > 0) {
    if (!context->first_output) {
        size_t len;
#ifndef SCPI_LINE_ENDING
#error no termination character defined
@@ -122,20 +125,30 @@
 * Process command
 * @param context
 */

 //负命令回调的执行、参数处理和错误管理
static scpi_bool_t processCommand(scpi_t * context) {
    //这个地方修改为 读comdlist->pattern
    const scpi_command_t * cmd = context->param_list.cmd;
    //const scpi_command_t * cmd = context->cmdlist->pattern;
    lex_state_t * state = &context->param_list.lex_state;
    scpi_bool_t result = TRUE;
    // 先检测是否为查询命令(以?结尾)
    scpi_bool_t is_query = context->param_list.cmd_raw.data[context->param_list.cmd_raw.length - 1] == '?';

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

    /* conditionally write ; */
    //输出分隔符
    if(!context->first_output && is_query) {
        writeData(context, ";", 1);
    }
    //重置context上下文状态
    context->cmd_error = FALSE;
    context->output_count = 0;
    context->input_count = 0;
    context->arbitrary_reminding = 0;
    context->arbitrary_remaining = 0;

    /* if callback exists - call command callback */
    //命令回调执行  scpi_commands[]查找这里面的命令类型
    if (cmd->callback != NULL) {
        if ((cmd->callback(context) != SCPI_RES_OK)) {
            if (!context->cmd_error) {
@@ -145,11 +158,16 @@
        } else {
            if (context->cmd_error) {
                result = FALSE;
            } else {
                if(context->first_output && is_query) {
                    context->first_output = 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;
@@ -163,17 +181,18 @@
 * @param context
 * @result TRUE if context->paramlist is filled with correct values
 */
static scpi_bool_t findCommandHeader(scpi_t * context, const char * header, int len) {
    int32_t i;
    const scpi_command_t * cmd;
scpi_bool_t findCommandHeader(scpi_t * context, const char * header, int len)
{

    for (i = 0; context->cmdlist[i].pattern != NULL; i++) {
        cmd = &context->cmdlist[i];
        if (matchCommand(cmd->pattern, header, len, NULL, 0, 0)) {
            context->param_list.cmd = cmd;
    for(int i=0;i<get_pattern_count();i++)
    {
        if( match_segments_global(header,i) )
        {
            context->param_list.cmd = &context->cmdlist[i];
            return TRUE;
        }
    }
    context->SCPIerror = RETURN_NotFind;
    return FALSE;
}

@@ -183,6 +202,15 @@
 * @param data - complete command line
 * @param len - command line length
 * @return FALSE if there was some error during evaluation of commands
 */

 /*
    指令解析函数
    解析流程：
        1.先检查命令头是否合法，检查公共命令 或者复合命令 以及普通命令或者查询命令
        2.命令合法后组合复合命令 如*  ::  ? 三种类型
        3.通过完整的命令查找 是否有相对应的类型
        
 */
scpi_bool_t SCPI_Parse(scpi_t * context, char * data, int len) {
    scpi_bool_t result = TRUE;
@@ -194,19 +222,26 @@
        return FALSE;
    }

    //初始化context的解析器状态
    state = &context->parser_state;
    context->output_count = 0;
    context->first_output = TRUE;

    while (1) {
        
        //初步的检查命令是否合法
        r = scpiParser_detectProgramMessageUnit(state, data, len);

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

        } 
        else if (state->programHeader.len > 0) 
        {
            //命令有效开始处理
            composeCompoundCommand(&cmd_prev, &state->programHeader);

            //查找命令后并且设置解析状态并且执行命令
            if (findCommandHeader(context, state->programHeader.ptr, state->programHeader.len)) {

                context->param_list.lex_state.buffer = state->programData.ptr;
@@ -215,15 +250,17 @@
                context->param_list.cmd_raw.data = state->programHeader.ptr;
                context->param_list.cmd_raw.position = 0;
                context->param_list.cmd_raw.length = state->programHeader.len;

                //命令查找
                result &= processCommand(context);
                cmd_prev = state->programHeader;
            } else {
                //如果命令没有定义则抛出错误
                /* place undefined header with error */
                /* calculate length of errornouse header and trim \r\n */
                /* calculate length of errorenous header and trim \r\n */
                size_t r2 = r;
                while(r2 > 0 && (data[r2 - 1] == '\r' || data[r2 - 1] == '\n')) r2--;
                while (r2 > 0 && (data[r2 - 1] == '\r' || data[r2 - 1] == '\n')) r2--;
                SCPI_ErrorPushEx(context, SCPI_ERROR_UNDEFINED_HEADER, data, r2);
                context->SCPIerror = RETURN_UnDefine;
                result = FALSE;
            }
        }
@@ -237,7 +274,8 @@

    }

    /* conditionaly write new line */
    /* conditionally write new line */
    //解析完毕以后等待下一条指令的输入
    writeNewLine(context);

    return result;
@@ -248,7 +286,9 @@
 * @param context
 * @param commands
 * @param interface
 * @param units
 * @param unitsfind_package(Qt${QT_VERSION_MAJOR} COMPONENTS Widgets)
set(project_link_libraries Qt::Widgets)

 * @param idn1
 * @param idn2
 * @param idn3
@@ -270,23 +310,29 @@
    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, 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
 */
 */find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Widgets)
    set(project_link_libraries Qt::Widgets)

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);
@@ -303,25 +349,40 @@
 * @param len - length of data
 * @return
 */
scpi_bool_t SCPI_Input(scpi_t * context, const char * data, int len) {
    scpi_bool_t result = TRUE;

 /*
    输入处理函数，输入数据并且处理完整的SCPI命令
    context:上下文的context
    data：输入的数据
    len：输入数据的长度
 */
scpi_bool_t SCPI_Input(scpi_t * context, const char * data, int len)
{
    scpi_bool_t result = FALSE;
    size_t totcmdlen = 0;
    int cmdlen = 0;

    //当长度为0时  解析当前的数据 并且清空context的buff标记位
    if (len == 0) {
        context->buffer.data[context->buffer.position] = 0;
        //SCPI_Parse 解析完成后会返回状态
        result = SCPI_Parse(context, context->buffer.data, context->buffer.position);
        context->buffer.position = 0;
    } else {
        /*
        如果长度溢出则指令无效 
        正常情况下会将输入的指令传给context内
        */
        int buffer_free;

        buffer_free = context->buffer.length - context->buffer.position;
        
        if (len > (buffer_free - 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;
            context->SCPIerror = RETURN_LengthOverFlow;
            return result;
        }
        memcpy(&context->buffer.data[context->buffer.position], data, len);
        context->buffer.position += len;
@@ -329,16 +390,18 @@


        while (1) {
            //初步检查命令是否合法
            cmdlen = scpiParser_detectProgramMessageUnit(&context->parser_state, context->buffer.data + totcmdlen, context->buffer.position - totcmdlen);
            totcmdlen += cmdlen;

            //如果命令合法则将命令解析,同时删除context内的已经处理完成的命令
            if (context->parser_state.termination == SCPI_MESSAGE_TERMINATION_NL) {
                result = SCPI_Parse(context, context->buffer.data, totcmdlen);
                memmove(context->buffer.data, context->buffer.data + totcmdlen, context->buffer.position - totcmdlen);
                context->buffer.position -= totcmdlen;
                totcmdlen = 0;
            } else {
                if (context->parser_state.programHeader.type == SCPI_TOKEN_UNKNOWN) break;
                if (context->parser_state.programHeader.type == SCPI_TOKEN_UNKNOWN
                        && context->parser_state.termination == SCPI_MESSAGE_TERMINATION_NONE) break;
                if (totcmdlen >= context->buffer.position) break;
            }
        }
@@ -437,6 +500,7 @@
 */
size_t SCPI_ResultInt32(scpi_t * context, int32_t val) {
    return resultUInt32BaseSign(context, val, 10, TRUE);

}

/**
@@ -503,7 +567,7 @@
}

/**
 * Write string withn " to the result
 * Write string within "" to the result
 * @param context
 * @param data
 * @return
@@ -603,6 +667,7 @@
 * @return
 */
size_t SCPI_ResultArbitraryBlockHeader(scpi_t * context, size_t len) {
    size_t result = 0;
    char block_header[12];
    size_t header_len;
    block_header[0] = '#';
@@ -611,8 +676,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);
    context->arbitrary_remaining = len;
    result  = writeDelimiter(context);
    result += writeData(context, block_header, header_len + 2);
    return result;
}

/**
@@ -624,14 +691,14 @@
 */
size_t SCPI_ResultArbitraryBlockData(scpi_t * context, const void * data, size_t len) {

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

    context->arbitrary_reminding -= len;
    context->arbitrary_remaining -= len;

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

@@ -698,7 +765,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;
    }
@@ -994,6 +1061,9 @@
    return result;
}




/**
 * Read signed/unsigned 32 bit integer parameter
 * @param context
@@ -1133,7 +1203,7 @@
                break;
        }

        // TODO: return also parameter type (ProgramMnemonic, ArbitraryBlockProgramData, SingleQuoteProgramData, DoubleQuoteProgramData
        /* TODO: return also parameter type (ProgramMnemonic, ArbitraryBlockProgramData, SingleQuoteProgramData, DoubleQuoteProgramData */
    }

    return result;
@@ -1269,6 +1339,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
@@ -1280,12 +1359,6 @@
    scpi_bool_t result;
    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);
@@ -1299,7 +1372,7 @@
            SCPI_ParamToInt32(context, &param, &intval);
            *value = intval ? TRUE : FALSE;
        } else {
            result = SCPI_ParamToChoice(context, &param, bool_options, &intval);
            result = SCPI_ParamToChoice(context, &param, scpi_bool_def, &intval);
            if (result) {
                *value = intval ? TRUE : FALSE;
            }
@@ -1393,13 +1466,6 @@
    for (result = 1; result != 0; result = scpiLex_Comma(state, &tmp)) {
        token->len += result;

        if (result == 0) {
            token->type = SCPI_TOKEN_UNKNOWN;
            token->len = 0;
            paramCount = -1;
            break;
        }

        result = scpiParser_parseProgramData(state, &tmp);
        if (tmp.type != SCPI_TOKEN_UNKNOWN) {
            token->len += result;
@@ -1410,10 +1476,6 @@
            break;
        }
        paramCount++;
    }

    if (token->len == -1) {
        token->len = 0;
    }

    if (numberOfParameters != NULL) {
@@ -1429,25 +1491,36 @@
 * @param len
 * @return
 */
 //识别完整的SCPI命令
int scpiParser_detectProgramMessageUnit(scpi_parser_state_t * state, char * buffer, int len) {
    lex_state_t lex_state;
    scpi_token_t tmp;
    lex_state_t lex_state = {};
    scpi_token_t tmp = {};
    int result = 0;

    // 初始化词法分析
    lex_state.buffer = lex_state.pos = buffer;
    lex_state.len = len;
    // 重置参数计数器
    state->numberOfParameters = 0;

    /* ignore whitespace at the begginig */
    //预处理 跳过空白字符
    scpiLex_WhiteSpace(&lex_state, &tmp);

    if (scpiLex_ProgramHeader(&lex_state, &state->programHeader) >= 0) {
        if (scpiLex_WhiteSpace(&lex_state, &tmp) > 0) {
    //找到命令头后解析所有命令 
    if (scpiLex_ProgramHeader(&lex_state, &state->programHeader) >= 0) 
    {
        if (scpiLex_WhiteSpace(&lex_state, &tmp) > 0)
        {
            scpiParser_parseAllProgramData(&lex_state, &state->programData, &state->numberOfParameters);
        } else {
        }
        else
        {
            //无效命令标记
            invalidateToken(&state->programData, lex_state.pos);
        }
    } else {
    }
     else 
    {
        //处理解析失败的命令头
        invalidateToken(&state->programHeader, lex_state.buffer);
        invalidateToken(&state->programData, lex_state.buffer);
    }
@@ -1455,15 +1528,17 @@
    if (result == 0) result = scpiLex_NewLine(&lex_state, &tmp);
    if (result == 0) result = scpiLex_Semicolon(&lex_state, &tmp);

    //无效字符处理
    if (!scpiLex_IsEos(&lex_state) && (result == 0)) {
        // 跳过无效字符
        lex_state.pos++;

        //标记位命令头解析失败
        state->programHeader.len = 1;
        state->programHeader.type = SCPI_TOKEN_INVALID;

        invalidateToken(&state->programData, lex_state.buffer);
    }

    //设置终止符
    if (SCPI_TOKEN_SEMICOLON == tmp.type) {
        state->termination = SCPI_MESSAGE_TERMINATION_SEMICOLON;
    } else if (SCPI_TOKEN_NL == tmp.type) {
@@ -1545,7 +1620,7 @@
 * @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) {
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) {
@@ -1610,7 +1685,7 @@
            result += func(context, array[i]);\
        }\
    } else {\
        result = parserResultArrayBinary(context, array, count, sizeof(*array), format);\
        result = produceResultArrayBinary(context, array, count, sizeof(*array), format);\
    }\
    return result;\
} while(0)
@@ -1734,3 +1809,95 @@
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);
}