anchor.diff:          let rMap = new System.Collections.Generic.Dictionary<_,_>()
           module'.openings
           |> List.iter (fun op ->
  -            try 
  +            try
                   publicRules.[op.text] |> List.iter (fun r ->
  -                    try 
  +                    try
                           rMap.[r.name.text] <- op.text
                       with
                       | e -> printfn "Get rules error: rule name: %A;" r.name.text
   
                           )
               with
  -            | e -> printfn "Get rules error: open: %A;" op.text  
  -            
  +            | e -> printfn "Get rules error: open: %A;" op.text
  +
           )
           module'.rules |> List.iter (fun r -> rMap.[r.name.text] <- getModuleName module')
           getModuleName module', rMap
  
positive.code: 
  let errorToken = "error"
  
  let getModuleName (m : Module<_,_>) = 
      match m.name with
      | Some n -> n.text
      | None -> ""
  
negative.code:         )
      |> dict
  
  let rec getAllNonTermOfProd (prod : Production.t<_,_>) =
      let inline getNonTermOfLst prodList = List.collect getAllNonTermOfProd prodList
  
      match prod with
      |PAlt(prod1, prod2)
      |PConj(prod1, prod2) -> List.append (getAllNonTermOfProd prod1) (getAllNonTermOfProd prod2)
      |PNeg prod -> getAllNonTermOfProd prod
      |PSeq(prodList, _, _) -> getNonTermOfLst << List.map (fun elem -> elem.rule) <| prodList
      |PToken(_) -> []
      |PRef(nonTerm, _) -> List.singleton nonTerm
      |PMany prod -> getAllNonTermOfProd prod
      |PMetaRef(ref, _, prodList) -> ref :: getNonTermOfLst prodList
      |PLiteral lit -> List.empty
      |PRepet(prod, _, _) -> getAllNonTermOfProd prod
      |PPerm prodList -> getNonTermOfLst prodList
      |PSome prod -> getAllNonTermOfProd prod
      |POpt prod -> getAllNonTermOfProd prod
  
  /// For each module creates map: rule -> (module, in which the rule is declared)
  let getRulesMap (grammar : Grammar.t<_,_>) =
      let publicRules = getPublicRules grammar
  