anchor.diff:      end.
   
   process_tree(ParseTree, Options) ->
  -    {Dict0, InclusionTrail, TokenAcc} = case proplists:get_value(file, Options) of
  +    {Dict0, IncludeTrail, TokenAcc} = case proplists:get_value(file, Options) of
           undefined -> {dict:new(), [], []};
           FileName -> {dict:store('FILE', [{string, 1, FileName}], dict:new()),
                   [filename:absname(FileName)], 
  
positive.code: 
      Dict2 = dict:store('MACHINE',  [{atom, 1, list_to_atom(erlang:system_info(machine))}], Dict1),
  
      case catch process_tree(ParseTree, Dict2, InclusionTrail, TokenAcc) of
          {error, What} ->
              {error, What};
          {_MacroDict, RevTokens} ->
              {ok, lists:reverse(RevTokens)}
      end.
  
  process_tree([], MacroDict, _, TokenAcc) ->
      {MacroDict, TokenAcc};
  process_tree([Node|Rest], MacroDict, InclusionTrail, TokenAcc) ->
      case Node of
          {'macro_define', {_Type, Loc, MacroName}} ->
              NewDict = dict:store(MacroName, [{atom,Loc,true}], MacroDict),
              process_tree(Rest, NewDict, InclusionTrail, TokenAcc);
          {'macro_define', {_Type, _Loc, MacroName}, MacroTokens} ->
              NewDict = dict:store(MacroName, MacroTokens, MacroDict),
              process_tree(Rest, NewDict, InclusionTrail, TokenAcc);
          {'macro_define', {_Type, _Loc, MacroName}, MacroArgs, MacroTokens} ->
              NewDict = dict:store({MacroName, length(MacroArgs)}, {MacroArgs, MacroTokens}, MacroDict),
              process_tree(Rest, NewDict, InclusionTrail, TokenAcc);
          {'macro_undef', {_Type, _Loc, MacroName}} ->
              NewDict = dict:erase(MacroName, MacroDict),
              process_tree(Rest, NewDict, InclusionTrail, TokenAcc);
          {'macro_include', {string, Loc, FileName}} ->
              AbsName = filename:absname(FileName),
              {IncludeMacroDict, IncludeTokens} = process_inclusion(AbsName, Loc, MacroDict, InclusionTrail),
              process_tree(Rest, IncludeMacroDict, InclusionTrail, IncludeTokens ++ TokenAcc);
          {'macro_include_lib', {string, Loc, FileName}} ->
              AbsName = expand_include_lib(FileName),
              {IncludeMacroDict, IncludeTokens} = process_inclusion(AbsName, Loc, MacroDict, InclusionTrail),
              process_tree(Rest, IncludeMacroDict, InclusionTrail, IncludeTokens ++ TokenAcc);
          {'macro_ifdef', {_Type, _Loc, MacroName}, IfBody} ->
              process_ifelse(Rest, MacroName, IfBody, [], MacroDict, InclusionTrail, TokenAcc);
          {'macro_ifdef', {_Type, _Loc, MacroName}, IfBody, ElseBody} ->
              process_ifelse(Rest, MacroName, IfBody, ElseBody, MacroDict, InclusionTrail, TokenAcc);
          {'macro_ifndef', {_Type, _Loc, MacroName}, IfBody} ->
              process_ifelse(Rest, MacroName, [], IfBody, MacroDict, InclusionTrail, TokenAcc);
          {'macro_ifndef', {_Type, _Loc, MacroName}, IfBody, ElseBody} ->
              process_ifelse(Rest, MacroName, ElseBody, IfBody, MacroDict, InclusionTrail, TokenAcc);
          {'macro', {var, {Line, _Col} = Loc, 'LINE'}} ->
              process_tree(Rest, MacroDict, InclusionTrail, [{integer, Loc, Line}|TokenAcc]);
          {'macro', {var, Line, 'LINE'}} when is_integer(Line) ->
              process_tree(Rest, MacroDict, InclusionTrail, [{integer, Line, Line}|TokenAcc]);
          {'macro', {_Type, _Loc, MacroName}} ->
              InsertTokens = dict:fetch(MacroName, MacroDict),
              {_, RevProcessedTokens} = process_tree(InsertTokens, MacroDict, InclusionTrail, []),
              process_tree(Rest, MacroDict, InclusionTrail, RevProcessedTokens ++ TokenAcc);
          {'macro', {_Type, Loc, MacroName}, MacroArgs} ->
              {DefinedArgs, DefinedTokens} = dict:fetch({MacroName, length(MacroArgs)}, MacroDict),
              InsertTokens = expand_macro_fun(Loc, DefinedArgs, DefinedTokens, MacroArgs),
              {_, RevProcessedTokens} = process_tree(InsertTokens, MacroDict, InclusionTrail, []),
              process_tree(Rest, MacroDict, InclusionTrail, RevProcessedTokens ++ TokenAcc);
          OtherToken ->
              process_tree(Rest, MacroDict, InclusionTrail, [OtherToken|TokenAcc])
      end.
  
  process_ifelse(Rest, MacroName, IfBody, ElseBody, MacroDict, InclusionTrail, TokenAcc) ->
      ChooseBody = case dict:is_key(MacroName, MacroDict) of
          true -> IfBody;
          false -> ElseBody
      end,
      {NewMacroDict, NewTokens} = process_tree(ChooseBody, MacroDict, InclusionTrail, []),
      process_tree(Rest, NewMacroDict, InclusionTrail, NewTokens ++ TokenAcc).
  
  process_inclusion(FileName, {Line, _}, MacroDict, InclusionTrail) ->
      process_inclusion(FileName, Line, MacroDict, InclusionTrail);
  process_inclusion(FileName, Line, MacroDict, InclusionTrail) ->
      case lists:member(FileName, InclusionTrail) of
          true ->
              throw({error, {circular_inclusion, FileName}});
          false ->
  
negative.code: process_tokens(Tokens) ->
      process_tokens(Tokens, []).
  
  % Valid options:
  % - file: The path of the file being processed
  % - include: A list of directories to include in the .hrl search path
  process_tokens(Tokens, Options) ->
      {Tokens1, Module} = mark_keywords(Tokens),
      case aleppo_parser:parse(Tokens1) of
  