解决LALR歧义

Question

我最近把我的头围绕着LALR足以写一个LALR generator，我正在尝试为它构造一个java或c＃式语法（其开头是here }）。

我知道编写解析器生成器需要付出额外的努力，比如重新发明轮子（为什么不使用Antlr？），但我的目标是引导一个可以自行编译而不依赖于第三方工具链的业余爱好操作系统。我的问题不在于生成器，而在于语法。

我正在使用语句和表达式来减少/减少歧义。

我知道如何解决某些类型的歧义，比如悬挂其他东西，但是这些歧视对我来说并不直观，而且让我感到难过。

解决这些问题的最佳方法是什么？此外，是否有可用于帮助可视化解决方案的原型制作工具？或者，我应该回到原点并尝试为语法实现GLR解析器生成器吗？

这些陈述是合法的：

Generic.List<int> myVar1 = x + 4, myVar2; // stmt -> var-decl ;
                                          // var-decl -> type-name var-decl-list

t = 99;                           // simple-stmt -> assign

i++;                              // simple-stmt -> incr-decr
                                  // incr-decr -> primary-expr ++

json.deserialize<list<int>>(obj); // simple-stmt -> call
                                  // call -> primary-expr ( params )
                                  // ...  -> primary-expr . basic-name ( params )
                                  // ...  -> basic-name . basic-name ( params )

以下是它的设置方式：

basic-name : ident < type-list >
           | ident

nested-name : nested-name . basic-name
            | basic-name

basic-type : int | bool | ...

type-name : nested-name
          | basic-type

stmt : var-decl ;
     | simple-stmt ;
     | ...

var-decl : type-name var-decl-list

var-decl-list : var-decl-list , var-init
              | var-init

var-init : ident assign-op expression
         | ident

simple-stmt : assign
            | call
            | incr-decr

expr : assign-expr

assign-expr : assign
            | cond-expr

assign : unary-expr assign-op expr

...
rel-expr : rel-expr < shift-expr
         ...
         | shift-expr

...
unary-expr : unary-op primary-expr
           | primary-expr

unary-op : + - ! ~ ++ --  // Prefix operators
         | ( type-name )  // Conversion operator

primary-expr : call
             | primary-expr . basic-name
             | primary-expr ++
             | ( expr )
             ...
             | basic-name

call : primary-expr ( params )

incr-decr : primary-expr ++
          | -- primary-expr
          | ...

因此，当解析器期望一个语句时，* LR（k）项集内核为method-body -> { * stmts-opt }，并且为该状态设置的完整项看起来像这样：

method-body -> { * stmts-opt }
stmts-opt -> * stmts
stmts-opt -> *
stmts -> * stmts stmt
stmt -> * var-decl ;
stmt -> * simple-stmt ;
var-decl -> * type-name var-decl-list
simple-stmt -> * assign
simple-stmt -> * call
simple-stmt -> * incr-decr
type-name -> * nested-name
type-name -> * basic-type
nested-name -> * nested-name . basic-name
nested-name -> * basic-name
basic-name -> * ident < type-list >
basic-name -> * ident
assign -> * unary-expr assign-op expr
unary-expr -> * unary-op primary-expr
unary-expr -> * primary-expr
unary-op -> * ( typename )
unary-op -> * ! | ~ | ...
primary-expr -> * call
primary-expr -> * primary-expr . basic-name
primary-expr -> * primary-expr ++
primary-expr -> * basic-name
primary-expr -> * ( expr )
call -> * primary-expr ( params )
incr-decr -> * primary-expr ++
...

当移动标识符时，下一个状态是：

basic-name -> ident *
basic-name -> ident * < type-list >

被解析或减少，并将下一个状态带到：

nested-name -> basic-name *
primary-expr -> basic-name *

潜在的冲突。在父状态中，前瞻不起作用，因为nested-name和primary-expr中有一个点。哦，好的，让我们尝试通过嵌套名称减少：

type-name -> nested-name *
nested-name -> nested-name * . basic-name

这里没什么可看的...... 现在，如何减少primary-expr：

unary-expr -> primary-expr *
primary-expr -> primary-expr * . basic-name
primary-expr -> primary-expr * ++
call -> primary-expr * ( params )
incr-decr -> primary-expr * ++
...

现在，当我们转换++时，我们得到：

primary-expr -> primary-expr ++ *
incr-decr -> primary-expr ++ *

......另一种减少 - 减少冲突。

