嵌套循环时间分析(Nested Loops Time Analysis)

 你写的是想要检索procedure_declaration的解析，但是在你的代码中，你只想检索一个procedure_body，所以我假设这就是你想要的。 
 
 用我自己的话说，你想要编写语法而不告诉嵌入语法嵌入了哪种语法。 问题（在你的情况下没问题，因为你幸运地有一个非常友好的语法）这是在LALR（1）中，你需要一个前瞻标记来决定采取哪个规则。 你的语法看起来像这样： 
 
procedure_declaration:
  SUB procedure_name EOS
  procedure_body
  END SUB EOS
 
 您可以将procedure_name和procedure_body组合在一起，因此您的规则和语义操作将如下所示： 
 
procedure_declaration:
  SUB combined = procedure_name EOS /* nothing here */ EOS
  { { procedure_name = fst combined; procedure_body = snd combined; } }

procedure_name:
  id = IDENT {
    let lexbuf = _menhir_env._menhir_lexbuf in
    (id, Parser_pd.main Lexer_pd.token lexbuf)
  }
 
 Parser_pd将包含此规则： 
 
main: procedure_body END SUB { $1 }
 
 您很可能在Parser_pd中想要END SUB，因为procedure_body可能不会自我分隔。 
 
 请注意，在解析过程名称标识符之后的第一个EOS之前调用子解析器，因为这是您的前瞻。 如果你在 EOS中调用它，则为时已晚，并且解析器已经从正文中提取了一个令牌。 第二个EOS是END SUB之后的EOS。 
 
 _menhir_env显然是一个只适用于menhir的黑客。 您可能需要另一个hack来制作menhir --infer work（如果您使用它），因为不希望用户引用它，因此符号不在范围内。 那个黑客将是： 
 
%{
  type menhir_env_hack = { _menhir_lexbuf : Lexing.lexbuf }
  let _menhir_env = { _menhir_lexbuf = Lexing.from_function
    (* Make sure this lexbuf is never actually used. *)
    (fun _ _ -> assert false) }
%}

You write that you want to retrieve the parsing of procedure_declaration, but in your code, you only want to retrieve a procedure_body, so I'm assuming that's what you want.
 
To put into my own words, you want to have to compose grammars without telling the embedding grammar which grammar is embedded. The problem (no problem in your case, because you luckily have a very friendly grammar) with this is that in LALR(1), you need one token of lookahead to decide which rule to take. Your grammar looks like this:
 
procedure_declaration:
  SUB procedure_name EOS
  procedure_body
  END SUB EOS
 
You can combine procedure_name and procedure_body, so your rule and semantic action will look like:
 
procedure_declaration:
  SUB combined = procedure_name EOS /* nothing here */ EOS
  { { procedure_name = fst combined; procedure_body = snd combined; } }

procedure_name:
  id = IDENT {
    let lexbuf = _menhir_env._menhir_lexbuf in
    (id, Parser_pd.main Lexer_pd.token lexbuf)
  }
 
Parser_pd will contain this rule:
 
main: procedure_body END SUB { $1 }
 
You will very likely want END SUB in Parser_pd, because procedure_body is likely not self-delimiting.
 
Note that you call the sub-parser before parsing the first EOS after the procedure name identifier, because that is your lookahead. If you call it in EOS, it is too late, and the parser will have pulled a token from the body, already. The second EOS is the one after END SUB.
 
The _menhir_env thing is obviously a hack that only works with menhir. You may need another hack to make menhir --infer work (if you use that), because that doesn't expect a user to refer to it, so the symbol won't be in scope. That hack would be:
 
%{
  type menhir_env_hack = { _menhir_lexbuf : Lexing.lexbuf }
  let _menhir_env = { _menhir_lexbuf = Lexing.from_function
    (* Make sure this lexbuf is never actually used. *)
    (fun _ _ -> assert false) }
%}