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

Question

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

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

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

stdout/stderr:

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):
    = token INT_TERM ()
    = 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

Lex 文件：

%{
#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 
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", , ); }

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

%%

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 文件...）

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

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

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

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

这是一个简单的示例，它允许您设置 yylex 一个以 NULL 结尾的类似 argv 的字符串数组，然后将它们全部作为单个输入进行词法分析。（如果您选择使用 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);
}

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

When using multiple buffers with Flex, how do I avoid having tokens get split between buffers

c

bison

flex-lexer