让我们尝试转移(而不是ident：

primary-expr -> ( * expr )
unary-op -> ( * type-name )
expr -> * assign-expr
assign-expr -> * assign
assign-expr -> * cond-expr
assign -> * unary-expr assign-op expr
unary-expr -> * unary-op primary-expr
unary-expr -> * primary-expr
unary-op -> * ( typename )
unary-op -> * ! | ~ | ...
primary-expr -> * call
primary-expr -> * primary-expr . basic-name
primary-expr -> * primary-expr ++
primary-expr -> * basic-name
primary-expr -> * ( expr )
call -> * primary-expr ( params )
cond-expr -> * ...
...
rel-expr -> * rel-expr < shift-expr
rel-expr -> * shift-expr
...
type-name -> * nested-name
type-name -> * basic-type
nested-name -> * nested-name . basic-name
nested-name -> * basic-name
basic-name -> * ident < type-list >
basic-name -> * ident

将ident或(转移到堆栈时会出现同样的问题。

这些只是我到目前为止遇到的问题。由于basic-name优先于rel-expr，因此我假设x < n之类的内容会被解释为basic-name -> ident < type-list *，如果它实际上是关系表达式则会出错。

我的大脑已经达到了我可以真正使用帮助的程度。

Answer 1

您的帖子中有一些问题，这使得它不太适合SO。但我会尝试提供一些关于每个人的想法。在我看来，你有三个问题：

1. 区分表达式语句与非语句的表达式。

2. 在声明中解析分层命名的类型，而不与表达式语句中的字段访问表达式冲突

3. 区分使用＆lt; 作为比较运算符和模板括号。

1。区分表达式语句与非语句的表达式。

据我所知，希望仅允许具有（或可能具有）某种副作用的语句表达式：赋值，增量突变和子例程调用。粗略地说，这对应于Java，其语法包括：

StatementExpression:
  Assignment
  PreIncrementExpression
  PreDecrementExpression
  PostIncrementExpression
  PostDecrementExpression
  MethodInvocation
  ClassInstanceCreationExpression

为StatementExpression 列出的每个替代方案都出现在Expression的派生树中的某个位置，其中它们已被排除在可能性列表之外。这是一个非常简洁的样本：

Expression:
  LambdaExpression
  AssignmentExpression

AssignmentExpression:
  ConditionalExpression
  Assignment

Assignment:
  LeftHandSide AssignmentOperator Expression

...

UnaryExpression:
  PreIncrementExpression
  + UnaryExpression
  UnaryExpressionNotPlusMinus

PreIncrementExpression:
  ++ UnaryExpression

UnaryExpressionNotPlusMinus:
  PostfixExpression
  ~ UnaryExpression

PostfixExpression:
  Primary
  ExpressionName
  PostIncrementExpression

PostIncrementExpress:
  PostfixExpression ++

请注意ExpressionStatement右侧使用的非终端在每个优先级别是如何特殊的。在C ++语法中，不限制哪些表达式可以是语句，不需要单独的Assignment非终端：

assignment-expression:
  conditional-expression
  logical-or-expression assignment-operator initializer-clause

但在Java中，这是行不通的。它需要创建一个不会派生ConditionalExpression的额外非终端，正是为了让Assignment成为Statement而AssignmentExpression成为Expression }。

2。在声明中解析分层命名的类型，而不与表达式语句中的字段访问表达式冲突

与上面类似，这里有必要从其他形式的字段访问表达式中放置层次结构名称（必须以basic-name开头），这些表达式可能以任何（其他）primary-expr开头。前者可以是类型名称或主要表达式;后者只能是类型名称。为了做出这种区分，我们需要拆分primary-expr生产：

primary-expr : field-access-expr
             | nested-name

non-field-access-expr:
               call
             | post-increment-expression  // was primary-expr ++
             | ( expr )
             ...

field-access-expr :
               non-field-access-expr
             | field-access-expr . basic-name

3。区分使用＆lt; 作为比较运算符和模板括号。

与其他两个问题不同，这个问题实际上可能是语言中的含糊不清。例如，在C ++中，模板括号肯定是模棱两可的;它们只能通过知道（或被告知）特定名称是否是模板名称来解决。另一方面，在Java中，有时需要类型参数在通用名称之前解决歧义。例如：

ConstructorDeclarator:
  [TypeParameters] SimpleTypeName ( [FormalParameterList] )

或

MethodInvocation:
  Primary . [TypeArguments] Identifier ( [ArgumentList] )

在C＃中，还有一个不同的规则，需要查看＆gt; 后面的字符，该字符可能与开头＆lt; 匹配。该算法在C＃手册的第7.6.4.2节中描述;我不知道你将如何在LALR（1）解析器中实现它。