Question

更新了更多信息

我在使用Lemon解析一个简单的元素数组时遇到了问题。有人可以开导我吗？

我正在尝试使用mygrammar定义解析此字符串“[0 0 612 792] [100 200]”，解析器总是跳过第一个数组元素并复制最后一个......任何想法？

语法文件是

%token_type { char* }

%include {
    #include <assert.h>
}

%parse_accept { printf("The parser has completed successfully.\n"); }
%syntax_error { fprintf(stderr, "Syntax Error\n"); }
%parse_failure { fprintf(stderr, "Parse failure\n"); }

%start_symbol program

array_value ::= INT_LITERAL(A). {printf("Av: %s\n", A);} 

array_value_list ::=.
array_value_list ::= array_value_list array_value.

array_declaration ::= LBRACKET array_value_list RBRACKET.

array_list ::= array_declaration.
array_list ::= array_list array_declaration.

program ::= array_list END_TOKEN.

我使用re2c来获取令牌，并且为每个令牌调用解析器的代码是

  while(token = scan(&scanner, buff_end)) { 
    // Send strings to the parser with NAME tokens  

    if(token == INT_LITERAL) {
      name_length = scanner.cur - scanner.top;
      strncpy(name_str, scanner.top, name_length);
      name_str[name_length] = '\0';
      //printf("Token:Pre: %s\tName: %s\n", tokenStr(token),name_str);
      Parse(parser, token, name_str);
    }
    else {
      //printf("Token: %s\n", tokenStr(token));
      Parse(parser, token, 0);
    }
    // Execute Parse for the last time
    if(token == END_TOKEN) {
      Parse(parser, 0, NULL);
      break;
    }
  }

对于输入字符串“[0 -100 612 792] [100 200]”，输出为：

Av: -100
Av: 612
Av: 792
Av: 792
Av: 200
Av: 200

您可以注意到，第一个元素没有出现，最后一个元素是重复的。

柠檬的语法是：

State 0:
          array_declaration ::= * LBRACKET array_value_list RBRACKET
          array_list ::= * array_declaration
          array_list ::= * array_list array_declaration
          program ::= * array_list END_TOKEN

                      LBRACKET shift        3      
             array_declaration shift        1        /* because array_declaration==array_list */
                    array_list shift        1      
                       program accept

State 1:
          array_declaration ::= * LBRACKET array_value_list RBRACKET
          array_list ::= array_list * array_declaration
          program ::= array_list * END_TOKEN

                      LBRACKET shift        3      
                     END_TOKEN shift        4      
             array_declaration shift-reduce 5      array_list ::= array_list array_declaration

State 2:
          array_value ::= * INT_LITERAL
          array_value_list ::= array_value_list * array_value
          array_declaration ::= LBRACKET array_value_list * RBRACKET

                   INT_LITERAL shift-reduce 0      array_value ::= INT_LITERAL
                      RBRACKET shift-reduce 3      array_declaration ::= LBRACKET array_value_list RBRACKET
                   array_value shift-reduce 2      array_value_list ::= array_value_list array_value

State 3:
      (1) array_value_list ::= *
          array_value_list ::= * array_value_list array_value
          array_declaration ::= LBRACKET * array_value_list RBRACKET

              array_value_list shift        2      
                     {default} reduce       1      array_value_list ::=

State 4:
      (6) program ::= array_list END_TOKEN *

                             $ reduce       6      program ::= array_list END_TOKEN

----------------------------------------------------
Symbols:
    0: $:
    1: INT_LITERAL
    2: LBRACKET
    3: RBRACKET
    4: END_TOKEN
    5: error:
    6: array_value: INT_LITERAL
    7: array_value_list: <lambda> INT_LITERAL
    8: array_declaration: LBRACKET
    9: array_list: LBRACKET
   10: program: LBRACKET

示例字符串的输出跟踪是：

