anchor.diff:      ['if',Test,?Q(true),exp_cond(Cond)];
   exp_cond([]) -> ?Q(false).
   
  +%% exp_do(DoBody) -> DoLoop.
  +%%  Expand a do body into a loop. Add a variable 'do-state' which is
  +%%  the value of the do body which can be used when setting new values
  +%%  to do vars.
  +
  +exp_do([Pars,[Test,Ret]|Body], St0) ->
  +    {Vs,Is,Cs} = foldr(fun ([V,I,C], {Vs,Is,Cs}) -> {[V|Vs],[I|Is],[C|Cs]} end,
  +                       {[],[],[]}, Pars),
  +    {Fun,St1} = new_fun_name("do", St0),
  +    Exp = ['letrec-function',
  +           [[Fun,[lambda,Vs,
  +                  ['if',Test,Ret,
  +		   ['let',[['do-state',
  +			    ['progn'] ++ Body]],
  +		    [Fun|Cs]]]]]],
  +	   [Fun|Is]],
  +    {Exp,St1}.
  +
   %% exp_andalso(AndAlsoBody) -> Ifs.
   %% exp_orelse(OrElseBody) -> Ifs.
   
  
positive.code:     Exp = exp_cond(Cbody),
      {yes,Exp,St};
  exp_predef(['do'|Dbody], _, St0) ->
      %% (do ((v i c) ...) (test val) . body) but of limited use as it
      %% stands as we have to everything in new values.
      [Pars,[Test,Ret]|B] = Dbody,                %Check syntax
      {Vs,Is,Cs} = foldr(fun ([V,I,C], {Vs,Is,Cs}) -> {[V|Vs],[I|Is],[C|Cs]} end,
                         {[],[],[]}, Pars),
      {Fun,St1} = new_fun_name("do", St0),
      Exp = ['letrec-function',
             [[Fun,[lambda,Vs,
                    ['if',Test,Ret,
                     ['progn'] ++ B ++ [[Fun|Cs]]]]]],
             [Fun|Is]],
      {yes,Exp,St1};
  exp_predef([lc|Lbody], _, St0) ->
      %% (lc (qual ...) e ...)
  
negative.code:     B = foldl(fun ([V,_], Acc) -> exp_bif(Op, [Acc,V]) end, hd(hd(Ls)), tl(Ls)),
      {exp_let_star([Ls,B]),St1}.
  
  %% exp_logical(Args, Op State) -> {Exp,State}.
  %%  Expand logical call forcing evaluation of all arguments but not
  %%  strictly; this guarantees expansion is hygenic.  Note that single
  %%  argument version may need special casing.
  
  exp_logical([A], Op, St) -> {exp_bif(Op, [A,?Q(true)]),St};
  exp_logical([A,B], Op, St) -> {exp_bif(Op, [A,B]),St};
  exp_logical(As, Op, St0) ->
      {Ls,St1} = exp_args(As, St0),
      B = foldl(fun ([V,_], Acc) -> exp_bif(Op, [Acc,V]) end, hd(hd(Ls)), tl(Ls)),
      {['let',Ls,B],St1}.
  
  %% exp_comp(Args, Op, State) -> {Exp,State}.
  %%  Expand comparison test strictly forcing evaluation of all
  %%  arguments. Note that single argument version may need special
  