Question

我一直在使用正则表达式来浏览一堆Verilog文件并提取某些语句。目前，正则表达式对此很好，但是，我开始到达需要真正的解析器来处理嵌套结构的点，所以我正在调查ocamllex / ocamlyacc。我想首先复制我在正则表达式实现中的内容，然后慢慢地在语法中添加更多内容。

现在我主要对提取模块声明和实例化感兴趣。为了使这个问题更加简洁，让我们来看一下模块声明。

在Verilog中，模块声明如下：

module modmame ( ...other statements ) endmodule;

我当前的正则表达式实现只是检查是否有一个使用特定名称声明的模块（检查我感兴趣的名称列表 - 我不需要找到所有模块声明只是具有某些名称的模块）。所以基本上，我得到我要解析的Verilog文件的每一行并做这样的匹配（伪OCaml与Pythonish和Rubyish元素）：

foreach file in list_of_files:
  let found_mods = Hashtbl.create 17;
  open file 
  foreach line in file:
    foreach modname in modlist
    let mod_patt=  Str.regexp ("module"^space^"+"^modname^"\\("^space^"+\\|(\\)") in 
    try
      Str.search_forward (mod_patt) line 0
      found_mods[file] = modname; (* map filename to modname *)
    with Not_found -> ()

这很有效。模块声明可以出现在Verilog文件中的任何位置;我只是想知道文件是否包含该特定声明，我不关心该文件中还有什么。

我首次尝试将此转换为ocamllex / ocamlyacc：

verLexer.mll：

rule lex = parse
  | [' ' '\n' '\t']               { lex lexbuf }
  | ['0'-'9']+ as s               { INT(int_of_string s) }
  | '('                           { LPAREN }
  | ')'                           { RPAREN }
  | "module"                      { MODULE }
  | ['A'-'Z''a'-'z''0'-'9''_']+ as s  { IDENT(s) }
  | _                             { lex lexbuf }
  | eof

verParser.mly：

%{ type expr =  Module of expr | Ident of string | Int of int %}

%token <int> INT
%token <string> IDENT
%token  LPAREN RPAREN MODULE EOF

%start expr1
%type <expr> expr1

%%

expr:   
| MODULE IDENT LPAREN    { Module( Ident $2) };

expr1:   
| expr EOF { $1 };

然后在REPL中尝试：

# #use "verLexer.ml" ;; 
# #use "verParser.ml" ;; 
# expr1 lex (Lexing.from_string "module foo (" ) ;;
- : expr = Module (Ident "foo")

那很好，它有效！

但是，真正的Verilog文件中不仅包含模块声明：

# expr1 lex (Lexing.from_string "//comment\nmodule foo ( \nstuff" ) ;;
Exception: Failure "lexing: empty token".

我真的不关心在该模块定义之前或之后出现的内容，有没有办法只提取语法的那一部分来确定Verilog文件包含'module foo（'声明？是的，我意识到然而，如上所述，正则表达式工作正常，我计划慢慢增加这个语法并添加更多元素，正则表达式将开始崩溃。

编辑：我在lex规则中添加了匹配任何字符：

      | _                             { lex lexbuf }

认为它会跳过目前尚未匹配的任何字符，但这似乎不起作用：

 # expr1 lex (Lexing.from_string "fof\n module foo (\n" ) ;;
 Exception: Parsing.Parse_error.

Answer 1

第一个广告分钟：你应该考虑使用FrançoisPottier的Menhir而不是ocamlyacc，它就像一个“yacc，升级”，在所有方面都更好（更易读的语法，更强大的构造，更容易调试...）虽然仍然非常相似。它当然可以与ocamllex结合使用。

您的expr1规则仅允许以expr规则开头和结尾。你应该放大它以允许expr之前或之后的“东西”。类似的东西：

junk:
| junk LPAREN
| junk RPAREN
| junk INT
| junk IDENT

expr1:
| junk expr junk EOF

请注意，此语法不允许module标记显示在junk部分中。这样做会有点问题，因为它会使语法模糊不清（您正在寻找的结构可以嵌入expr或junk）。如果你在表格形式之外可能有一个module令牌，你应该考虑改变词法分析器以捕获单个令牌中感兴趣的整个module ident (结构，这样它就可以原子化从语法中匹配。然而，从长远来看，更细粒度的令牌可能更好。

Answer 2

根据@gasche的建议，我尝试了menhir，并且已经取得了更好的效果。我将verLexer.ml更改为：

{
  open VerParser
}
rule lex = parse
  | [' ' '\n' '\t']               { lex lexbuf }
  | ['0'-'9']+ as s               { INT(int_of_string s) }
  | '('                           { LPAREN }
  | ')'                           { RPAREN }
  | "module"                      { MODULE }
  | ['A'-'Z''a'-'z''0'-'9''_']+ as s  { IDENT(s) }
  | _  as c                       { lex lexbuf }
  | eof                           { EOF }

并将verParser.mly更改为：

%{ type expr =  Module of expr | Ident of string | Int of int
           |Lparen | Rparen  | Junk %}

%token <int> INT
%token <string> IDENT
%token  LPAREN RPAREN MODULE EOF

%start expr1
%type <expr> expr1


%%

expr:
  | MODULE IDENT LPAREN    { Module( Ident $2) };

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

expr1:
| junk* expr junk* EOF { $2 };

这里的关键是menhir允许规则用'*'参数化，如上面的行中我在规则中有'垃圾*'意味着匹配垃圾0次或更多次。 ocamlyacc似乎不允许这样做。

现在当我在REPL中尝试时，我得到了：

# #use "verParser.ml" ;;
# #use "verLexer.ml" ;;
# expr1 lex (Lexing.from_string "module foo ( " ) ;;
- : expr = Module (Ident "foo")
# expr1 lex (Lexing.from_string "some module foo ( " ) ;;
- : expr = Module (Ident "foo")
# expr1 lex (Lexing.from_string "some module foo (\nbar " ) ;;
- : expr = Module (Ident "foo")
# expr1 lex (Lexing.from_string "some module foo (\n//comment " ) ;;
- : expr = Module (Ident "foo")
# expr1 lex (Lexing.from_string "some module fot foo (\n//comment " ) ;;
Exception: Error.
# expr1 lex (Lexing.from_string "some module foo (\n//comment " ) ;;

这似乎完全符合我的要求。

使用ocamllex / ocamlyacc来解析部分语法

2 个答案: