anchor.diff:  store({handler_integer, TO} = Conf, _) when is_integer(TO)->
     {ok, Conf}.
   
  -do(ModRec) ->
  -  case defer_response(ModRec) of
  -    false-> {proceed, safe_handle(ModRec)};
  -    true -> {proceed, ModRec#mod.data}
  +do(M) ->
  +  case defer_response(M) of
  +    false-> {proceed, safe_handle(M)};
  +    true -> {proceed, M#mod.data}
     end.
   
   %% we guarantee that handle/1 succeeds (in which case we send a 200) or we
   %% generate a 404.
  -safe_handle(ModRec) ->
  -  try handle(ModRec)
  -  catch _:_ -> fourofour(ModRec)
  +safe_handle(M) ->
  +  try handle(M)
  +  catch _:_ -> fourofour(M)
     end.
   
   %% true if some other mod_* has already handled the request
  
positive.code:       end;
      sent_headers ->
        Len = S#s.length + length(Chunk),
        send_chunk(ModRec,Chunk),
        S#s{length=Len};
      has_headers ->
        S#s{chunks=S#s.chunks++Chunk};
  
negative.code: 
  %%%% send stuff
  %% not chunking
  send_headers(false,M,Headers) ->
    send_header(M,200,[{"connection","close"} | Headers]);
  %% chunking
  send_headers(true,M,Headers) ->
    send_header(M,200,[{"transfer-encoding","chunked"} | Headers]).
  
  %% wrapper around httpd_response
  send_header(M,Status,HTTPHeaders) ->
    ExtraHeaders = read_header_cache(M),
    httpd_response:send_header(M,Status,ExtraHeaders++HTTPHeaders).
  
  send_chunk(M,Chunk) ->
    httpd_response:send_chunk(M,Chunk,false).
  
  send_final_chunk(M) ->
    httpd_response:send_final_chunk(M,false).
  
  send_unchunked(Status,M,Headers,Body) ->
    Len = integer_to_list(lists:flatlength(Body)),
    send_headers(false,M,[{"content-length",Len} | Headers]),
    httpd_response:send_body(M,Status,Body),
    Len.
  
  read_header_cache(M) ->
    try httpd_response:cache_headers(M)                % -R15
    catch
      _:undef ->
        httpd_response:cache_headers(M,script_nocache) % R16-
    end.
  