c - 在 Flex 中使用多个缓冲区时，如何避免标记在缓冲区之间拆分

Question

假设我有一个由逗号分隔的正整数和字母字符串的简单语法。我想使用 Flex 和 Bison 解析这个语法，并且我想使用 Flex 的多个输入缓冲区，无论出于何种原因(可能是数据通过网络或串行线路或其他原因到达)。我看到的问题是，当一个字符串或一个整数(它们都是可变长度标记)在一个缓冲区的末尾和下一个缓冲区的开头之间拆分时，词法分析器报告两个标记，而实际上应该只有一个。

在下面的示例中， block 是 10, asdf 和 g,。如果这一切都在一个缓冲区中，它将产生标记 INT(10) COMMA STR(asdfg) COMMA .但是由于 'g' 位于与 'asdf' 不同的缓冲区中，词法分析器实际上生成 INT(10) COMMA STR(asdf) STR(g) 逗号。看起来到达缓冲区末尾的逻辑是(1)检查输入是否与 token 匹配，(2)重新填充缓冲区。我觉得应该反过来:(2)重新填充缓冲区，(1)检查输入是否与 token 匹配。

我想确保我改变缓冲区的方式没有做一些愚蠢的事情。

标准输出/标准错误:

read_more_input: Setting up buffer containing: 10,
--accepting rule at line 48 ("10")
Starting parse
Entering state 0
Reading a token: Next token is token INT_TERM ()
Shifting token INT_TERM ()
Entering state 1
Return for a new token:
--accepting rule at line 50 (",")
Reading a token: Next token is token COMMA ()
Shifting token COMMA ()
Entering state 4
Reducing stack by rule 2 (line 67):
   $1 = token INT_TERM ()
   $2 = token COMMA ()
-> $$ = nterm int_non_term ()
Stack now 0
Entering state 3
Return for a new token:
--(end of buffer or a NUL)
--EOF (start condition 0)
read_more_input: Setting up buffer containing: asdf
--(end of buffer or a NUL)
--accepting rule at line 49 ("asdf")
Reading a token: Next token is token STR_TERM ()
Shifting token STR_TERM ()
Entering state 6
Return for a new token:
--(end of buffer or a NUL)
--EOF (start condition 0)
read_more_input: Setting up buffer containing: g,
--accepting rule at line 49 ("g")
Reading a token: Next token is token STR_TERM ()
syntax errorError: popping token STR_TERM ()
Stack now 0 3
Error: popping nterm int_non_term ()
Stack now 0
Cleanup: discarding lookahead token STR_TERM ()
Stack now 0

莱克斯文件:

%{
#include <stdbool.h>
#include "yacc.h"
bool read_more_input(yyscan_t scanner);
%}

%option reentrant bison-bridge

%%

[0-9]+     { yylval->int_value = atoi(yytext); return INT_TERM; }
[a-zA-Z]+  { yylval->str_value = strdup(yytext); return STR_TERM; }
,          { return COMMA;    }
<<EOF>>    {
             if (!read_more_input(yyscanner)) {
                yyterminate();
             }
           }

Yacc 文件:

%{
// This appears to be a bug. This typedef breaks a dependency cycle between the headers.
// See https://stackoverflow.com/questions/44103798/cyclic-dependency-in-reentrant-flex-bison-headers-with-union-yystype
typedef void * yyscan_t;  

#include <stdbool.h>
#include "yacc.h"
#include "lex.h"
%}

%define api.pure full
%lex-param {yyscan_t scanner}
%parse-param {yyscan_t scanner}
%define api.push-pull push

%union {
  int int_value;
  char * str_value; 
}

%token <int_value> INT_TERM
%type  <int_value> int_non_term
%token <str_value> STR_TERM
%type  <str_value> str_non_term
%token COMMA

%%

complete : int_non_term str_non_term { printf(" === %d === %s === \n", $1, $2); }

int_non_term : INT_TERM COMMA { $$ = $1; }
str_non_term : STR_TERM COMMA { $$ = $1; }

