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

nancy.liao

1 天以前 11f2f2e329ef404d0e9c022cb2f9fbbb45bae285

 libscpi/src/parser.c

@@ -37,6 +37,7 @@

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

#include "scpi/config.h"
#include "scpi/parser.h"
@@ -45,7 +46,7 @@
#include "scpi/error.h"
#include "scpi/constants.h"
#include "scpi/utils.h"

#include "scpi/externinterface.h"
/**
 * Write data to SCPI output
 * @param context
@@ -55,7 +56,8 @@
 */
static size_t writeData(scpi_t * context, const char * data, size_t len) {
    if ((len > 0) && (data != NULL)) {
        return context->interface->write(context, data, len);
        return 0;
       // return context->interface->write(context, data, len);
    } else {
        return 0;
    }
@@ -123,23 +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] == '?';

    /* 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_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) {
@@ -158,6 +167,7 @@
    }

    /* 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;
@@ -171,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;
}

@@ -191,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;
@@ -202,20 +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;
@@ -224,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 errorenous 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);
                context->SCPIerror = RETURN_UnDefine;
                result = FALSE;
            }
        }
@@ -247,6 +275,7 @@
    }

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

    return result;
@@ -257,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
@@ -279,12 +310,15 @@
    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);
}

@@ -296,7 +330,9 @@
 * @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);
@@ -313,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;
@@ -339,9 +390,10 @@


        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);
@@ -448,6 +500,7 @@
 */
size_t SCPI_ResultInt32(scpi_t * context, int32_t val) {
    return resultUInt32BaseSign(context, val, 10, TRUE);

}

/**
@@ -614,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] = '#';
@@ -623,7 +677,9 @@
    block_header[1] = (char) (header_len + '0');

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

/**
@@ -1004,6 +1060,9 @@
    }
    return result;
}




/**
 * Read signed/unsigned 32 bit integer parameter
@@ -1432,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);
    }
@@ -1458,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) {