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:     Predefs0 = [{module_info,[lambda,[],?Q(dummy)],1},
                  {module_info,[lambda,[x],?Q(dummy)],1}],
      Exps0 = [{module_info,0},{module_info,1}],
      {Predefs0,Env0,St#lint{exps=add_exports(St#lint.exps, Exps0)}}.
  
  %% check_functions(FuncBindings, Env, State) -> {Funcs,Env,State}.
  %%  Check the top-level functions definitions. These have the format
  
negative.code: 
  bit_size(all, {Ty,_,_,_}, _, L, St, _) ->
      if Ty =:= binary -> St;
         true -> illegal_bitsize_error(L, St)
      end;
  bit_size(undefined, {Ty,_,_,_}, _, L, St, _) ->
      if Ty =:= utf8; Ty =:= utf16; Ty =:= utf32 -> St;
         true -> illegal_bitsize_error(L, St)
      end;
  bit_size(Sz, _, Env, L, St, Check) -> Check(Sz, Env, L, St).
  
  