anchor.diff:  
   transforms(Os) -> [ M || {parse_transform,M} <- Os ].
   
  -transform_module(#compile{options=Opt,code=Code0}=St0) ->
  +transform_module(Code0, #compile{options=Opt}=St) ->
       %% Extract compile options from code into options field.
       case transforms(Opt ++ compile_options(Code0)) of
  -	[] -> {ok,St0};				%No parse transforms.
  +	[] ->
  +            %% No parse transforms.
  +            {ok,Code0,St};
   	Ts ->
   	    %% Remove parse_transform attributes from the abstract code to
   	    %% prevent parse transforms to be run more than once.
   	    Code = clean_parse_transforms(Code0),
  -	    St = St0#compile{code=Code},
  -	    foldl_transform(St, Ts)
  -    end.
  -
  -foldl_transform(St, [T|Ts]) ->
  +	    foldl_transform(Ts, Code, St)
  +    end.
  +
  +foldl_transform([T|Ts], Code0, St) ->
       Name = "transform " ++ atom_to_list(T),
       case code:ensure_loaded(T) =:= {module,T} andalso
  -                erlang:function_exported(T, parse_transform, 2) of
  +        erlang:function_exported(T, parse_transform, 2) of
           true ->
  -            Fun = fun(S) ->
  -                         T:parse_transform(S#compile.code, S#compile.options)
  +            Fun = fun(Code, S) ->
  +                          T:parse_transform(Code, S#compile.options)
                     end,
               Run = case member(time, St#compile.options) of
  -                      true  -> fun run_tc/2;
  -                      false -> fun({_Name,F}, S) -> catch F(S) end
  +                      true  ->
  +                          fun run_tc/3;
  +                      false ->
  +                          fun({_Name,F}, Code, S) ->
  +                                  catch F(Code, S)
  +                          end
                     end,
  -            case Run({Name, Fun}, St) of
  +            case Run({Name, Fun}, Code0, St) of
                   {error,Es,Ws} ->
                       {error,St#compile{warnings=St#compile.warnings ++ Ws,
                                         errors=St#compile.errors ++ Es}};
  
positive.code: 		   true -> MainRule ++ PhonyRules;
  		   _ -> MainRule
  	       end,
      {ok,St#compile{code=iolist_to_binary([Makefile,"\n"])}}.
  
  makedep_add_headers(Ifile, [{attribute,_,file,{File,_}}|Rest],
  		    Included, LineLen, MainTarget, Phony, Opts) ->
  
negative.code: 	      [Name,Elapsed/1000,Mem]),
      Val.
  
  run_eprof({Name,Fun}, Code, Name, St) ->
      io:format("~p: Running eprof\n", [Name]),
      c:appcall(tools, eprof, start_profiling, [[self()]]),
      Val = (catch Fun(Code, St)),
      c:appcall(tools, eprof, stop_profiling, []),
      c:appcall(tools, eprof, analyze, []),
      Val;
  run_eprof({_,Fun}, Code, _, St) ->
      catch Fun(Code, St).
  
  comp_ret_ok(Code, #compile{warnings=Warn0,module=Mod,options=Opts}=St) ->
      case werror(St) of
          true ->
              case member(report_warnings, Opts) of
  