anchor.diff:  
   
   
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'band'}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary('&',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bor'}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary('|',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bxor'}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary('^',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bnot'}, [L]})->
  -    esast:unaryExpression(atom_to_binary('~',utf8),true,toksFuncBody(noreturn,L));
  -
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'or'}, [L,R]})->
  -    esast:logicalExpression(atom_to_binary('||',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'and'}, [L,R]})->
  -    esast:logicalExpression(atom_to_binary('&&',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'not'}, [L]})->
  -    esast:unaryExpression(atom_to_binary('!',utf8),true,toksFuncBody(noreturn,L));
  -
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'xor'}, [L,R]})->
  -    toksFuncBody(noreturn,{c_call, a, {a, a, erlang}, {a, a, 'or'}, [
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'band'}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary('&',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bor'}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary('|',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bxor'}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary('^',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'bnot'}, [L]})->
  +    esast:unaryExpression(atom_to_binary('~',utf8),true,parseFunctionBody(noreturn,L));
  +
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'or'}, [L,R]})->
  +    esast:logicalExpression(atom_to_binary('||',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'and'}, [L,R]})->
  +    esast:logicalExpression(atom_to_binary('&&',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'not'}, [L]})->
  +    esast:unaryExpression(atom_to_binary('!',utf8),true,parseFunctionBody(noreturn,L));
  +
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'xor'}, [L,R]})->
  +    parseFunctionBody(noreturn,{c_call, a, {a, a, erlang}, {a, a, 'or'}, [
               {c_call, a, {a, a, erlang}, {a, a, 'and'}, [L,{c_call, a, {a, a, erlang}, {a, a, 'not'}, [R]}]},
               {c_call, a, {a, a, erlang}, {a, a, 'and'}, [R,{c_call, a, {a, a, erlang}, {a, a, 'not'}, [L]}]}
           ]}
       );
   
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'div'}, [L,R]})->
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'div'}, [L,R]})->
       esast:callExpression(
            esast:memberExpression(esast:identifier(<<"Math">>),esast:identifier(<<"floor">>),false),
  -         [toksFuncBody(noreturn,{c_call, a, {b, c, erlang}, {d, e, '/'}, [L,R]})]
  +         [parseFunctionBody(noreturn,{c_call, a, {b, c, erlang}, {d, e, '/'}, [L,R]})]
        );
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'rem'}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary('%',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, '/='}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary('!=',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, '=<'}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary('<=',utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  -
  -toksFuncBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, FunctionName}, [L,R]})->
  -    esast:binaryExpression(atom_to_binary(FunctionName,utf8),toksFuncBody(noreturn,L),toksFuncBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, 'rem'}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary('%',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, '/='}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary('!=',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, '=<'}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary('<=',utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
  +
  +parseFunctionBody(noreturn,{c_call, _, {_, _, erlang}, {_, _, FunctionName}, [L,R]})->
  +    esast:binaryExpression(atom_to_binary(FunctionName,utf8),parseFunctionBody(noreturn,L),parseFunctionBody(noreturn,R));
   
   %Bodge job: external module calls
   %TODO: proper external module calls
  -toksFuncBody(noreturn,{c_call, _, {_, _, io}, {_, _, format}, [T]})->
  +parseFunctionBody(noreturn,{c_call, _, {_, _, io}, {_, _, format}, [T]})->
       esast:callExpression(
            esast:memberExpression(esast:identifier(<<"console">>),esast:identifier(<<"log">>),false),
  -         [toksFuncBody(noreturn,T)]
  +         [parseFunctionBody(noreturn,T)]
        );
   
   
  -toksFuncBody(noreturn,{c_call, _, {_, _, _Module}, {_, _, _FunctionName}, _Params})->
  -    io:format("",[]);
  -
  -
  -toksFuncBody(return,{c_values, _, _Values})->
  +parseFunctionBody(noreturn,{c_call, _, {_, _, _Module}, {_, _, _FunctionName}, _Params})->
  +    io:format("",[]);
  +
  +
  +parseFunctionBody(return,{c_values, _, _Values})->
       %io:format("~p~n", [tupleList_getVars_3(Values)]);
       io:format("",[]);
   
  -toksFuncBody(return,{c_var, A, Var})->
  -    esast:returnStatement(toksFuncBody(noreturn,{c_var, A, Var}));
  -toksFuncBody(noreturn,{c_var, _, Var})->
  +parseFunctionBody(return,{c_var, A, Var})->
  +    esast:returnStatement(parseFunctionBody(noreturn,{c_var, A, Var}));
  +parseFunctionBody(noreturn,{c_var, _, Var})->
       esast:identifier(atom_to_binary(Var,utf8));
       %io:format("",[]);
   
   
  -toksFuncBody(return,{c_seq, _, A, B})->
  +parseFunctionBody(return,{c_seq, _, A, B})->
       assembleSequence(
  -        toksFuncBody(noreturn,A),
  -        toksFuncBody(return,B));
  -toksFuncBody(noreturn,{c_seq, _, A, B})->
  +        parseFunctionBody(noreturn,A),
  +        parseFunctionBody(return,B));
  +parseFunctionBody(noreturn,{c_seq, _, A, B})->
       assembleSequence(
  -        toksFuncBody(noreturn,A),
  -        toksFuncBody(noreturn,B));
  -
  -
  -
  -toksFuncBody(return,{c_let, _, [{_, _, _Variable}], _A, _B})->
  +        parseFunctionBody(noreturn,A),
  +        parseFunctionBody(noreturn,B));
  +
  +
  +
  +parseFunctionBody(return,{c_let, _, [{_, _, _Variable}], _A, _B})->
       %io:format("        Let statement: ~s~n", [Variable]),
  -    %toksFuncBody(A),
  -    %toksFuncBody(B);
  +    %parseFunctionBody(A),
  +    %parseFunctionBody(B);
       io:format("",[]);
       
   % Is apply a local function call? Assignment from function? Assignment with pattern matching?
  -toksFuncBody(return,{c_apply, _, {_,_,{_FName,_Arity}}, _Params})->
  +parseFunctionBody(return,{c_apply, _, {_,_,{_FName,_Arity}}, _Params})->
       %io:format("Call local function ~s(",[FName]),
       %io:format("~p)~n", [tupleList_getVars_3(Params)]);
       io:format("",[]);
   
  -toksFuncBody(return,{c_apply, _, _A, _B})->
  +parseFunctionBody(return,{c_apply, _, _A, _B})->
       %io:format("        Apply statement: ~n");
       io:format("",[]);
       
  -toksFuncBody(return,{c_literal,_,Value})->
  +parseFunctionBody(return,{c_literal,_,Value})->
       esast:returnStatement(esast:literal(Value));
  -toksFuncBody(_,{c_literal,_,Value})->
  +parseFunctionBody(_,{c_literal,_,Value})->
       esast:literal(Value);
   
  -toksFuncBody(return,{c_tuple,_,_Values})->
  +parseFunctionBody(return,{c_tuple,_,_Values})->
       %io:format("        Tuple ~p~n", [tupleList_getVars_3(Values)]);
       io:format("",[]);
       
  -toksFuncBody(return,{c_primop,_,{_,_,Type},_Details})->
  +parseFunctionBody(return,{c_primop,_,{_,_,Type},_Details})->
       % io:format("        Error? ~p~n~p~n", [Type,Details]),
       esast:error(atom_to_list(Type),"TODO Errors dont parse nicely",esast:literal("Message"));
       % io:format("",[]);
       
  -toksFuncBody(return,{c_case, _, _Condition, _Clauses})->
  +parseFunctionBody(return,{c_case, _, _Condition, _Clauses})->
       %io:format("        case statement:"),
  -    %toksFuncBody(noreturn,Condition),
  -    %lists:map(fun({c_clause,_,MatchVals,_true,Body})->toksFuncBody(return,Body) end,Clauses).
  -    io:format("",[]);
  -    
  -toksFuncBody(_,T)->
  +    %parseFunctionBody(noreturn,Condition),
  +    %lists:map(fun({c_clause,_,MatchVals,_true,Body})->parseFunctionBody(return,Body) end,Clauses).
  +    io:format("",[]);
  +    
  +parseFunctionBody(_,T)->
       io:format("Unrecognised Token in function body: ~p", [T]).
   
   assembleSequence(L,R) when is_list(L) and is_list(R)->
  
positive.code: 
  
  tupleListToIdentifierList(List)->
      lists:map(fun({c_var,[],A})->toksFuncBody(noreturn,{c_var,[],A}) end,List).
  
  
  
  
negative.code: 
  %Parse the function body
  
  parseFunctionBody(return,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Params})->
      %io:format("        call function ~s:~s(", [Module, FunctionName]),
      %io:format("~p)~n", [tupleList_getVars_3(Params)]);
      esast:returnStatement(parseFunctionBody(noreturn,{c_call, A, {B, C, Module}, {D, E, FunctionName}, Params}));
  
  
  
  