anchor.diff:      %% structure.
       {Eqs,St1} = exp_qlc_quals(Qs, Env, St0),
       {Ees,St2} = exp_list(Es, Env, St1),
  -    %%lfe_io:format("Q0 = ~p\n", [[lc,Eqs|Ees]]),
  +    lfe_io:format("Q0 = ~p\n", [[lc,Eqs|Ees]]),
       %% Now translate to vanilla AST, call qlc expand and then convert
       %% back to LFE.  lfe_qlc:expand/2 wants a list of conversions not
       %% a conversion of a list.
       Vlc = lfe_trans:to_expr([lc,Eqs|Ees], 42),
       Vos = map(fun (O) -> lfe_trans:to_expr(O, 42) end, Opts),
  -    %% io:put_chars([erl_pp:expr(Vlc),"\n"]),
  +    io:put_chars(["E0 = ",erl_pp:expr(Vlc, 5, []),"\n"]),
       {ok,Vexp} = lfe_qlc:expand(Vlc, Vos),
  -    %%io:put_chars([erl_pp:expr(Vexp),"\n"]),
  +    io:put_chars(["E1a = ",erl_pp:expr(Vexp, 6, []),"\n"]),
  +    {ok,Vexp1} = lfe_q:expand(Vlc, Vos),
  +    io:put_chars(["E1b = ",erl_pp:expr(Vexp1, 6, []),"\n"]),
       Exp = lfe_trans:from_expr(Vexp),
  -    %%lfe_io:format("Q1 = ~p\n", [Exp]),
  +    %% lfe_io:format("Q1 = ~p\n", [Exp]),
       {yes,Exp,St2}.
   
   exp_qlc_quals(Qs, Env, St) ->
  
positive.code: exp_predef([Fun|As], _, St) when is_atom(Fun) ->
      case string:tokens(atom_to_list(Fun), ":") of
          [M,F] ->
              {yes,[call,?Q(list_to_atom(M)),?Q(list_to_atom(F))|As],St};
          _ -> no                                 %This will also catch a:b:c
      end;
  %% This was not a call to a predefined macro.
  
negative.code: 
  exp_macro([Name|_]=Call, Env, St) ->
      case lfe_lib:is_core_form(Name) of
          true -> no;                             %Never expand core forms
          false ->
              case get_mbinding(Name, Env) of
                  {yes,Def} ->
                      %% User macro bindings.
                      exp_userdef_macro(Call, Def, Env, St);
                  no ->
                      %% Default macro bindings.
                      exp_predef_macro(Call, Env, St)
              end
      end.
  
  %% exp_userdef_macro(Call, Def, Env, State) -> {yes,Exp,State}.
  