anchor.diff:      {Cvs,St1} = new_c_vars(Ar, L, St0),
       {Ccs,St2} = comp_match_clauses(Cls, Env, L, St1),
       {Fvs,St3} = new_c_vars(Ar, L, St2),
  -    Cf = fail_clause(Fvs,c_tuple([c_atom(function_clause)|Fvs]), L, St3),
  +    Cf = func_fail(Fvs, L, St3),
       Cb = c_case(c_values(Cvs), Ccs ++ [Cf], [L]),
       {c_fun(Cvs, Cb, [L,{file,St3#cg.file}]),St3}.
   
  +func_fail(Fvs, L, #cg{func=F}=St) ->
  +    %% We need function_name anno to generate function_clause error.
  +    fail_clause(Fvs, c_tuple([c_atom(function_clause)|Fvs]),
  +                [{function_name,F}], L, St).
  +
   %% match_lambda_arity(MatchClauses) -> int().
   
   match_lambda_arity([[Pats|_]|_]) -> length(Pats).
   
   comp_match_clauses(Cls, Env, L, St) ->
       mapfoldl(fun (Cl, Sta) -> comp_match_clause(Cl, Env, L, Sta) end,
  -         St, Cls).
  +             St, Cls).
   
   %% comp_match_clause(Clause, Env, L, State) -> {#c_clause{},State}.
   %% (Pats [(when Guard)] . Body)
  
positive.code: 
  try_case_fail(L, St) ->
      Cv = c_var(omega),
      fail_clause([Cv], c_tuple([c_atom(try_clause),Cv]), L, St).
  
  %% try_exception(CatchClauses, Env, L, State) -> {Vars,#c_case{},State}.
  
  
negative.code:              atts=[],                           %Attrubutes
               defs=[],                           %Function definitions.
               env=[],                            %Environment
               anno=[],                           %Current annotation
               opts=[],                           %Options
               file=[],                           %File name
               func=[],                           %Current function
               line=0,                            %Current line
               vc=0,                              %Variable counter
               fc=0                               %Function counter
              }).
  