anchor.diff:  		      {ok, Form} = refac_parse:parse_form(Toks2),
   		      [Form1] = refac_syntax:form_list_elements(
   				  refac_recomment:recomment_forms([Form], [])),
  -		      {Form2, _, _} = vann_function_1(Form1, Env, Ms, []),
  +		      {Form2, _, _} = vann_function_1(Form1, Env, Ms, [], Pid),
   		      get_var_info(Form2)
   		end
   	end,
       {Tree2, Bound, Free} = try
   			     F()
   			   of
  -			     VI -> vann_function_1(Tree1, Env, Ms, VI)
  +			     VI -> vann_function_1(Tree1, Env, Ms, VI, Pid)
   			   catch
  -			     _E1:_E2_ -> vann_function_1(Tree1, Env, Ms, [])
  +			     _E1:_E2_ -> vann_function_1(Tree1, Env, Ms, [], Pid)
   			   end,
       {update_var_define_locations(Tree2), Bound, Free}.
       
   
  -vann_function_1(Tree, Env, Ms, VI) ->
  +vann_function_1(Tree, Env, Ms, VI, Pid) ->
       Cs = refac_syntax:function_clauses(Tree),
  -    {Cs1, {_, Free}} = vann_clauses(Cs, Env, Ms, VI),
  +    {Cs1, {_, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
       N = refac_syntax:function_name(Tree),
  -    {N1, _, _} = vann(N, Env, Ms, VI),
  +    {N1, _, _} = vann(N, Env, Ms, VI, Pid),
       Tree1 = rewrite(Tree, refac_syntax:function(N1, Cs1)),
       Bound = [],
       {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
   
  -vann_rule(Tree, Env, Ms, VI) ->
  +vann_rule(Tree, Env, Ms, VI, Pid) ->
       Cs = refac_syntax:rule_clauses(Tree),
  -    {Cs1, {_, Free}} = vann_clauses(Cs, Env, Ms, VI),
  +    {Cs1, {_, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
       N = refac_syntax:rule_name(Tree),
  -    {N1, _, _} = vann(N, Env, Ms, VI),
  +    {N1, _, _} = vann(N, Env, Ms, VI, Pid),
       Tree1 = rewrite(Tree, refac_syntax:rule(N1, Cs1)),
       Bound = [],
       {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
   
  -vann_fun_expr(Tree, Env, Ms, VI) ->
  +vann_fun_expr(Tree, Env, Ms, VI, Pid) ->
       Cs = refac_syntax:fun_expr_clauses(Tree),
  -    {Cs1, {_, Free}} = vann_fun_expr_clauses(Cs, Env, Ms, VI),
  +    {Cs1, {_, Free}} = vann_fun_expr_clauses(Cs, Env, Ms, VI, Pid),
       Tree1 = rewrite(Tree, refac_syntax:fun_expr(Cs1)),
       Bound = [],
       {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
   
  -vann_match_expr(Tree, Env, Ms, VI) ->
  +vann_match_expr(Tree, Env, Ms, VI, Pid) ->
       E = refac_syntax:match_expr_body(Tree),
  -    {E1, Bound1, Free1} = vann(E, Env, Ms, VI),
  +    {E1, Bound1, Free1} = vann(E, Env, Ms, VI, Pid),
       Env1 = ordsets:union(Env, Bound1),
       P = refac_syntax:match_expr_pattern(Tree),
  -    {P1, Bound2, Free2} = vann_pattern(P, Env1, Ms, VI),
  +    {P1, Bound2, Free2} = vann_pattern(P, Env1, Ms, VI, Pid),
       Bound = ordsets:union(Bound1, Bound2),
       Free = ordsets:union(Free1, Free2),
       Tree1 = rewrite(Tree, refac_syntax:match_expr(P1, E1)),
       Tree2 =ann_bindings(Tree1, Env, Bound, Free), 
  -    Tree3=constant_propagate(Tree2),
  +    Tree3=constant_propagate(Tree2, Pid),
       {Tree3, Bound, Free}.
   
  -vann_case_expr(Tree, Env, Ms, VI) ->
  +vann_case_expr(Tree, Env, Ms, VI, Pid) ->
       E = refac_syntax:case_expr_argument(Tree),
  -    {E1, Bound1, Free1} = vann(E, Env, Ms, VI),
  +    {E1, Bound1, Free1} = vann(E, Env, Ms, VI, Pid),
       Env1 = ordsets:union(Env, Bound1),
       Cs = refac_syntax:case_expr_clauses(Tree),
  -    {Cs1, {Bound2, Free2}} = vann_clauses(Cs, Env1, Ms, VI),
  +    {Cs1, {Bound2, Free2}} = vann_clauses(Cs, Env1, Ms, VI, Pid),
       Bound = ordsets:union(Bound1, Bound2),
       Free = ordsets:union(Free1, Free2),
       Tree1 = rewrite(Tree, refac_syntax:case_expr(E1, Cs1)),
       {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
   
  -vann_if_expr(Tree, Env, Ms, VI) ->
  +vann_if_expr(Tree, Env, Ms, VI, Pid) ->
       Cs = refac_syntax:if_expr_clauses(Tree),
  -    {Cs1, {Bound, Free}} = vann_clauses(Cs, Env, Ms, VI),
  +    {Cs1, {Bound, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
       Tree1 = rewrite(Tree, refac_syntax:if_expr(Cs1)),
       {ann_bindings(Tree1, Env, Bound, Free), Bound, Free}.
   
  -vann_cond_expr(Tree, Env, _Ms, _VI) ->
  +vann_cond_expr(Tree, Env, _Ms, _VI, _Pid) ->
       {ann_bindings(Tree, Env, [], []), [],[]}.   %% TODO: NEED TO CHANGE THIS BACK.
       %% erlang:error({not_implemented, cond_expr}).
   
  -vann_try_expr(Tree, Env, Ms, VI) ->  
  +vann_try_expr(Tree, Env, Ms, VI, Pid) ->  
       Body = refac_syntax:try_expr_body(Tree),
  -    {Body1, {Bound1, Free1}} = vann_body(Body, Env, Ms, VI),
  +    {Body1, {Bound1, Free1}} = vann_body(Body, Env, Ms, VI, Pid),
       Cs = refac_syntax:try_expr_clauses(Tree),
       {Cs1, {Bound2, Free2}} = case Cs of 
   				 [] -> {Cs, {[], []}};
  -				 _ -> vann_clauses(Cs, Env, Ms, VI)
  +				 _ -> vann_clauses(Cs, Env, Ms, VI, Pid)
   			     end,
       Handlers = refac_syntax:try_expr_handlers(Tree),
       {Handlers1, {Bound3, Free3}} = case Handlers of 
   				       [] -> {Handlers, {[],[]}};
  -				       _  ->vann_clauses(Handlers,Env, Ms, VI)
  +				       _  ->vann_clauses(Handlers,Env, Ms, VI, Pid)
   				   end,
       After = refac_syntax:try_expr_after(Tree),
       {After1, {Bound4, Free4}} = case After of 
   				    [] -> {After, {[],[]}};
  -				    _  -> vann_body(After, Env, Ms, VI)
  +				    _  -> vann_body(After, Env, Ms, VI, Pid)
   				end,
       Tree1 = rewrite(Tree, refac_syntax:try_expr(Body1, Cs1, Handlers1, After1)),
       Bound = ordsets:union(ordsets:union(ordsets:union(Bound1, Bound2), Bound3),Bound4),
       Free  = ordsets:union(ordsets:union(ordsets:union(Free1, Free2), Free3),Free4),
       {ann_bindings(Tree1, Env, Bound, Free), Bound,Free}.    
   
  -vann_receive_expr(Tree, Env, Ms, VI) ->
  +vann_receive_expr(Tree, Env, Ms, VI, Pid) ->
       %% The timeout action is treated as an extra clause.
       %% Bindings in the expiry expression are local only.
       Cs = refac_syntax:receive_expr_clauses(Tree),
       Es = refac_syntax:receive_expr_action(Tree),
       case Es of 
   	[] ->
  -	    {Cs1,{Bound, Free}} = vann_clauses(Cs, Env, Ms, VI),
  +	    {Cs1,{Bound, Free}} = vann_clauses(Cs, Env, Ms, VI, Pid),
   	    Tree1 = rewrite(Tree, refac_syntax:receive_expr(Cs1, none, [])),
   	    {ann_bindings(Tree1, Env, Bound, Free), Bound, Free};
   	_ ->
   	    C = refac_syntax:clause([], Es),
   	    {[C1 | Cs1], {Bound, Free1}} = vann_clauses([C | Cs],
  -							Env, Ms, VI),
  +							Env, Ms, VI, Pid),
   	    Es1 = refac_syntax:clause_body(C1),
   	    {T1, _, Free2} = case
   		       refac_syntax:receive_expr_timeout(Tree)
   			 of
   		       none -> {none, [], []};
  -		       T -> vann(T, Env, Ms, VI)
  +		       T -> vann(T, Env, Ms, VI, Pid)
   		     end,
   	    Free = ordsets:union(Free1, Free2),
   	    Tree1 = rewrite(Tree,
  
positive.code: 		{value, {free, Free1}} = lists:keysearch(free, 1, As),
  		{value, {def, Def1}} = lists:keysearch(def, 1, As),
  		{value, {env, Env1}} = lists:keysearch(env, 1, As),
  		case get_value(Def1) of
  		  {value, Val} ->
  		      Tree1 = ann_bindings(Tree, Env1, Bound1, Free1, Def1),
  		      Tree2 = update_ann(Tree1, {value, Val}),
  
negative.code: 	case refac_syntax:type(MacroHead) of 
  	    application -> Operator = refac_syntax:application_operator(MacroHead),
  			   Arguments = refac_syntax:application_arguments(MacroHead),
  			   {Operator1, Bs1, _Fs1} = vann_pattern(Operator, Env, Ms, VI, Pid),
  			   {Arguments1, {Bs2, _Fs2}} = vann_patterns(Arguments, Env, Ms, VI, Pid), 
  	                   %%Bs3= ordsets:union(Bs1, Bs2),
  			   H = rewrite(MacroHead, refac_syntax:application(Operator1, Arguments1)),
  			   %%{{ann_bindings(H, Env, Bs3, []), Bs3, []}, Bs1};
  			   {{ann_bindings(H, Env, Bs2, []), Bs2, []}, Bs1};
  	    _  -> {vann_pattern(MacroHead, Env, Ms, VI, Pid),[]}
  	end,
      Env1 = ordsets:union(Env, Bound),
      {MacroBody1, {_Bound1, _Free1}} = vann_body(MacroBody, Env1, Ms, VI, Pid),
      MacroBody2 = adjust_define_body(MacroBody1, Env1),
      D1 = rewrite(D, refac_syntax:attribute(Name, [MacroHead1| MacroBody2])),
      {ann_bindings(D1, Env, [], []), [], []}.   
  