anchor.diff:  
   parse_arguments(Opts, Args) ->
       try lists:map(fun
  -              ({K, N, F, D}) -> {K, map_args(K, N, F, D, proplists:get_all_values(K, Args))};
  -              ({K, N, F}) ->
  -                  case proplists:get_all_values(K, Args) of
  -                  [] -> erlang:error({missing_option, K});
  -                  A -> {K, map_args(K, N, F, undefined, A)}
  -                  end
  -              end, Opts) of
  -    Options -> {ok, Options}
  +                      ({K, N, F, D}) -> {K, map_args(K, N, F, D, proplists:get_all_values(K, Args))};
  +                      ({K, N, F}) ->
  +                         case proplists:get_all_values(K, Args) of
  +                             [] -> erlang:error({missing_option, K});
  +                             A -> {K, map_args(K, N, F, undefined, A)}
  +                         end
  +                 end, Opts) of
  +        Options -> {ok, Options}
       catch
  -    error:{missing_option, K} -> {missing_option, K};
  -    error:{parse_error, Reason, K, A} -> {parse_error, Reason, K, A}
  +        error:{missing_option, K} -> {missing_option, K};
  +        error:{parse_error, Reason, K, A} -> {parse_error, Reason, K, A}
       end.
  
positive.code:                        [{report_dir, LogDir}|Options]
                 end,
      case rb:start(Options1) of
      {ok, _Pid} -> ok;
      {error, already_present} ->
          % Can sometimes get wedged
          supervisor:delete_child(sasl_sup, rb_server),
          erlang:error(try_again);
      {error, Reason} ->
          erlang:error(Reason)
      end,
      case RegExp of
      [] -> rb:show();
      _ -> rb:grep(RegExp)
      end,
      catch rb:stop(),
      TempFile.
  
negative.code: map_types(TypeStrings) ->
      Types = lists:map(fun list_to_atom/1, TypeStrings),
      case lists:all(fun (T) -> lists:member(T, ?report_types) end, Types) of
          true -> Types;
          false -> usage("argument to -t must be one or more of ~w~n",
                         [?report_types])
      end.
  
  start() ->
      Options = case parse_arguments([{h, 0, undefined, false},
                                      {n, 1, fun list_to_integer/1, all},
                                      {e, 1, undefined, undefined},
                                      {t, one_or_more, fun map_types/1, all},
                                      {report_dir, 1, undefined}],
                                     init:get_arguments()) of
                    {ok, O} ->
                        O;
                    {parse_error, badarg, n, _} ->
                        usage("-n requires a single integer argument~n", []);
                    {missing_option, K} ->
                        usage("option ~p is required~n", [K]);
                    {parse_error, {wrong_number_of_args, _, N}, K, _} ->
                        usage("option ~p requires ~p arguments~n", [K, N]);
                    Error -> usage("parse error: ~p~n", [Error])
                end,
      case proplists:get_value(h, Options) of
          true -> usage();
          false -> ok
      end,
      Dir = proplists:get_value(report_dir, Options),
      Types = proplists:get_value(t, Options),
  