anchor.diff:      Decoders = make_decoders(TaggedElems, ParentMod, ModName),
       Encoders = make_encoders(TaggedElems, ModName),
       Printer = make_printer(TaggedElems, PredefRecords, ModName, ParentMod),
  +    GettersSetters = make_getters_setters(TaggedElems, PredefRecords, ModName),
       Compile = erl_syntax:attribute(?AST(compile), [?AST(export_all)]),
       LocalFunForms = make_local_funs(FunDeps, TaggedElems, ModName),
  -    NewAST = Decoders ++ Encoders ++ Printer ++ LocalFunForms ++ AST,
  +    NewAST = Decoders ++ Encoders ++ GettersSetters ++ Printer ++ LocalFunForms ++ AST,
       ResultAST = erl_syntax:form_list([Hdr, Module, Compile|NewAST]),
       file:write_file(
         filename:join([ErlDirName, ModNameErl]),
  
positive.code:      make_function(is_known_tag,
  		   [?AST({xmlel, Name, Attrs, _}), ?AST(TopXMLNS)],
  		   KnownTagCase),
       make_function(pp, [?AST(Term)], [PPCase])].
  
  make_encoders(TaggedSpecs, ModName) ->
  
negative.code: 			fun({RecName, RecSize}) ->
  				?AST({'?a(RecName)', '?a(RecSize)'})
  			end, Records))])].
  
  make_getters_setters(TaggedSpecs, PredefRecords, ModName) ->
      RecNames = lists:foldl(
                   fun({Tag, #elem{result = Result, module = Mod}}, Acc)
  		       when Mod == ModName ->
                           try
                               [H|_]= tuple_to_list(Result),
                               true = is_atom(H),
                               false = is_label(H),
                               dict:append(H, Tag, Acc)
                           catch _:_ ->
                                   Acc
                           end;
  		    (_, Acc) ->
  			 Acc
                   end, dict:new(), TaggedSpecs),
      {Getters, Setters} =
          lists:foldl(
            fun({Tag, #elem{result = Result}}, {Acc1, Acc2}) ->
                    try
                        [H|T]= tuple_to_list(Result),
                        true = is_atom(H),
                        false = is_label(H),
                        [Tag|_] = dict:fetch(H, RecNames),
  		      Fields = case dict:find(H, PredefRecords) of
  				   {ok, Fs} ->
  				       [FName || {FName, _} <- Fs];
  				   error ->
  				       [label_to_record_field(F) || F <- T]
  			       end,
  		      case lists:member(sub_els, Fields) of
  			  false ->
  			      {Acc1, Acc2};
  			  true ->
  			      {[erl_syntax:clause(
  				  [record_fields_to_vars(H, Fields)],
  				  none,
  				  [?AST(_sub_els)])|Acc1],
  			       [erl_syntax:clause(
  				  [record_fields_to_vars(H, Fields, [{sub_els, ?AST(_)}]),
  				   ?AST(_sub_els)],
  				  none,
  				  [record_fields_to_vars(
  				     H, Fields, [{sub_els, ?AST(_sub_els)}])])|Acc2]}
  		      end
  		  catch _:_ ->
  			 {Acc1, Acc2}
                    end
            end, {[], []}, TaggedSpecs),
      case {Getters, Setters} of
  	{[], []} ->
  	    [];
  	_ ->
  	    [erl_syntax:function(?AST(get_els), Getters),
  	     erl_syntax:function(?AST(set_els), Setters)]
      end.
  
  elem_to_AST(#elem{name = Name, xmlns = XMLNS, cdata = CData,
                    result = Result, attrs = Attrs, refs = _Refs} = Elem,
  