anchor.diff:  to_xmerl(#dbus_node{}=Elem) ->
       {node,
        case to_binary(Elem#dbus_node.name) of
  -	 undefined ->
  -	     [];
  -	 Name ->
  -	     [{name, Name}]
  +         undefined ->
  +             [];
  +         Name ->
  +             [{name, Name}]
        end,
        to_xmerl(Elem#dbus_node.elements) ++
  -     to_xmerl(Elem#dbus_node.interfaces)
  +         to_xmerl(Elem#dbus_node.interfaces)
       };
   
   to_xmerl(#dbus_iface{}=Elem) ->
       {interface,
        [{name, to_binary(Elem#dbus_iface.name)}],
        to_xmerl(Elem#dbus_iface.methods) ++
  -     to_xmerl(Elem#dbus_iface.signals) ++
  -     to_xmerl(Elem#dbus_iface.properties)};
  +         to_xmerl(Elem#dbus_iface.signals) ++
  +         to_xmerl(Elem#dbus_iface.properties)};
   
   to_xmerl(#dbus_method{}=Elem) ->
       Result =
  -	case Elem#dbus_method.result of
  -	    none ->
  -		[];
  -	    undefined ->
  -		[];
  -	    Arg ->
  -		[to_xmerl(Arg)]
  -	end,
  +        case Elem#dbus_method.result of
  +            none ->
  +                [];
  +            undefined ->
  +                [];
  +            Arg ->
  +                [to_xmerl(Arg)]
  +        end,
       {method,
        case to_binary(Elem#dbus_method.name) of
  -	    undefined ->
  -	        [];
  -	    Name ->
  -	        [{name, Name}]
  +         undefined ->
  +             [];
  +         Name ->
  +             [{name, Name}]
        end,
        to_xmerl(Elem#dbus_method.args) ++ Result};
   
   to_xmerl(#dbus_signal{}=Elem) ->
       Result =
  -	case Elem#dbus_signal.result of
  -	    none ->
  -		[];
  -	    undefined ->
  -		[];
  -	    Arg ->
  -		[to_xmerl(Arg)]
  -	end,
  +        case Elem#dbus_signal.result of
  +            none ->
  +                [];
  +            undefined ->
  +                [];
  +            Arg ->
  +                [to_xmerl(Arg)]
  +        end,
       {signal,
        case list_to_binary(Elem#dbus_signal.name) of
  -	    undefined ->
  -	        [];
  -	    Name ->
  -	        [{name, Name}]
  +         undefined ->
  +             [];
  +         Name ->
  +             [{name, Name}]
        end,
        to_xmerl(Elem#dbus_signal.args) ++ Result};
   
   to_xmerl(#dbus_arg{}=Elem) ->
       {arg, 
        case to_binary(Elem#dbus_arg.name) of
  -	    undefined ->
  -	        [];
  -	    Name ->
  -	        [{name, Name}]
  +         undefined ->
  +             [];
  +         Name ->
  +             [{name, Name}]
        end ++
  -     [{direction, Elem#dbus_arg.direction}, {type, Elem#dbus_arg.type}],  []}.
  +         [{direction, Elem#dbus_arg.direction}, {type, Elem#dbus_arg.type}],  []}.
   
   xml_event(startDocument, _L, S) ->
       S;
  
positive.code: %%%
  find_name(Name, Tree, _) when is_atom(Name) ->
      case gb_trees:lookup(Name, Tree) of
  	{value, Iface} -> {value, Iface};
  	none -> gb_trees:lookup(atom_to_binary(Name, utf8), Tree)
      end;
  find_name(Name, Tree, ToKnownFun) when is_binary(Name) ->
      case gb_trees:lookup(Name, Tree) of
  	{value, Iface} -> {value, Iface};
  	none -> 
  	    case ToKnownFun(Name) of
  		Bin when is_binary(Bin) -> none;
  		Atom when is_atom(Atom) -> gb_trees:lookup(Atom, Tree)
  	    end
      end.
  
  
  
negative.code: 
  end_signal(#dbus_signal{args=Args}=Signal) ->
      OutArgs = lists:filter(fun (#dbus_arg{direction=out}) ->
                                     true;
                                 (#dbus_arg{direction=undefined}) ->
                                     true;
                                 (_) ->
                                     false
                             end, Args),
      Signature = lists:foldl(fun (#dbus_arg{type=Type}, Acc) ->
                                      << Type/binary, Acc/binary >>
                              end, <<>>, OutArgs),
      case dbus_marshaller:unmarshal_signature(Signature) of
          {ok, Types} ->
              Signal#dbus_signal{args=lists:reverse(Args), out_sig=Signature, out_types=Types};
          more ->
              throw({error, incomplete_signature})
      end.
  
  
  