anchor.diff:  
   compile(File) ->
       {ok, _, Syntax} = compile_to_ast(File),
  -    % io:format("Syntax is ~p~n", [Syntax]),
  -    % {ok, Binary} = file:read_file(File),
  -    % {ok, Tokens, _} = erl_scan:string(binary_to_list(Binary), 1,
  -    %                                  [return_white_spaces, return_comments]),
  -    % io:format("Tokens is ~p~n", [Tokens]),
  +    {ok, Binary}    = file:read_file(File),
  +    {ok, Tokens, _} = erl_scan:string(binary_to_list(Binary), 1,
  +                                      [return_white_spaces, return_comments]),
  +    {ok, Tokens2} = collect_tokens(Tokens),
       Name = filename:rootname(filename:basename(File)),
  -    comp2(Syntax, #module{name = Name}, []).
  +    comp2(Syntax, #module{name = Name}, Tokens2, []).
   
  -comp2([], Module, Acc) ->
  +comp2([], Module, _Tokens, Acc) ->
       Module#module{contents = lists:reverse(Acc)};
  -comp2([{function, LineNo, Fn, Arity, Contents} | T], Module, Acc) ->
  -    C = comp_fn(Contents, []),
  +comp2([{function, LineNo, Fn, Arity, Contents} | T], Module, Tokens, Acc) ->
  +    C = comp_fn(Contents, Tokens, []),
       NewAcc = #function{name     = Fn,
                          arity    = Arity,
                          line_no  = LineNo,
                          contents = C},
  -    comp2(T, Module, [NewAcc | Acc]);
  -comp2([{eof, _} | T], Module, Acc) ->
  -    comp2(T, Module, Acc);
  -comp2([{attribute, _, _, _} = A | T], Module, Acc) ->
  +    comp2(T, Module, Tokens, [NewAcc | Acc]);
  +comp2([{eof, _} | T], Module, Tokens, Acc) ->
  +    comp2(T, Module, Tokens, Acc);
  +comp2([{attribute, _, _, _} = A | T], Module, Tokens, Acc) ->
       #module{attributes = Attrs} = Module,
       NewM = Module#module{attributes = [A | Attrs]},
  -    comp2(T, NewM, Acc);
  -comp2([H | T], Module, Acc) ->
  +    comp2(T, NewM, Tokens, Acc);
  +comp2([H | T], Module, Tokens, Acc) ->
       io:format("Handle ~p~n", [H]),
  -    comp2(T, Module, Acc).
  +    comp2(T, Module, Tokens, Acc).
   
  -comp_fn([], Acc) ->
  +comp_fn([], _Tokens, Acc) ->
       lists:reverse(Acc);
  -comp_fn([{clause, LineNo, Params, Guards, Contents} | T], Acc) ->
  +comp_fn([{clause, LineNo, Params, Guards, Contents} | T], Tokens, Acc) ->
       C = comp_st(Contents, []),
       NewAcc = #clause{params   = Params,
                        guards   = Guards,
                        line_no  = LineNo,
                        contents = C},
  -    comp_fn(T, [NewAcc | Acc]);
  -comp_fn([H | T], Acc) ->
  +    comp_fn(T, Tokens, [NewAcc | Acc]);
  +comp_fn([H | T], Tokens, Acc) ->
       io:format("Handle (2) ~p~n", [H]),
  -    comp_fn(T, Acc).
  +    comp_fn(T, Tokens, Acc).
   
   comp_st([], Acc) ->
       lists:reverse(Acc);
  
positive.code:                             {ok, _, _} = Syn -> Syn;
                              error            -> {error, File}
                          end.
  
negative.code: -module(luvviescript).
  
  -export([
           compile/1
          ]).
  
  