anchor.diff:  
   end_method(#dbus_method{args=Args}=Method) ->
       InArgs = lists:filter(fun (#dbus_arg{direction=in}) ->
  -				  true;
  -			      (#dbus_arg{direction=undefined}) ->
  -				  true;
  -			      (_) ->
  -				  false
  -			  end, Args),
  +                                  true;
  +                              (#dbus_arg{direction=undefined}) ->
  +                                  true;
  +                              (_) ->
  +                                  false
  +                          end, Args),
       Signature = lists:foldl(fun (#dbus_arg{type=Type}, Acc) ->
  -				    << Type/binary, Acc/binary >>
  -			    end, <<>>, InArgs),
  +                                    << Type/binary, Acc/binary >>
  +                            end, <<>>, InArgs),
       case dbus_marshaller:unmarshal_signature(Signature) of
  -	{ok, Types} ->
  -	    Method#dbus_method{args=lists:reverse(Args), in_sig=Signature, in_types=Types};
  -	more ->
  -	    throw({error, incomplete_signature})
  +        {ok, Types} ->
  +            Method#dbus_method{args=lists:reverse(Args), in_sig=Signature, in_types=Types};
  +        more ->
  +            throw({error, incomplete_signature})
       end.
   
   
  
positive.code: -include("dbus_errors.hrl").
  
  -export([
  	 find_interface/2,
  	 find_method/3,
  	 find_signal/3,
  	 to_xml/1,
  	 from_xml/1,
  	 from_xml_string/1
  	]).
  
  -record(state, {node         :: dbus_node(),
  		child        :: dbus_node(),
  		iface        :: dbus_iface(),
  		method       :: dbus_method(),
  		signal       :: dbus_signal(),
  		property     :: dbus_property(),
  		s     = root :: atom()}).
  
  %%%
  %%% API
  %%%
  -spec find_interface(dbus_node(), Iface :: dbus_name()) -> 
  			 {ok, dbus_iface()} | {error, dbus_err()}.
  find_interface(#dbus_node{interfaces=Ifaces}, IfaceName) ->
      case find_name(IfaceName, Ifaces, fun dbus_names:bin_to_iface/1) of
  	{value, #dbus_iface{}=I} ->
  	    {ok, I};
  	none ->
  	    {error, {'org.freedesktop.DBus.UnknownInterface', [IfaceName]}}
      end.
  
  
  -spec find_method(dbus_node(), Iface :: dbus_name(), Method :: dbus_name()) -> 
  			 {ok, dbus_method()} | {error, dbus_err()}.
  find_method(#dbus_node{interfaces=Ifaces}=Node, IfaceName, MethodName) ->
      case find_name(IfaceName, Ifaces, fun dbus_names:bin_to_iface/1) of
  	{value, #dbus_iface{methods=Methods}=_I} ->
  	    case find_name(MethodName, Methods, fun dbus_names:bin_to_method/1) of
  		{value, #dbus_method{}=Method} ->
  		    {ok, Method};
  		none ->
  		    {error, {'org.freedesktop.DBus.UnknownMethod', {[MethodName], IfaceName, Node}}}
  	    end;
  	none ->
  	    {error, {'org.freedesktop.DBus.UnknownInterface', [IfaceName]}}
      end.
  
  
  -spec find_signal(dbus_node(), Iface :: dbus_name(), Signal :: dbus_name()) -> 
  			 {ok, dbus_signal()} | {error, dbus_err()}.
  find_signal(#dbus_node{interfaces=Ifaces}=Node, IfaceName, SignalName) ->
      case find_name(IfaceName, Ifaces, fun dbus_names:bin_to_iface/1) of
  	{value, #dbus_iface{signals=Signals}} ->
  	    case find_name(SignalName, Signals, fun dbus_names:bin_to_signal/1) of
  		{value, #dbus_signal{}=Signal} ->
  		    {ok, Signal};
  		none ->
  		    {error, {'org.freedesktop.DBus.UnknownSignal', {[SignalName], IfaceName, Node}}}
  	    end;
  	none ->
  	    {error, {'org.freedesktop.DBus.UnknownInterface', [IfaceName]}}
      end.
  
  
  
negative.code: 
  xml_event({startElement, _, "annotation", _, Attrs}, _L, #state{s=method, method=#dbus_method{annotations=Annotations}=M}=S) ->
      S#state{s=method_annotation, 
              method=M#dbus_method{annotations=[ build_annotation(Attrs, {undefined, undefined}) | Annotations]}};
  
  xml_event({startElement, _, "annotation", _, Attrs}, _L, #state{s=iface, iface=#dbus_iface{annotations=Annotations}=I}=S) ->
      S#state{s=iface_annotation, 
              iface=I#dbus_iface{annotations=[ build_annotation(Attrs, {undefined, undefined}) | Annotations]}};
  
  xml_event({startElement, _, "annotation", _, Attrs}, _L, #state{s=property, property=#dbus_property{annotations=Annotations}=P}=S) ->
      S#state{s=property_annotation, 
              property=P#dbus_property{annotations=[ build_annotation(Attrs, {undefined, undefined}) | Annotations]}};
  
  xml_event({startElement, _, "annotation", _, Attrs}, _L, #state{s=signal, signal=#dbus_signal{annotations=Annotations}=Sig}=S) ->
      S#state{s=signal_annotation, 
              signal=Sig#dbus_signal{annotations=[ build_annotation(Attrs, {undefined, undefined}) | Annotations]}};
  
  xml_event({endElement, _, "node", _}, _L, #state{s=node}=S) ->
      S#state{s=root};
  