修改

nancy.liao

2025-04-18 a3fdd3589c713678eafe20840a7334de6bed038b

 libscpi/src/parser.c

@@ -50,11 +50,11 @@
 * 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) {
    if ((len > 0) && (data != NULL)) {
        return context->interface->write(context, data, len);
    } else {
        return 0;
@@ -93,7 +93,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
@@ -123,20 +123,28 @@
 * Process command
 * @param 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;
    // 先检测是否为查询命令(以?结尾)
    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) {
@@ -146,11 +154,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;
@@ -185,6 +198,15 @@
 * @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;
    scpi_parser_state_t * state;
@@ -195,19 +217,25 @@
        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);
            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;
@@ -216,12 +244,13 @@
                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--;
                SCPI_ErrorPushEx(context, SCPI_ERROR_UNDEFINED_HEADER, data, r2);
@@ -238,7 +267,8 @@

    }

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

    return result;
@@ -249,7 +279,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
@@ -271,6 +303,7 @@
    context->interface = interface;
    context->units = units;
    context->idn[0] = idn1;

    context->idn[1] = idn2;
    context->idn[2] = idn3;
    context->idn[3] = idn4;
@@ -288,7 +321,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);
@@ -305,19 +340,33 @@
 * @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;
@@ -331,9 +380,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);
@@ -440,6 +490,7 @@
 */
size_t SCPI_ResultInt32(scpi_t * context, int32_t val) {
    return resultUInt32BaseSign(context, val, 10, TRUE);

}

/**
@@ -506,7 +557,7 @@
}

/**
 * Write string withn " to the result
 * Write string within "" to the result
 * @param context
 * @param data
 * @return
@@ -606,6 +657,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] = '#';
@@ -614,8 +666,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;
}

/**
@@ -627,14 +681,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++;
    }

@@ -1424,25 +1478,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;
    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);
    }
@@ -1450,15 +1515,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) {