是否可以使用Menhir创建非常宽松的语法？

Question

我正在尝试解析Verilog的一些点点滴滴-我主要对提取模块定义和实例化感兴趣。

在verilog中，模块的定义如下：

module foo ( ... ) endmodule;

并以两种可能的方式之一实例化一个模块：

foo fooinst ( ... );
foo #( ...list of params... ) fooinst ( .... );

至此，我只想查找已定义或实例化模块的名称； 在以上两种情况下均为“ foo”。

鉴于此竖线语法（verParser.mly）：

%{ 

  type expr =   Module of expr 
           | ModInst of expr
           | Ident of string 
           | Int of int
           | Lparen 
           | Rparen  
           | Junk 
           | ExprList of expr list

%}

%token <string> INT
%token <string> IDENT
%token  LPAREN RPAREN MODULE TICK OTHER HASH EOF



%start expr2
%type <expr> mod_expr
%type <expr> expr1
%type <expr list> expr2

%%


mod_expr:
  | MODULE IDENT LPAREN    { Module ( Ident $2) }
  | IDENT IDENT LPAREN     { ModInst ( Ident $1) }
  | IDENT HASH  LPAREN     { ModInst ( Ident $1) };

junk: 
  |  LPAREN {  }
  |  RPAREN {  }
  |  HASH { } 
  |  INT {  };

expr1:
  | junk* mod_expr junk* { $2 } ;

expr2: 
  | expr1* EOF { $1 };

当我在menhir解释器中进行尝试时，提取模块实例可以正常工作：

MODULE IDENT LPAREN
ACCEPT
[expr2:
  [list(expr1):
    [expr1:
      [list(junk):]
      [mod_expr: MODULE IDENT LPAREN]
      [list(junk):]
    ]
    [list(expr1):]
  ]
  EOF
]

它对于单个模块实例运行良好：

IDENT IDENT LPAREN
ACCEPT
[expr2:
  [list(expr1):
    [expr1:
      [list(junk):]
      [mod_expr: IDENT IDENT LPAREN]
      [list(junk):]
    ]
    [list(expr1):]
  ]
  EOF
]

但是，当然，如果在任何这些ID之前出现一个IDENT，它将被拒绝：

IDENT MODULE IDENT LPAREN IDENT IDENT LPAREN
REJECT

...，当然，在这些定义之前，实际的Verilog文件中会有标识符。

我试图不必完全指定Verilog语法，而是要逐步逐步构建语法，以最终解析越来越多的语言。

如果我将IDENT添加到垃圾规则中，则可以解决上述问题，但是模块实例化规则不起作用，因为现在垃圾规则正在捕获IDENT。

是否可以创建一个非常宽松的规则来绕过我不想匹配的内容，或者通常是否需要创建一个完整的语法才能实际执行此类操作？

是否可以创建一个让我匹配的规则：

MODULE IDENT LPAREN stuff* RPAREN ENDMODULE

“ stuff *”最初与RPAREN之外的所有内容都匹配？

就像是 ：

stuff: 
  | !RPAREN { } ;

我过去使用过PEG解析器，它将允许类似的构造。

Answer 1

我认为PEG更适合宽松，非穷尽的语法。 看了一下钉子/腿 ，就可以很快地完成我需要做的腿语法：

start   = ( comment | mod_match | char)

line    = < (( '\n' '\r'* ) | ( '\r' '\n'* )) > { lines++;  chars += yyleng; }
module_decl =    module  modnm:ident lparen ( !rparen . )* rparen   {  chars += yyleng; printf("Module    decl: <%s>\n",yytext);}
module_inst = modinstname:ident ident lparen { chars += yyleng; printf("Module Inst: <%s>\n",yytext);}
         |modinstname:ident hash lparen { chars += yyleng; printf("Module Inst: <%s>\n",yytext);} 

mod_match = ( module_decl | module_inst ) 
module     =  'module' ws                { modules++;    chars +=yyleng; printf("Module: <%s>\n", yytext);  } 
endmodule  = 'endmodule' ws              { endmodules++; chars +=yyleng; printf("EndModule: <%s>\n", yytext); } 

kwd = (module|endmodule)
ident   = !kwd<[a-zA-z][a-zA-Z0-9_]+>-    { words++;  chars += yyleng;  printf("Ident: <%s>\n", yytext);  }

char    = .                 { chars++; }
lparen  =  '(' - 
rparen  =  ')' - 
hash    =  '#' 

- =  ( space | comment )*
ws = space+
space = ' ' | '\t' | EOL
comment = '//' ( !EOL .)* EOL
          | '/*' ( !'*/' .)* '*/' 
EOF = !.
EOL = '\r\n' | '\n' | '\r' 

Aurochs也可能是一个选项，但是我对Aurochs生成的解析器的速度和内存使用情况感到担心。 peg / leg在C中产生一个解析器，应该很快。