anchor.diff:          | None -> []
   
       and expandMetaRef metaName _params metaArgs' = 
  -        let key = getKey metaName metaArgs' in                
  -        if refsTbl.ContainsKey(key) then (PRef (refsTbl.Item key, _params), res)
  +        let key = getKey metaName metaArgs'
  +        if refsTbl.ContainsKey(key)
  +        then (PRef (refsTbl.Item key, _params), res)
           else
  -          let rName = createNewName metaName in       
  +          let rName = createNewName metaName
             let eRules = refsTbl.Add(key,rName) ;
                          genNewRule (getText rName) _params 
                                     metaRulesTbl (getText metaName) metaArgs' 
  -          in let b = PRef (rName, _params) 
  -             in (b, res @ eRules)
  +          let b = PRef (rName, _params) 
  +          (b, res @ eRules)
           
   
       in
  
positive.code:           args = createPairsList metaRule.name metaRule.metaArgs metaArgs 
          in 
          let fArgs = getFormalArgs metaRule.name _params metaRule.args
          in let args' = list2opt fArgs in
          let (b, newRules) = transformBody rName args' args [] metaRule.body 
          in ( newRules @ [ createRule rName fArgs b metaRule._public [] ] )
  
      and genNewRule rName args' mRulesTbl metaName' metaArgs =
          let res = findMetaRule mRulesTbl metaName' in 
  
negative.code:     let rec transformBody ruleName actParams args nRules = 
          function
          | PRef (r, p) -> 
            let rName = getText r
            (** pass actual parameters for item 
             *  (which is replaced with yard_item_...) 
             *)
            let aParams = updateActParams (isItem rName) actParams p
            let param = getActualParam rName args
            let (|Terminal|NonTerminal|) (name:string) = 
              if name.[0] = name.ToLower().[0] then NonTerminal else Terminal
  
            match param with          
            | Some n -> 
              match n with
              | NonTerminal -> PRef (getNewSource r n, aParams), nRules
              | Terminal    -> PToken (getNewSource r n), nRules
            | None   -> PRef (r, p), nRules
            
          | PAlt (l, r) -> 
            let (l', nRules') = transformBody ruleName actParams args nRules l 
            let (r', nRules'') = transformBody ruleName actParams args nRules' r
            PAlt (l', r'), nRules''
          | PSeq (seq, a) -> 
            let rec transformSeq args = function
                | h::t -> 
                  let (body', newRules) = 
                      transformBody ruleName actParams args [] h.rule 
                  let (seq', newRules') = transformSeq args t 
                  ({ h with rule = body' }::seq', newRules @ newRules')
                | []   -> ([], [])
            let (l', nRules') = transformSeq args seq 
            (PSeq (l', a), nRules @ nRules')
          | PToken t -> (PToken t, nRules)
          | PLiteral r -> (PLiteral r, nRules)
  
          | PMetaRef (n, p, mArgs) -> 
            (** we accept other metarule as parameter *)
            let n' = (*printPairList args ;*) replaceFormal args n
            let mRuleName' = getText n'
            let p' = updateActParams (isEBNFmeta mRuleName') actParams p
            let mArgs' = replaceFormals mArgs args
            let (b', nRules') = expandMetaRef n' p' mArgs'
            b', nRules @ nRules'     
          | POpt r -> 
            let (b', nRules') = transformBody ruleName actParams args nRules r
            in (POpt b', nRules')
  