%%

char * packets[]= {"10,", "asdf", "g,"};
int current_packet = 0;

bool read_more_input(yyscan_t scanner) {
  if (current_packet >= 3) {
    fprintf(stderr, "read_more_input: No more input\n");
    return false;
  }

  fprintf(stderr, "read_more_input: Setting up buffer containing: %s\n", packets[current_packet]);
  size_t buffer_size = strlen(packets[current_packet]) + 2;
  char * buffer = (char *) calloc(buffer_size, sizeof(char));
  memcpy(buffer, packets[current_packet], buffer_size - 2);

  yy_scan_buffer(buffer, buffer_size, scanner);
  current_packet++;
  return true; 
}

int main(int argc, char** argv) {

  yyscan_t scanner;
  yylex_init(&scanner) ;

  read_more_input(scanner);

  yyset_debug(1, scanner); 
  yydebug = 1;

  int status;
  yypstate *ps = yypstate_new ();

  YYSTYPE pushed_value;

  do {
    status = yypush_parse(ps, yylex(&pushed_value, scanner), &pushed_value, scanner);
  } while(status == YYPUSH_MORE);

  yypstate_delete (ps);
  yylex_destroy (scanner) ;
  return 0;
}

Answer 1

这不是多个缓冲区的预期用例。多个输入缓冲区通常用于处理诸如 #include 甚至宏扩展之类的事情，其中​​包含的文本绝对应该遵守标记边界。 (考虑一个包含未终止注释的#included 文件...)

如果您希望以允许 token 跨缓冲区边界流动的方式将来自不同来源的输入粘贴在一起，请重新定义 YY_INPUT 宏以满足您的需求。

YY_INPUT 是自定义输入的宏钩子(Hook)；它被赋予一个缓冲区和一个最大长度，它必须将指定数量的字节(或更少)复制到缓冲区中，并且还指示提供了多少字节(0 字节被视为输入结束，此时 yywrap 将被调用。)

YY_INPUT 在 yylex 中展开，因此它可以访问 yylex 参数，其中包括词法分析器状态。可重入词法分析器中的 yywrap 以扫描器状态作为参数调用。因此，如果需要，您可以同时使用这两种机制。

不幸的是，这不允许“零拷贝”缓冲区切换。但是 flex 通常没有针对内存输入缓冲区进行优化:您可以使用 yyscan_buffer 为 flex 提供缓冲区，但缓冲区必须以两个 NUL 字节终止，并且它将在扫描期间被修改，所以该功能很少有用。

这是一个简单的示例，它允许您使用一个以 NULL 结尾的类似 argv 的字符串数组来设置 yylex，然后将它们全部作为单个输入进行词法分析。 (如果您选择使用 argv+1 来初始化这个数组，您会注意到它从连续的参数中一起运行标记。)

%{
#include <string.h>
#include <parser.tab.h>
#define YY_EXTRA_TYPE char**
/* FIXME:
 * This assumes that none of the string segments are empty
 * strings (or for the feature-not-a-bug interpretation, 
 * it allows the list to be terminated by NULL or an empty string).
 */
#define YY_INPUT(buf,result,max_size) { \
  char* segment = *yyextra; \
  if (segment == NULL) result = 0; \
  else { \
    size_t avail = strnlen(segment, max_size); \
    memcpy(buf, segment, avail); \
    if (segment[avail]) *yyextra += avail; \
    else ++yyextra; \
    result = avail; \
  } \
}

%}

%option reentrant bison-bridge
%option noinput nounput nodefault noyywrap

%%

[[:space:]]+              ;
[0-9]+                    { yylval->number = strtol(yytext, 0, 10); return NUMBER; }
[[:alpha:]_][[:alnum:]_]* { yylval->string = strdup(yytext); return ID; }
.                         { return *yytext; }

%%

/* This function must be exported in some header */
void yylex_strings(char** argv, yyscan_t scanner) {
  yyset_extra(argv, scanner);
}