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: from_expr({'catch',_,E}, Vt0, St0) ->
      {Le,Vt1,St1} = from_expr(E, Vt0, St0),
      {['catch',Le],Vt1,St1};
  from_expr({match,_,P,E}, Vt0, St0) ->
      {Lp,Eqt,Vt1,St1} = from_pat(P, Vt0, St0),   %The pattern
      {Le,Vt2,St2} = from_expr(E, Vt1, St1),      %The expression
      {Lb,Vt3,St3} = from_expr(P, Vt2, St2),      %Pattern as value expression
      Leg = from_eq_tests(Eqt),                   %Implicit guard tests
      {['let',[[Lp,['when'|Leg],Le]],Lb],Vt3,St3};
  from_expr({op,_,Op,A}, Vt0, St0) ->
      {La,Vt1,St1} = from_expr(A, Vt0, St0),
      {[Op,La],Vt1,St1};
  
negative.code:     {[F,Le|Lfs],Vt2,St2};
  from_rec_fields([], Vt, St) -> {[],Vt,St}.
  
  %% from_package_module(Module, VarTable, State) -> {Module,VarTable,State}.
  %%  We must handle the special case where in pre-R16 you could have
  %%  packages with a dotted module path. It used a special record_field
  %%  tuple. This does not work in R16 and later!
  
  from_package_module({record_field,_,_,_}=M, Vt, St) ->
      Segs = erl_parse:package_segments(M),
      A = list_to_atom(packages:concat(Segs)),
      {?Q(A),Vt,St}.
  
  from_maybe(_, []) -> [];
  from_maybe(Tag, Es) -> [[Tag|Es]].
  
  %% new_from_var(State) -> {VarName,State}.
  %% new_from_vars(Count, State) -> {VarNames,State}.
  
  new_from_var(#from{vc=C}=St) ->
      V = list_to_atom(lists:concat(['-var-',C,'-'])),
      {V,St#from{vc=C+1}}.
  
  new_from_vars(N, St) -> new_from_vars(N, St, []).
  