anchor.diff:  format_error(bad_funcs) -> "bad function list";
   format_error(bad_body) -> "bad body";
   format_error(bad_clause) -> "bad clause";
  -format_error(bad_args) -> "bad arguments";
  -format_error(bad_gargs) -> "bad guard arguments";
  -format_error(bad_alias) -> "bad alias";
  +format_error(bad_guard) -> "bad guard";
  +format_error(bad_args) -> "bad argument list";
  +format_error(bad_gargs) -> "bad guard argument list";
  +format_error(bad_alias) -> "bad pattern alias";
   format_error(bad_arity) -> "head arity mismatch";
   format_error({bad_attribute,A}) ->
       lfe_io:format1("bad attribute: ~w", [A]);
   format_error({bad_meta,M}) ->
       lfe_io:format1("bad metadata: ~w", [M]);
   format_error({bad_form,Type}) ->
  -    lfe_io:format1("bad form: ~w", [Type]);
  +    lfe_io:format1("bad ~w form", [Type]);
   format_error({bad_gform,Type}) ->
  -    lfe_io:format1("bad guard form: ~w", [Type]);
  +    lfe_io:format1("bad ~w guard form", [Type]);
   format_error({bad_pat,Type}) ->
  -    lfe_io:format1("bad pattern: ~w", [Type]);
  +    lfe_io:format1("bad ~w pattern", [Type]);
   format_error({unbound_symb,S}) ->
  -    lfe_io:format1("unbound symbol: ~w", [S]);
  -format_error({unbound_func,F}) ->
  -    lfe_io:format1("unbound function: ~w", [F]);
  +    lfe_io:format1("symbol ~w unbound", [S]);
  +format_error({undefined_func,F}) ->
  +    lfe_io:format1("function ~w undefined", [F]);
   format_error({multi_var,S}) ->
  -    lfe_io:format1("multiple variable: ~w", [S]);
  +    lfe_io:format1("variable ~w multiply defined", [S]);
   format_error({redef_fun,F}) ->
  -    lfe_io:format1("redefining function: ~w", [F]);
  +    lfe_io:format1("redefining function ~w", [F]);
   format_error({bad_fdef,F}) ->
  -    lfe_io:format1("bad function definition: ~w", [F]);
  +    lfe_io:format1("bad definition of function ~w", [F]);
   format_error({illegal_literal,Lit}) ->
  -    lfe_io:format1("illegal literal value: ~w", [Lit]);
  +    lfe_io:format1("illegal literal value ~w", [Lit]);
   format_error({illegal_pattern,Pat}) ->
  -    lfe_io:format1("illegal pattern: ~w", [Pat]);
  +    lfe_io:format1("illegal pattern ~w", [Pat]);
   format_error(illegal_guard) -> "illegal guard";
  -format_error(illegal_bitseg) -> "illegal bit segment";
   format_error({illegal_mapkey,Key}) ->
  -    lfe_io:format1("illegal map key: ~w", [Key]);
  +    lfe_io:format1("illegal map key ~w", [Key]);
   format_error({undefined_bittype,S}) ->
       lfe_io:format1("bit type ~w undefined", [S]);
   format_error(bittype_unit) ->
       "bit unit size can only be specified together with size";
  +format_error(illegal_bitseg) -> "illegal bit segment";
   format_error(illegal_bitsize) -> "illegal bit size";
   format_error({deprecated,What}) ->
       lfe_io:format1("deprecated: ~s", [What]);
  
positive.code: 
  %% We do a lot of quoting!
  -define(Q(E), [quote,E]).
  
  -record(lint, {module=[],                       %Module name
                 exps=[],                         %Exports
                 imps=[],                         %Imports
                 pref=[],                         %Prefixes
                 funcs=[],                        %Defined functions
                 types=[],                        %Known types
                 specs=[],                        %Known func specs
                 env=[],                          %Top-level environment
                 lline=[],                        %Last line
                 func=[],                         %Current function
                 file="nofile",                   %File name
                 opts=[],                         %Compiler options
  
negative.code: multi_var_error(L, V, St) ->
      add_error(L, {multi_var,V}, St).
  
  undefined_func_error(L, F, St) ->
      add_error(L, {undefined_func,F}, St).
  
  illegal_guard_error(L, St) ->
      add_error(L, illegal_guard, St).
  