anchor.diff:          false -> {{call,L,{atom,L,F},Eas},St1}
       end;
   to_expr(List, L, _, St) ->
  -    case is_integer_list(List) of
  +    case is_posint_list(List) of
           true -> {{string,L,List},St};
           false ->
  -            io:format("BOOM:~p\n", [List]),
  -            {integer,L,4711}                    %Not right!
  +            error({illegal_code,List})          %Not right!
       end.
   
   to_expr_var(V, L, Vt, St) ->
  
positive.code:     {[Et|Eqs],Vt1,St2};
  to_lc_quals([], _, Vt, St) -> {[],Vt,St}.
  
  %% to_bitsegs(Segs, LineNumber, VarTable, State) -> {Segs,State}.
  %% This gives a verbose value, but it is correct.
  
  to_bitsegs(Ss, L, Vt, St) ->
      Fun = fun (S, St0) -> to_bitseg(S, L, Vt, St0) end,
      mapfoldl(Fun, St, Ss).
  
  to_bitseg([Val|Specs]=F, L, Vt, St) ->
      case is_integer_list(F) of
          true ->
              {Size,Type} = to_bitspecs([]),
              to_bin_element(F, Size, Type, L, Vt, St);
          false ->
              {Size,Type} = to_bitspecs(Specs),
              to_bin_element(Val, Size, Type, L, Vt, St)
      end;
  to_bitseg(Val, L, Vt, St) ->
      {Size,Type} = to_bitspecs([]),
      to_bin_element(Val, Size, Type, L, Vt, St).
  
  to_bin_element(Val, Size, {Type,Unit,Sign,End}, L, Vt, St0) ->
      {Eval,St1} = to_expr(Val, L, Vt, St0),
      {Esiz,St2} = to_bin_size(Size, L, Vt, St1),
      {{bin_element,L,Eval,Esiz,[Type,to_bin_unit(Unit),Sign,End]},St2}.
  
  to_bin_size(default, _, _, St) -> {default,St};
  to_bin_size(undefined, _, _, St) -> {default,St};
  to_bin_size(Size, L, Vt, St) -> to_expr(Size, L, Vt, St).
  
  to_bin_unit(default) -> default;
  to_bin_unit(Unit) -> {unit,Unit}.
  
  %% to_bitspec(Specs) -> {Size,Type}.
  %%  Get the error handling as we want it.
  
  to_bitspecs(Ss) ->
      case lfe_bits:get_bitspecs(Ss) of
          {ok,Sz,Ty} -> {Sz,Ty};
          {error,Error} -> erlang:error(Error)
      end.
  
  %% to_map_pairs(Pairs, LineNumber, VarTable, State) -> {Fields,State}.
  
  to_map_pairs([K,V|Ps], Field, L, Vt, St0) ->
      {Ek,St1} = to_expr(K, L, Vt, St0),
      {Ev,St2} = to_expr(V, L, Vt, St1),
      {Eps,St3} = to_map_pairs(Ps, Field, L, Vt, St2),
      {[{Field,L,Ek,Ev}|Eps],St3};
  to_map_pairs([], _, _, _, St) -> {[],St}.
  
  new_to_var(#to{vc=C}=St) ->
      V = list_to_atom(lists:concat(["___",C,"___"])),
      {V,St#to{vc=C+1}}.
  
negative.code: from_pat({bin,_,Segs}, Vt0, St0) ->
      {Ss,Eqt,Vt1,St1} = from_pat_bitsegs(Segs, Vt0, St0),
      {[binary|Ss],Eqt,Vt1,St1};
  from_pat({map,_,Assocs}, Vt0, St0) ->
      {Ps,Eqt,Vt1,St1} = from_pat_map_assocs(Assocs, Vt0, St0),
      {[map|Ps],Eqt,Vt1,St1};
  from_pat({record,_,R,Fs}, Vt0, St0) ->          %Match a record
      MR = list_to_atom("match-" ++ atom_to_list(R)),
      {Sfs,Eqt,Vt1,St1} = from_pat_rec_fields(Fs, Vt0, St0),
  