anchor.diff:                  update -> {element(1, Term), element(2, Term)};
                   {update, Val1} -> {element(1, Term), Val1};
                   {update, Key1, Val1} -> {Key1, Val1};
  -                error -> throw({invalid, element(1, Term)})
  +                error -> throw({invalid, Term})
               end,
               {lists:keystore(Key, 1, Opts, {Key, Val}), RestOpts}
       end,
  
positive.code:         Environment = nksip_config_cache:app_config(),
          Defaults = nksip_lib:defaults(Environment, default_config()),
          Opts1 = nksip_lib:defaults(Opts, Defaults),
          {Opts2, RestOpts} = parse_opts(Opts1, [], []),
          Plugins0 = proplists:get_all_values(plugins, Opts),
          Plugins = sort_plugins(lists:flatten(Plugins0), []),
          Opts3 = [{plugins, Plugins}|Opts2],
          Opts4 = parse_plugins_opts(RestOpts, Plugins, Opts3),
          Cache = cache_syntax(Opts4),
          PluginCallbacks = plugin_callbacks_syntax([nksip|Plugins]),
          AppName = nksip_lib:get_value(name, Opts4, nksip),
  
negative.code:     ConfigOpts;
  
  parse_plugins_opts([], ConfigOpts, PluginOpts) ->
      lager:notice("Ignoring unrecognized options starting '~p' SipApp: ~p",
                   [nksip_lib:get_value(name, ConfigOpts), PluginOpts]),
      ConfigOpts;
  
  parse_plugins_opts([Plugin|RestPlugins], ConfigOpts, PluginOpts) ->
      ?P("CALLING ~p, ~p, ~p", [Plugin, PluginOpts, ConfigOpts]),
      case erlang:function_exported(Plugin, parse_config, 2) of
          true -> 
              case Plugin:parse_config(PluginOpts, ConfigOpts) of
                  {ok, PluginOpts1, ConfigOpts1} ->
                      ?P("OK: ~p, ~p", [PluginOpts1, ConfigOpts1]),
                      parse_plugins_opts(RestPlugins, ConfigOpts1, PluginOpts1);
                  {error, Error} ->
                      throw({invalid, Error})
              end;
          false ->
              parse_plugins_opts(RestPlugins, ConfigOpts, PluginOpts)
      end.
  
  
  
  %% @private
  