T__Input 'LBRACKET'
T__Shift 'LBRACKET', go to state 3
T__Return. Stack=[LBRACKET]
T__Input 'INT_LITERAL'
T__Reduce [array_value_list ::=], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'INT_LITERAL'
T__Return. Stack=[LBRACKET array_value_list INT_LITERAL]
T__Input 'INT_LITERAL'
T__Reduce [array_value ::= INT_LITERAL], go to state 2.
T__Shift 'array_value'
T__Reduce [array_value_list ::= array_value_list array_value], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'INT_LITERAL'
T__Return. Stack=[LBRACKET array_value_list INT_LITERAL]
T__Input 'INT_LITERAL'
T__Reduce [array_value ::= INT_LITERAL], go to state 2.
T__Shift 'array_value'
T__Reduce [array_value_list ::= array_value_list array_value], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'INT_LITERAL'
T__Return. Stack=[LBRACKET array_value_list INT_LITERAL]
T__Input 'INT_LITERAL'
T__Reduce [array_value ::= INT_LITERAL], go to state 2.
T__Shift 'array_value'
T__Reduce [array_value_list ::= array_value_list array_value], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'INT_LITERAL'
T__Return. Stack=[LBRACKET array_value_list INT_LITERAL]
T__Input 'RBRACKET'
T__Reduce [array_value ::= INT_LITERAL], go to state 2.
T__Shift 'array_value'
T__Reduce [array_value_list ::= array_value_list array_value], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'RBRACKET'
T__Return. Stack=[LBRACKET array_value_list RBRACKET]
T__Input 'LBRACKET'
T__Reduce [array_declaration ::= LBRACKET array_value_list RBRACKET], go to state 0.
T__Shift 'array_declaration', go to state 1
T__Shift 'LBRACKET', go to state 3
T__Return. Stack=[array_declaration LBRACKET]
T__Input 'INT_LITERAL'
T__Reduce [array_value_list ::=], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'INT_LITERAL'
T__Return. Stack=[array_declaration LBRACKET array_value_list INT_LITERAL]
T__Input 'INT_LITERAL'
T__Reduce [array_value ::= INT_LITERAL], go to state 2.
T__Shift 'array_value'
T__Reduce [array_value_list ::= array_value_list array_value], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'INT_LITERAL'
T__Return. Stack=[array_declaration LBRACKET array_value_list INT_LITERAL]
T__Input 'RBRACKET'
T__Reduce [array_value ::= INT_LITERAL], go to state 2.
T__Shift 'array_value'
T__Reduce [array_value_list ::= array_value_list array_value], go to state 3.
T__Shift 'array_value_list', go to state 2
T__Shift 'RBRACKET'
T__Return. Stack=[array_declaration LBRACKET array_value_list RBRACKET]
T__Input 'END_TOKEN'
T__Reduce [array_declaration ::= LBRACKET array_value_list RBRACKET], go to state 1.
T__Shift 'array_declaration'
T__Reduce [array_list ::= array_list array_declaration], go to state 0.
T__Shift 'array_list', go to state 1
T__Shift 'END_TOKEN', go to state 4
T__Return. Stack=[array_list END_TOKEN]
T__Input '$'
T__Reduce [program ::= array_list END_TOKEN], go to state 0.
T__Accept!
T__Return. Stack=]

我坚持这个错误，我很确定这是一个我不明白的概念错误。任何帮助表示赞赏。

由于

Answer 1

您没有在扫描仪代码中显示name_str的定义，但似乎它是char的数组。如果是这种情况，那么您将面临缓冲区溢出的风险，因为您从未检查以确保name_length小于缓冲区大小;此外，您也可以使用memcpy而不是strncpy，因为您已经知道复制字符串中没有NUL字符。但这些问题实际上都不是问题所在：问题是你将每个令牌复制到同一个缓冲区中。

您传递给解析器的是NUL终止字符串的地址。解析器不复制字符串;它只是将地址存储为令牌的语义值。换句话说，解析器假定它拥有传入的令牌字符串，至少在解析完成之前。

但实际上字符缓冲区（name_str）由扫描程序拥有，一旦它将令牌推入解析器，它就会假定它可以自由地使用字符缓冲区。这是用下一个标记覆盖缓冲区。

与野牛不同，当前瞻无关紧要时，柠檬不会立即减少。一看到野牛就会将INT_LITERAL减少到array_value，因为减少不依赖于前瞻。但是柠檬总是有一个先行令牌，因此它不会将INT_LITERAL减少到array_value，直到它收到下一个令牌。不幸的是，如果下一个标记也是INT_LITERAL，则下一个标记将在缩减发生之前覆盖字符缓冲区，因此简化操作将打印出 next 标记中的字符串。如果下一个标记是] ，则扫描程序不会覆盖字符缓冲区，因此在这种情况下将打印当前标记，尽管它已经由前一个标记的缩小打印。 / p>

通常，扫描程序无法知道解析器需要多长时间才能使用令牌值。对于该问题环境，只有两个明智的所有权政策：

扫描仪保留所有权。如果需要保留值，解析器必须复制。
扫描程序将所有权传递给解析器，解析器必须在完成后立即释放令牌。

第一个策略更清晰，因为它不需要两个组件就资源管理协议达成一致。但是解析器生成器不太可能包含任何允许实现该策略的机制，因为它需要在解析器函数的顶部采取一些操作。

所以你需要使用第二个政策;扫描程序必须在新分配的内存中复制令牌字符串，并将此内存及其所有权传递给解析器，以便解析器必须（最终）释放该副本。这是由大多数功能强大的野牛解析器使用的相同协议，出于同样的原因，并且在没有进行复制时发生的各种错误可能是最常见的模糊的野牛错误。

当然，在这种简单的情况下，您可以通过让扫描程序将字符串转换为整数来避免内存管理问题。

Answer 2

您可以从您提供的解析器定义中生成Lemon解析器。它允许递归列表array_value的终端元素array_value_list为空。解析器可以减少此规则的不定次数并报告解析冲突。

是为了解决冲突，切换到空列表规则的概念而不是空元素。以下是lemon文档中列表的推荐左递归定义：

list ::= .
list ::= list element.

将此模式应用于您的解析器会得到下一个结果：

array_value ::= INT_LITERAL(A). {printf("Array value: %s\n", A);}
array_value_list ::= .
array_value_list ::= array_value_list array_value.
init_array ::=. {printf("Init Array\n");}
end_array ::=. {printf("End Array\n");}
array_declaration ::= init_array LBRACKET array_value_list RBRACKET end_array.
array_list ::= array_declaration.
array_list ::= array_list array_declaration.
program ::= array_list END_TOKEN.

Lemon Parser跳过的东西（或者我的误解）

更新了更多信息

2 个答案: