anchor.diff:  
   debug_print(Format, Args, Opts) ->
       case member(debug_print, Opts) of
  -    true -> io:fwrite(Format, Args);
  -    false -> ok
  +        true -> io:fwrite(Format, Args);
  +        false -> ok
       end.
   
   return_status(#lint{errors=[]}=St) ->
  
positive.code: 
  check_fbindings(Fbs0, St0) ->
      AddFb = fun(F, Fs, L, St) ->
              case member(F, Fs) of
              true -> {Fs,add_error(L, {redef_fun,F}, St)};
              false -> {add_element(F, Fs),St}
              end
          end,
      Check = fun ({V,[lambda,Args|_],L}, {Fs,St}) ->
              case is_symb_list(Args) of
              true -> AddFb({V,length(Args)}, Fs, L, St);
              false -> {Fs,bad_form_error(L, lambda, St)}
              end;
          ({V,['match-lambda',[Pats|_]|_],L}, {Fs,St}) ->
              case is_proper_list(Pats) of
              true -> AddFb({V,length(Pats)}, Fs, L, St);
              false -> {Fs,bad_form_error(L, 'match-lambda', St)}
              end;
          (_, Acc) -> Acc            %Error here flagged later
          end,
      foldl(Check, {[],St0}, Fbs0).
  
  %% check_if(IfBody, Env, Line, State) -> State.
  
negative.code:     {[],check_mdef(Mdef, L, St)};
  collect_form(['define-function',Func,Body], L, St) ->
      case Body of
          [lambda|_] when is_atom(Func) ->
              {[{Func,Body,L}],St};
          ['match-lambda'|_] when is_atom(Func) ->
              {[{Func,Body,L}],St};
          _ -> {[],bad_form_error(L, 'define-function', St)}
      end;
  collect_form(_, L, St) ->
      {[],add_error(L, unknown_form, St)}.
  
  check_mdef([[export,all]|Mdef], L, St) ->       %Pass 'all' along
      check_mdef(Mdef, L, St#lint{exps=all});
  check_mdef([[export|Es]|Mdef], L, St) ->
      case is_flist(Es) of
          {yes,Fs} ->
              Exps = add_exports(St#lint.exps, Fs),
              check_mdef(Mdef, L, St#lint{exps=Exps});
          no ->
              check_mdef(Mdef, L, bad_mdef_error(L, export, St))
      end;
  check_mdef([[import|Is]|Mdef], L, St0) ->
      St1 = check_imports(Is, L, St0),
      check_mdef(Mdef, L, St1);
  check_mdef([[extends,M]|Mdef], L, St) ->
      if is_atom(M) ->
              check_mdef(Mdef, L, St#lint{extd=M});
         true ->
              check_mdef(Mdef, L, add_error(L, bad_extends, St))
      end;
  check_mdef([[Name|Vals]|Mdef], L, St) ->
      %% Other attributes, must be list and have symbol name.
      case is_atom(Name) and is_proper_list(Vals) of
          true -> check_mdef(Mdef, L, St);
          false -> check_mdef(Mdef, L, add_error(L, {bad_attribute,Name}, St))
      end;
  check_mdef([], _, St) -> St;
  check_mdef(_, L, St) -> bad_mdef_error(L, form, St).
  