Merge branch 'hb/bif_specs/OTP-9862'

* hb/bif_specs/OTP-9862:
  Move types and specs from erl_bif_types.erl to modules

31 files changed, 1662 insertions, 2118 deletions

diff --git a/erts/preloaded/ebin/prim_file.beam b/erts/preloaded/ebin/prim_file.beam
index 87e80aae9b..a4c454bbf7 100644
--- a/erts/preloaded/ebin/prim_file.beam
+++ b/erts/preloaded/ebin/prim_file.beam
diff --git a/erts/preloaded/src/prim_file.erl b/erts/preloaded/src/prim_file.erl
index 36cbe329e8..fcf94c5fa2 100644
--- a/erts/preloaded/src/prim_file.erl
+++ b/erts/preloaded/src/prim_file.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2000-2011. All Rights Reserved.
+%% Copyright Ericsson AB 2000-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -147,6 +147,32 @@
 -define(POSIX_FADV_NOREUSE,    5).
 
 
+%%% BIFs
+
+-export([internal_name2native/1,
+         internal_native2name/1,
+         internal_normalize_utf8/1]).
+
+-type unicode_string() :: [unicode:unicode_char()].
+-type prim_file_name() :: unicode_string() | unicode:unicode_binary().
+
+-spec internal_name2native(prim_file_name()) -> binary().
+
+internal_name2native(_) ->
+    erlang:nif_error(undefined).
+
+-spec internal_native2name(binary()) -> prim_file_name().
+
+internal_native2name(_) ->
+    erlang:nif_error(undefined).
+
+-spec internal_normalize_utf8(unicode:unicode_binary()) -> unicode_string().
+
+internal_normalize_utf8(_) ->
+    erlang:nif_error(undefined).
+
+%%% End of BIFs
+
 %%%-----------------------------------------------------------------
 %%% Functions operating on a file through a handle. ?FD_DRV.
 %%%
diff --git a/lib/dialyzer/test/r9c_SUITE_data/results/inets b/lib/dialyzer/test/r9c_SUITE_data/results/inets
index 24cb39e52b..0e8ddf5492 100644
--- a/lib/dialyzer/test/r9c_SUITE_data/results/inets
+++ b/lib/dialyzer/test/r9c_SUITE_data/results/inets
@@ -30,11 +30,11 @@ httpd_sup.erl:92: The variable Else can never match since previous clauses compl
 mod_auth.erl:559: The pattern {'error', Reason} can never match the type {_,integer(),maybe_improper_list(),_}
 mod_auth_dets.erl:120: The call lists:foreach(fun((_) -> 'true' | {'error','no_such_group' | 'no_such_group_member'}),{'ok',[any()]}) will never return since it differs in the 2nd argument from the success typing arguments: (fun((_) -> any()),[any()])
 mod_auth_plain.erl:100: The variable _ can never match since previous clauses completely covered the type {'ok',[any()]}
-mod_auth_plain.erl:159: The variable _ can never match since previous clauses completely covered the type [any()]
-mod_auth_plain.erl:83: The variable O can never match since previous clauses completely covered the type [any()]
+mod_auth_plain.erl:159: The variable _ can never match since previous clauses completely covered the type [[any()]]
+mod_auth_plain.erl:83: The variable O can never match since previous clauses completely covered the type [[any()]]
 mod_cgi.erl:372: The pattern {'http_response', NewAccResponse} can never match the type 'ok'
 mod_dir.erl:101: The call lists:flatten(nonempty_improper_list(atom() | [any()] | char(),atom())) will never return since it differs in the 1st argument from the success typing arguments: ([any()])
-mod_dir.erl:72: The pattern {'error', Reason} can never match the type {'ok',[[[any()] | char()],...]}
+mod_dir.erl:72: The pattern {'error', Reason} can never match the type {'ok',[[[any()] | non_neg_integer()],...]}
 mod_get.erl:135: The pattern <{'enfile', _}, _Info, Path> can never match the type <atom(),#mod{},atom() | binary() | [atom() | [any()] | char()]>
 mod_head.erl:80: The pattern <{'enfile', _}, _Info, Path> can never match the type <atom(),#mod{},atom() | binary() | [atom() | [any()] | char()]>
 mod_htaccess.erl:460: The pattern {'error', BadData} can never match the type {'ok',_}
@@ -46,9 +46,9 @@ mod_include.erl:692: The pattern <{'read', Reason}, Info, Path> can never match
 mod_include.erl:706: The pattern <{'enfile', _}, _Info, Path> can never match the type <atom(),#mod{},atom() | binary() | [atom() | [any()] | char()]>
 mod_include.erl:716: Function read_error/3 will never be called
 mod_include.erl:719: Function read_error/4 will never be called
-mod_security_server.erl:386: The variable O can never match since previous clauses completely covered the type [any()]
-mod_security_server.erl:433: The variable Other can never match since previous clauses completely covered the type [any()]
-mod_security_server.erl:585: The variable _ can never match since previous clauses completely covered the type [any()]
-mod_security_server.erl:608: The variable _ can never match since previous clauses completely covered the type [any()]
-mod_security_server.erl:641: The variable _ can never match since previous clauses completely covered the type [any()]
+mod_security_server.erl:386: The variable O can never match since previous clauses completely covered the type [tuple()]
+mod_security_server.erl:433: The variable Other can never match since previous clauses completely covered the type [tuple()]
+mod_security_server.erl:585: The variable _ can never match since previous clauses completely covered the type [tuple()]
+mod_security_server.erl:608: The variable _ can never match since previous clauses completely covered the type [tuple()]
+mod_security_server.erl:641: The variable _ can never match since previous clauses completely covered the type [tuple()]
 uri.erl:146: The pattern {'error', Error} can never match since previous clauses completely covered the type {_,{[],[]}}
diff --git a/lib/hipe/cerl/erl_bif_types.erl b/lib/hipe/cerl/erl_bif_types.erl
index cee399e861..71c83d9359 100644
--- a/lib/hipe/cerl/erl_bif_types.erl
+++ b/lib/hipe/cerl/erl_bif_types.erl
@@ -2,7 +2,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2003-2011. All Rights Reserved.
+%% Copyright Ericsson AB 2003-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -49,7 +49,6 @@
 		    t_boolean/0,
 		    t_byte/0,
 		    t_char/0,
-		    t_charlist/0,
 		    t_cons/0,
 		    t_cons/2,
 		    t_cons_hd/1,
@@ -120,8 +119,6 @@
 		    t_subtract/2,
 		    t_sup/1,
 		    t_sup/2,
-		    t_tid/0,
-		    t_timeout/0,
 		    t_tuple/0,
 		    t_tuple/1,
 		    t_tuple_args/1,
@@ -146,100 +143,6 @@ type(M, F, A) ->
 
 -spec type(atom(), atom(), arity(), [erl_types:erl_type()]) -> erl_types:erl_type().
 
-%%-- binary -------------------------------------------------------------------
-type(binary, at, 2, Xs) ->
-  strict(arg_types(binary, at, 2), Xs, fun(_) -> t_integer() end);
-type(binary, bin_to_list, Arity, Xs) when 1 =< Arity, Arity =< 3 ->
-  strict(arg_types(binary, bin_to_list, Arity), Xs,
-	 fun(_) -> t_list(t_integer()) end);
-type(binary, compile_pattern, 1, Xs) ->
-  strict(arg_types(binary, compile_pattern, 1), Xs,
-	 fun(_) -> t_binary_compiled_pattern() end);
-type(binary, copy, Arity, Xs)  when Arity =:= 1; Arity =:= 2 ->
-  strict(arg_types(binary, copy, Arity), Xs,
-	 fun(_) -> t_binary() end);
-type(binary, decode_unsigned, Arity, Xs)  when Arity =:= 1; Arity =:= 2 ->
-  strict(arg_types(binary, decode_unsigned, Arity), Xs,
-	 fun(_) -> t_non_neg_integer() end);
-type(binary, encode_unsigned, Arity, Xs)  when Arity =:= 1; Arity =:= 2 ->
-  strict(arg_types(binary, encode_unsigned, Arity), Xs,
-	 fun(_) -> t_binary() end);
-type(binary, first, 1, Xs) ->
-  strict(arg_types(binary, first, 1), Xs, fun(_) -> t_non_neg_integer() end);
-type(binary, last, 1, Xs) ->
-  strict(arg_types(binary, last, 1), Xs, fun(_) -> t_non_neg_integer() end);
-type(binary, list_to_bin, 1, Xs) ->
-  type(erlang, list_to_binary, 1, Xs);
-type(binary, longest_common_prefix, 1, Xs) ->
-  strict(arg_types(binary, longest_common_prefix, 1), Xs,
-	 fun(_) -> t_integer() end);
-type(binary, longest_common_suffix, 1, Xs) ->
-  strict(arg_types(binary, longest_common_suffix, 1), Xs,
-	 fun(_) -> t_integer() end);
-type(binary, match, Arity, Xs) when Arity =:= 2; Arity =:= 3 ->
-  strict(arg_types(binary, match, Arity), Xs,
-	 fun(_) ->
-	     t_sup(t_atom('nomatch'), t_binary_canonical_part())
-	 end);
-type(binary, matches, Arity, Xs) when Arity =:= 2; Arity =:= 3 ->
-  strict(arg_types(binary, matches, Arity), Xs,
-	 fun(_) -> t_list(t_binary_canonical_part()) end);
-type(binary, part, 2, Xs) ->
-  type(erlang, binary_part, 2, Xs);
-type(binary, part, 3, Xs) ->
-  type(erlang, binary_part, 3, Xs);
-type(binary, referenced_byte_size, 1, Xs) ->
-  strict(arg_types(binary, referenced_byte_size, 1), Xs,
-	 fun(_) -> t_non_neg_integer() end);
-%%-- code ---------------------------------------------------------------------
-type(code, get_chunk, 2, Xs) ->
-  strict(arg_types(code, get_chunk, 2), Xs,
-	 fun (_) -> t_sup(t_binary(), t_atom('undefined')) end);
-type(code, is_module_native, 1, Xs) ->
-  strict(arg_types(code, is_module_native, 1), Xs,
-	 fun (_) -> t_sup(t_boolean(), t_atom('undefined')) end);
-type(code, module_md5, 1, Xs) ->
-  strict(arg_types(code, module_md5, 1), Xs,
-	 fun (_) -> t_sup(t_binary(), t_atom('undefined')) end);
-type(code, make_stub_module, 3, Xs) ->
-  strict(arg_types(code, make_stub_module, 3), Xs, fun ([Mod,_,_]) -> Mod end);
-type(code, rehash, 0, _) ->
-  t_atom('ok');
-%%-- erl_ddll -----------------------------------------------------------------
-type(erl_ddll, demonitor, 1, Xs) ->
-  type(erlang, demonitor, 1, Xs);
-type(erl_ddll, format_error_int, 1, Xs) ->
-  strict(arg_types(erl_ddll, format_error_int, 1), Xs,
-	 fun (_) -> t_string() end);
-type(erl_ddll, info, 2, Xs) ->
-  strict(arg_types(erl_ddll, info, 2), Xs, fun (_) -> t_atom() end);
-type(erl_ddll, loaded_drivers, 0, _) ->
-  t_tuple([t_atom('ok'), t_list(t_string())]);
-type(erl_ddll, monitor, 2, Xs) -> % return type is the same, though args are not
-  type(erlang, monitor, 2, Xs);
-type(erl_ddll, try_load, 3, Xs) ->
-  strict(arg_types(erl_ddll, try_load, 3), Xs,
-	 fun (_) ->
-	     t_sup([t_tuple([t_atom('ok'), t_atom('already_loaded')]),
-		    t_tuple([t_atom('ok'), t_atom('loaded')]),
-		    t_tuple([t_atom('ok'),
-			     t_atom('pending_driver'), t_reference()]),
-		    t_tuple([t_atom('error'), t_atom('inconsistent')]),
-		    t_tuple([t_atom('error'), t_atom('permanent')])])
-	 end);
-type(erl_ddll, try_unload, 2, Xs) ->
-  strict(arg_types(erl_ddll, try_unload, 2), Xs,
-	 fun (_) ->
-	     t_sup([t_tuple([t_atom('ok'), t_atom('pending_process')]),
-		    t_tuple([t_atom('ok'), t_atom('unloaded')]),
-		    t_tuple([t_atom('ok'), t_atom('pending_driver')]),
-		    t_tuple([t_atom('ok'),
-			     t_atom('pending_driver'), t_reference()]),
-		    t_tuple([t_atom('error'), t_atom('permanent')]),
-		    t_tuple([t_atom('error'), t_atom('not_loaded')]),
-		    t_tuple([t_atom('error'),
-			     t_atom('not_loaded_by_this_process')])])
-	 end);
 %%-- erlang -------------------------------------------------------------------
 type(erlang, halt, 0, _) -> t_none();
 type(erlang, halt, 1, _) -> t_none();
@@ -1731,250 +1634,9 @@ type(erlang, whereis, 1, Xs) ->
   strict(arg_types(erlang, whereis, 1), Xs,
 	 fun (_) -> t_sup([t_pid(), t_port(), t_atom('undefined')]) end);
 type(erlang, yield, 0, _) -> t_atom('true');
-%%-- erl_prim_loader ----------------------------------------------------------
-type(erl_prim_loader, get_file, 1, Xs) ->
-  strict(arg_types(erl_prim_loader, get_file, 1), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_binary(), t_string()]),
-		   t_atom('error'))
-	 end);
-type(erl_prim_loader, get_path, 0, _) ->
-  t_tuple([t_atom('ok'), t_list(t_string())]);
-type(erl_prim_loader, set_path, 1, Xs) ->
-  strict(arg_types(erl_prim_loader, set_path, 1), Xs,
-	 fun (_) -> t_atom('ok') end);
-%%-- error_logger -------------------------------------------------------------
-type(error_logger, warning_map, 0, _) ->
-  t_sup([t_atom('info'), t_atom('warning'), t_atom('error')]);
-%%-- erts_debug ---------------------------------------------------------------
-type(erts_debug, breakpoint, 2, Xs) ->
-  strict(arg_types(erts_debug, breakpoint, 2), Xs, fun (_) -> t_fixnum() end);
-type(erts_debug, disassemble, 1, Xs) ->
-  strict(arg_types(erts_debug, disassemble, 1), Xs,
-	 fun (_) -> t_sup([t_atom('false'),
-			   t_atom('undef'),
-			   t_tuple([t_integer(), t_binary(), t_mfa()])]) end);
-type(erts_debug, display, 1, _) ->
-  t_string();
-type(erts_debug, dist_ext_to_term, 2, Xs) ->
-  strict(arg_types(erts_debug, dist_ext_to_term, 2), Xs,
-	 fun (_) -> t_any() end);
-type(erts_debug, dump_monitors, 1, Xs) ->
-  strict(arg_types(erts_debug, dump_monitors, 1), Xs,
-	 fun(_) -> t_atom('true') end);
-type(erts_debug, dump_links, 1, Xs) ->
-  strict(arg_types(erts_debug, dump_links, 1), Xs,
-	 fun(_) -> t_atom('true') end);
-type(erts_debug, flat_size, 1, Xs) ->
-  strict(arg_types(erts_debug, flat_size, 1), Xs, fun (_) -> t_integer() end);
-type(erts_debug, get_internal_state, 1, _) ->
-  t_any();
-type(erts_debug, instructions, 0, _) ->
-  t_list(t_list(t_byte()));
-type(erts_debug, lock_counters, 1, Xs) ->
-  strict(arg_types(erts_debug, lock_counters, 1), Xs,
-	 fun ([Arg]) ->
-	     case t_is_atom(Arg) of
-	       true ->
-		 case t_atom_vals(Arg) of
-		   ['enabled'] -> t_boolean();
-		   ['info'] -> t_any();
-		   ['clear'] -> t_atom(ok);
-		   _ -> t_sup([t_boolean(), t_any(), t_atom('ok')])
-		 end;
-	       false ->
-		 case t_is_tuple(Arg) of
-		   true -> t_boolean();
-		   false -> t_sup([t_boolean(), t_any(), t_atom('ok')])
-		 end
-	     end
-	 end);
-type(erts_debug, same, 2, Xs) ->
-  strict(arg_types(erts_debug, same, 2), Xs, fun (_) -> t_boolean() end);
-type(erts_debug, set_internal_state, 2, _) ->
-  t_any();
 %%-- ets ----------------------------------------------------------------------
-type(ets, all, 0, _) ->
-  t_list(t_tab());
-type(ets, delete, 1, Xs) ->
-  strict(arg_types(ets, delete, 1), Xs, fun (_) -> t_atom('true') end);
-type(ets, delete, 2, Xs) ->
-  strict(arg_types(ets, delete, 2), Xs, fun (_) -> t_atom('true') end);
-type(ets, delete_all_objects, 1, Xs) ->
-  strict(arg_types(ets, delete_all_objects, 1), Xs,
-	 fun (_) -> t_atom('true') end);
-type(ets, delete_object, 2, Xs) ->
-  strict(arg_types(ets, delete_object, 2), Xs, fun (_) -> t_atom('true') end);
-type(ets, first, 1, Xs) ->
-  strict(arg_types(ets, first, 1), Xs, fun (_) -> t_any() end);
-type(ets, give_away, 3, Xs) ->
-  strict(arg_types(ets, give_away, 3), Xs, fun (_) -> t_atom('true') end);
-type(ets, info, 1, Xs) ->
-  strict(arg_types(ets, info, 1), Xs,
-	 fun (_) ->
-	     t_sup(t_list(t_tuple([t_ets_info_items(), t_any()])),
-		   t_atom('undefined'))
-	 end);
-type(ets, info, 2, Xs) ->
-  strict(arg_types(ets, info, 2), Xs, fun (_) -> t_any() end);
-type(ets, insert, 2, Xs) ->
-  strict(arg_types(ets, insert, 2), Xs, fun (_) -> t_atom('true') end);
-type(ets, insert_new, 2, Xs) ->
-  strict(arg_types(ets, insert_new, 2), Xs, fun (_) -> t_boolean() end);
-type(ets, is_compiled_ms, 1, Xs) ->
-  strict(arg_types(ets, is_compiled_ms, 1), Xs, fun (_) -> t_boolean() end);
-type(ets, last, 1, Xs) ->
-  type(ets, first, 1, Xs);
-type(ets, lookup, 2, Xs) ->
-  strict(arg_types(ets, lookup, 2), Xs, fun (_) -> t_list(t_tuple()) end);
-type(ets, lookup_element, 3, Xs) ->
-  strict(arg_types(ets, lookup_element, 3), Xs, fun (_) -> t_any() end);
-type(ets, match, 1, Xs) ->
-  strict(arg_types(ets, match, 1), Xs, fun (_) -> t_matchres() end);
-type(ets, match, 2, Xs) ->
-  strict(arg_types(ets, match, 2), Xs, fun (_) -> t_list() end);
-type(ets, match, 3, Xs) ->
-  strict(arg_types(ets, match, 3), Xs, fun (_) -> t_matchres() end);
-type(ets, match_object, 1, Xs) -> type(ets, match, 1, Xs);
-type(ets, match_object, 2, Xs) -> type(ets, match, 2, Xs);
-type(ets, match_object, 3, Xs) -> type(ets, match, 3, Xs);
-type(ets, match_spec_compile, 1, Xs) ->
-  strict(arg_types(ets, match_spec_compile, 1), Xs, fun (_) -> t_any() end);
-type(ets, match_spec_run_r, 3, Xs) ->
-  strict(arg_types(ets, match_spec_run_r, 3), Xs, fun (_) -> t_list() end);
-type(ets, member, 2, Xs) ->
-  strict(arg_types(ets, member, 2), Xs, fun (_) -> t_boolean() end);
-type(ets, new, 2, Xs) ->
-  strict(arg_types(ets, new, 2), Xs, fun (_) -> t_tab() end);
-type(ets, next, 2, Xs) ->
-  strict(arg_types(ets, next, 2), Xs,
-	 %% t_any below stands for:  term() | '$end_of_table'
-	 fun (_) -> t_any() end);
-type(ets, prev, 2, Xs) -> type(ets, next, 2, Xs);
 type(ets, rename, 2, Xs) ->
   strict(arg_types(ets, rename, 2), Xs, fun ([_, Name]) -> Name end);
-type(ets, safe_fixtable, 2, Xs) ->
-  strict(arg_types(ets, safe_fixtable, 2), Xs, fun (_) -> t_atom('true') end);
-type(ets, select, 1, Xs) ->
-  strict(arg_types(ets, select, 1), Xs, fun (_) -> t_matchres() end);
-type(ets, select, 2, Xs) ->
-  strict(arg_types(ets, select, 2), Xs, fun (_) -> t_list() end);
-type(ets, select, 3, Xs) ->
-  strict(arg_types(ets, select, 3), Xs, fun (_) -> t_matchres() end);
-type(ets, select_count, 2, Xs) ->
-  strict(arg_types(ets, select_count, 2), Xs,
-	 fun (_) -> t_non_neg_fixnum() end);
-type(ets, select_delete, 2, Xs) ->
-  strict(arg_types(ets, select_delete, 2), Xs,
-	 fun (_) -> t_non_neg_fixnum() end);
-type(ets, select_reverse, 1, Xs) -> type(ets, select, 1, Xs);
-type(ets, select_reverse, 2, Xs) -> type(ets, select, 2, Xs);
-type(ets, select_reverse, 3, Xs) -> type(ets, select, 3, Xs);
-type(ets, setopts, 2, Xs) ->
-  strict(arg_types(ets, setopts, 2), Xs, fun (_) -> t_atom('true') end);
-type(ets, slot, 2, Xs) ->
-  strict(arg_types(ets, slot, 2), Xs,
-	 fun (_) -> t_sup(t_list(t_tuple()), t_atom('$end_of_table')) end);
-type(ets, update_counter, 3, Xs) ->
-  strict(arg_types(ets, update_counter, 3), Xs,
-	 fun ([_, _, Op]) ->
-	     case t_is_integer(Op) of
-	       true -> t_integer();
-	       false ->
-		 case t_is_tuple(Op) of
-		   true -> t_integer();
-		   false ->
-		     case t_is_list(Op) of
-		       true -> t_list(t_integer());
-		       false ->
-			 case t_is_nil(Op) of
-			   true -> t_nil();
-			   false -> t_sup([t_integer(), t_list(t_integer())])
-			 end
-		     end
-		 end
-	     end
-	 end);
-type(ets, update_element, 3, Xs) ->
-  strict(arg_types(ets, update_element, 3), Xs, fun (_) -> t_boolean() end);
-%%-- file ---------------------------------------------------------------------
-type(file, native_name_encoding, 0, _) ->
-  t_file_encoding();
-%%-- prim_file ----------------------------------------------------------------
-type(prim_file, internal_name2native, 1, Xs) ->
-  strict(arg_types(prim_file, internal_name2native, 1), Xs,  
-	 fun (_) -> t_binary() end);
-type(prim_file, internal_native2name, 1, Xs) ->
-  strict(arg_types(prim_file, internal_native2name, 1), Xs,  
-	 fun (_) -> t_prim_file_name() end);
-type(prim_file, internal_normalize_utf8, 1, Xs) ->
-  strict(arg_types(prim_file, internal_normalize_utf8, 1), Xs,  
-	 fun (_) -> t_unicode_string() end);
-%%-- gen_tcp ------------------------------------------------------------------
-%% NOTE: All type information for this module added to avoid loss of precision
-type(gen_tcp, accept, 1, Xs) ->
-  strict(arg_types(gen_tcp, accept, 1), Xs, fun (_) -> t_gen_tcp_accept() end);
-type(gen_tcp, accept, 2, Xs) ->
-  strict(arg_types(gen_tcp, accept, 2), Xs, fun (_) -> t_gen_tcp_accept() end);
-type(gen_tcp, connect, 3, Xs) ->
-  strict(arg_types(gen_tcp, connect, 3), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_socket()]),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-type(gen_tcp, connect, 4, Xs) ->
-  strict(arg_types(gen_tcp, connect, 4), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_socket()]),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-type(gen_tcp, listen, 2, Xs) ->
-  strict(arg_types(gen_tcp, listen, 2), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_socket()]),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-type(gen_tcp, recv, 2, Xs) ->
-  strict(arg_types(gen_tcp, recv, 2), Xs, fun (_) -> t_gen_tcp_recv() end);
-type(gen_tcp, recv, 3, Xs) ->
-  strict(arg_types(gen_tcp, recv, 3), Xs, fun (_) -> t_gen_tcp_recv() end);
-type(gen_tcp, send, 2, Xs) ->
-  strict(arg_types(gen_tcp, send, 2), Xs,
-	 fun (_) ->
-	     t_sup(t_atom('ok'),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-type(gen_tcp, shutdown, 2, Xs) ->
-  strict(arg_types(gen_tcp, shutdown, 2), Xs,
-	 fun (_) ->
-	     t_sup(t_atom('ok'),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-%%-- gen_udp ------------------------------------------------------------------
-%% NOTE: All type information for this module added to avoid loss of precision
-type(gen_udp, open, 1, Xs) ->
-  strict(arg_types(gen_udp, open, 1), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_socket()]),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-type(gen_udp, open, 2, Xs) ->
-  strict(arg_types(gen_udp, open, 2), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_socket()]),
-		   t_tuple([t_atom('error'), t_inet_posix_error()]))
-	 end);
-type(gen_udp, recv, 2, Xs) ->
-  strict(arg_types(gen_udp, recv, 2), Xs, fun (_) -> t_gen_udp_recv() end);
-type(gen_udp, recv, 3, Xs) ->
-  strict(arg_types(gen_udp, recv, 3), Xs, fun (_) -> t_gen_udp_recv() end);
-type(gen_udp, send, 4, Xs) ->
-  strict(arg_types(gen_udp, send, 4), Xs,
-	 fun (_) ->
-	     t_sup(t_atom('ok'),
-		   t_tuple([t_atom('error'), t_sup(t_atom('not_owner'),
-						   t_inet_posix_error())]))
-	 end);
 %%-- hipe_bifs ----------------------------------------------------------------
 type(hipe_bifs, add_ref, 2, Xs) ->
   strict(arg_types(hipe_bifs, add_ref, 2), Xs, fun (_) -> t_nil() end);
@@ -2097,26 +1759,6 @@ type(hipe_bifs, write_u32, 2, Xs) ->
   strict(arg_types(hipe_bifs, write_u32, 2), Xs, fun (_) -> t_nil() end);
 type(hipe_bifs, write_u64, 2, Xs) ->
   strict(arg_types(hipe_bifs, write_u64, 2), Xs, fun (_) -> t_nil() end);
-%%-- io -----------------------------------------------------------------------
-type(io, format, 1, Xs) ->
-  strict(arg_types(io, format, 1), Xs, fun (_) -> t_atom('ok') end);
-type(io, format, 2, Xs) ->
-  strict(arg_types(io, format, 2), Xs, fun (_) -> t_atom('ok') end);
-type(io, format, 3, Xs) ->
-  strict(arg_types(io, format, 3), Xs, fun (_) -> t_atom('ok') end);
-type(io, fwrite, 1, Xs) -> type(io, format, 1, Xs); % same
-type(io, fwrite, 2, Xs) -> type(io, format, 2, Xs); % same
-type(io, fwrite, 3, Xs) -> type(io, format, 3, Xs); % same
-type(io, put_chars, 1, Xs) ->
-  strict(arg_types(io, put_chars, 1), Xs, fun (_) -> t_atom('ok') end);
-type(io, put_chars, 2, Xs) ->
-  strict(arg_types(io, put_chars, 2), Xs, fun (_) -> t_atom('ok') end);
-%%-- io_lib -------------------------------------------------------------------
-type(io_lib, format, 2, Xs) ->
-  strict(arg_types(io_lib, format, 2), Xs,
-	 %% t_list() because the character list might be arbitrarily nested
-	 fun (_) -> t_list(t_sup(t_char(), t_list())) end);
-type(io_lib, fwrite, 2, Xs) -> type(io_lib, format, 2, Xs); % same
 %%-- lists --------------------------------------------------------------------
 type(lists, all, 2, Xs) ->
   strict(arg_types(lists, all, 2), Xs, 
@@ -2524,10 +2166,6 @@ type(lists, reverse, 1, Xs) ->
   strict(arg_types(lists, reverse, 1), Xs, fun ([X]) -> X end);
 type(lists, reverse, 2, Xs) ->
   type(erlang, '++', 2, Xs);    % reverse-onto is just like append
-type(lists, seq, 2, Xs) ->
-  strict(arg_types(lists, seq, 2), Xs, fun (_) -> t_list(t_integer()) end);
-type(lists, seq, 3, Xs) ->
-  strict(arg_types(lists, seq, 3), Xs, fun (_) -> t_list(t_integer()) end);
 type(lists, sort, 1, Xs) ->
   strict(arg_types(lists, sort, 1), Xs, fun ([X]) -> X end);
 type(lists, sort, 2, Xs) ->
@@ -2634,95 +2272,7 @@ type(lists, zipwith, 3, Xs) ->
 type(lists, zipwith3, 4, Xs) ->
   strict(arg_types(lists, zipwith3, 4), Xs,
 	 fun ([F,_As,_Bs,_Cs]) -> t_sup(t_list(t_fun_range(F)), t_nil()) end);
-%%-- math ---------------------------------------------------------------------
-type(math, acos, 1, Xs) ->
-  strict(arg_types(math, acos, 1), Xs, fun (_) -> t_float() end);
-type(math, acosh, 1, Xs) ->
-  strict(arg_types(math, acosh, 1), Xs, fun (_) -> t_float() end);
-type(math, asin, 1, Xs) ->
-  strict(arg_types(math, asin, 1), Xs, fun (_) -> t_float() end);
-type(math, asinh, 1, Xs) ->
-  strict(arg_types(math, asinh, 1), Xs, fun (_) -> t_float() end);
-type(math, atan, 1, Xs) ->
-  strict(arg_types(math, atan, 1), Xs, fun (_) -> t_float() end);
-type(math, atan2, 2, Xs) ->
-  strict(arg_types(math, atan2, 2), Xs, fun (_) -> t_float() end);
-type(math, atanh, 1, Xs) ->
-  strict(arg_types(math, atanh, 1), Xs, fun (_) -> t_float() end);
-type(math, cos, 1, Xs) ->
-  strict(arg_types(math, cos, 1), Xs, fun (_) -> t_float() end);
-type(math, cosh, 1, Xs) ->
-  strict(arg_types(math, cosh, 1), Xs, fun (_) -> t_float() end);
-type(math, erf, 1, Xs) ->
-  strict(arg_types(math, erf, 1), Xs, fun (_) -> t_float() end);
-type(math, erfc, 1, Xs) ->
-  strict(arg_types(math, erfc, 1), Xs, fun (_) -> t_float() end);
-type(math, exp, 1, Xs) ->
-  strict(arg_types(math, exp, 1), Xs, fun (_) -> t_float() end);
-type(math, log, 1, Xs) ->
-  strict(arg_types(math, log, 1), Xs, fun (_) -> t_float() end);
-type(math, log10, 1, Xs) ->
-  strict(arg_types(math, log10, 1), Xs, fun (_) -> t_float() end);
-type(math, pi, 0, _) -> t_float();
-type(math, pow, 2, Xs) ->
-  strict(arg_types(math, pow, 2), Xs, fun (_) -> t_float() end);
-type(math, sin, 1, Xs) ->
-  strict(arg_types(math, sin, 1), Xs, fun (_) -> t_float() end);
-type(math, sinh, 1, Xs) ->
-  strict(arg_types(math, sinh, 1), Xs, fun (_) -> t_float() end);
-type(math, sqrt, 1, Xs) ->
-  strict(arg_types(math, sqrt, 1), Xs, fun (_) -> t_float() end);
-type(math, tan, 1, Xs) ->
-  strict(arg_types(math, tan, 1), Xs, fun (_) -> t_float() end);
-type(math, tanh, 1, Xs) ->
-  strict(arg_types(math, tanh, 1), Xs, fun (_) -> t_float() end);
-%%-- net_kernel ---------------------------------------------------------------
-type(net_kernel, dflag_unicode_io, 1, Xs) ->
-  strict(arg_types(net_kernel, dflag_unicode_io, 1), Xs, 
-	 fun (_) -> t_boolean() end); 
-%%-- ordsets ------------------------------------------------------------------
-type(ordsets, filter, 2, Xs) ->
-  type(lists, filter, 2, Xs);
-type(ordsets, fold, 3, Xs) ->
-  type(lists, foldl, 3, Xs);
-%%-- os -----------------------------------------------------------------------
-type(os, getenv, 0, _) -> t_list(t_string());
-type(os, getenv, 1, Xs) ->
-  strict(arg_types(os, getenv, 1), Xs,
-	 fun (_) -> t_sup(t_string(), t_atom('false')) end);
-type(os, getpid, 0, _) -> t_string();
-type(os, putenv, 2, Xs) ->
-  strict(arg_types(os, putenv, 2), Xs, fun (_) -> t_atom('true') end);
-type(os, timestamp, 0, _) ->
-  t_timestamp();
-%%-- re -----------------------------------------------------------------------
-type(re, compile, 1, Xs) ->
-  strict(arg_types(re, compile, 1), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_re_MP()]),
-		   t_tuple([t_atom('error'), t_re_ErrorSpec()]))
-	 end);
-type(re, compile, 2, Xs) ->
-  strict(arg_types(re, compile, 2), Xs,
-	 fun (_) ->
-	     t_sup(t_tuple([t_atom('ok'), t_re_MP()]),
-		   t_tuple([t_atom('error'), t_re_ErrorSpec()]))
-	 end);
-type(re, run, 2, Xs) ->
-  strict(arg_types(re, run, 2), Xs,
-	 fun (_) ->
-	     t_sup([t_tuple([t_atom('match'), t_re_Captured()]),
-		    t_atom('nomatch'),
-		    t_tuple([t_atom('error'), t_re_ErrorSpec()])])
-	 end);
-type(re, run, 3, Xs) ->
-  strict(arg_types(re, run, 3), Xs,
-	 fun (_) ->
-	     t_sup([t_tuple([t_atom('match'), t_re_Captured()]),
-		    t_atom('match'),
-		    t_atom('nomatch'),
-		    t_tuple([t_atom('error'), t_re_ErrorSpec()])])
-	 end);
+
 %%-- string -------------------------------------------------------------------
 type(string, chars, 2, Xs) ->  % NOTE: added to avoid loss of information
   strict(arg_types(string, chars, 2), Xs, fun (_) -> t_string() end);
@@ -2741,41 +2291,6 @@ type(string, chars, 3, Xs) ->  % NOTE: added to avoid loss of information
 		 end
 	     end
 	 end);
-type(string, concat, 2, Xs) -> % NOTE: added to avoid loss of information
-  strict(arg_types(string, concat, 2), Xs, fun (_) -> t_string() end);
-type(string, equal, 2, Xs) ->  % NOTE: added to avoid loss of information
-  strict(arg_types(string, equal, 2), Xs, fun (_) -> t_boolean() end);
-type(string, to_float, 1, Xs) ->
-  strict(arg_types(string, to_float, 1), Xs,
-	 fun (_) -> t_sup(t_tuple([t_float(), t_string()]),
-			  t_tuple([t_atom('error'),
-				   t_sup(t_atom('no_float'),
-					 t_atom('not_a_list'))]))
-	 end);
-type(string, to_integer, 1, Xs) ->
-  strict(arg_types(string, to_integer, 1), Xs,
-	 fun (_) -> t_sup(t_tuple([t_integer(), t_string()]),
-			  t_tuple([t_atom('error'),
-				   t_sup(t_atom('no_integer'),
-					 t_atom('not_a_list'))]))
-	 end);
-%%-- unicode ------------------------------------------------------------------
-type(unicode, characters_to_binary, 2, Xs) ->
-  strict(arg_types(unicode, characters_to_binary, 2), Xs,
-	 fun (_) -> 
-	     t_sup([t_binary(),
-		    t_tuple([t_atom('error'), t_binary(), t_ML()]),
-		    t_tuple([t_atom('incomplete'), t_binary(), t_ML()])])
-		    end);
-type(unicode, characters_to_list, 2, Xs) ->
-  strict(arg_types(unicode, characters_to_list, 2), Xs,
-	 fun (_) ->
-	     t_sup([t_string(),
-		    t_tuple([t_atom('error'), t_string(), t_ML()]),
-		    t_tuple([t_atom('incomplete'), t_string(), t_ML()])])
-	 end);
-type(unicode, bin_is_7bit, 1, Xs) ->
-  strict(arg_types(unicode, bin_is_7bit, 1), Xs, fun (_) -> t_boolean() end);
 
 %%-----------------------------------------------------------------------------
 type(M, F, A, Xs) when is_atom(M), is_atom(F),
@@ -3230,107 +2745,6 @@ key_comparisons_fail(X0, KeyPos, TupleList) ->
 
 -spec arg_types(atom(), atom(), arity()) -> [erl_types:erl_type()] | 'unknown'.
 
-%%------- binary --------------------------------------------------------------
-arg_types(binary, at, 2) ->
-  [t_binary(), t_non_neg_integer()];
-arg_types(binary, bin_to_list, 1) ->
-  [t_binary()];
-arg_types(binary, bin_to_list, 2) ->
-  [t_binary(), t_binary_part()];
-arg_types(binary, bin_to_list, 3) ->
-  [t_binary(), t_integer(), t_non_neg_integer()];
-arg_types(binary, compile_pattern, 1) ->
-  [t_sup(t_binary(), t_list(t_binary()))];
-arg_types(binary, copy, 1) ->
-  [t_binary()];
-arg_types(binary, copy, 2) ->
-  [t_binary(), t_non_neg_integer()];
-arg_types(binary, decode_unsigned, 1) ->
-  [t_binary()];
-arg_types(binary, decode_unsigned, 2) ->
-  [t_binary(), t_endian()];
-arg_types(binary, encode_unsigned, 1) ->
-  [t_non_neg_integer()];
-arg_types(binary, encode_unsigned, 2) ->
-  [t_non_neg_integer(), t_endian()];
-arg_types(binary, first, 1) ->
-  [t_binary()];
-arg_types(binary, last, 1) ->
-  [t_binary()];
-arg_types(binary, list_to_bin, 1) ->
-  arg_types(erlang, list_to_binary, 1);
-arg_types(binary, longest_common_prefix, 1) ->
-  [t_list(t_binary())];
-arg_types(binary, longest_common_suffix, 1) ->
-  [t_list(t_binary())];
-arg_types(binary, match, 2) ->
-  [t_binary(), t_binary_pattern()];
-arg_types(binary, match, 3) ->
-  [t_binary(), t_binary_pattern(), t_binary_options()];
-arg_types(binary, matches, 2) ->
-  [t_binary(), t_binary_pattern()];
-arg_types(binary, matches, 3) ->
-  [t_binary(), t_binary_pattern(), t_binary_options()];
-arg_types(binary, part, 2) ->
-  arg_types(erlang, binary_part, 2);
-arg_types(binary, part, 3) ->
-  arg_types(erlang, binary_part, 3);
-arg_types(binary, referenced_byte_size, 1) ->
-  [t_binary()];
-%%------- code ----------------------------------------------------------------
-arg_types(code, get_chunk, 2) ->
-  [t_binary(), t_string()];
-arg_types(code, is_module_native, 1) ->
-  [t_atom()];
-arg_types(code, module_md5, 1) ->
-  [t_binary()];
-arg_types(code, make_stub_module, 3) ->
-  [t_atom(), t_binary(), t_tuple([t_list(), t_list()])];
-arg_types(code, rehash, 0) ->
-  [];
-%%------- erl_ddll ------------------------------------------------------------
-arg_types(erl_ddll, demonitor, 1) ->
-  arg_types(erlang, demonitor, 1);
-arg_types(erl_ddll, format_error_int, 1) ->
-  [t_sup([t_atom('inconsistent'),
-	  t_atom('linked_in_driver'),
-	  t_atom('permanent'),
-	  t_atom('not_loaded'),
-	  t_atom('not_loaded_by_this_process'),
-	  t_atom('not_pending'),
-	  t_atom('already_loaded'),
-	  t_atom('unloading')])];
-arg_types(erl_ddll, info, 2) ->
-  [t_sup([t_atom(), t_string()]),
-   t_sup([t_atom('awaiting_load'),
-	  t_atom('awaiting_unload'),
-	  t_atom('driver_options'),
-	  t_atom('linked_in_driver'),
-	  t_atom('permanent'),
-	  t_atom('port_count'),
-	  t_atom('processes')])];
-arg_types(erl_ddll, loaded_drivers, 0) ->
-  [];
-arg_types(erl_ddll, monitor, 2) ->
-  [t_atom('driver'),
-   t_tuple([t_atom(), t_sup([t_atom('loaded'), t_atom('unloaded')])])];
-arg_types(erl_ddll, try_load, 3) ->
-  [t_sup([t_atom(), t_string(), t_nonempty_list(t_sup([t_atom(), t_string()]))]),
-   t_sup([t_atom(), t_string()]),
-   t_list(t_sup([t_tuple([t_atom('driver_options'),
-			  t_list(t_atom('kill_ports'))]),
-		 t_tuple([t_atom('monitor'),
-			  t_sup([t_atom('pending_driver'),
-				 t_atom('pending')])]),
-		 t_tuple([t_atom('reload'),
-			  t_sup([t_atom('pending_driver'),
-				 t_atom('pending')])])]))];
-arg_types(erl_ddll, try_unload, 2) ->
-  [t_sup([t_atom(), t_string(), t_nonempty_list(t_sup([t_atom(), t_string()]))]),
-   t_list(t_sup([t_atom('kill_ports'),
-		 t_tuple([t_atom('monitor'),
-			  t_sup([t_atom('pending_driver'),
-				 t_atom('pending')])])]))];
 %%------- erlang --------------------------------------------------------------
 arg_types(erlang, '!', 2) ->
   Pid = t_sup([t_pid(), t_port(), t_atom(),
@@ -3960,177 +3374,9 @@ arg_types(erlang, whereis, 1) ->
   [t_atom()];
 arg_types(erlang, yield, 0) ->
   [];
-%%------- erl_prim_loader -----------------------------------------------------
-arg_types(erl_prim_loader, get_file, 1) ->
-  [t_sup(t_atom(), t_string())];
-arg_types(erl_prim_loader, get_path, 0) ->
-  [];
-arg_types(erl_prim_loader, set_path, 1) ->
-  [t_list(t_string())];
-%%------- error_logger --------------------------------------------------------
-arg_types(error_logger, warning_map, 0) ->
-  [];
-%%------- erts_debug ----------------------------------------------------------
-arg_types(erts_debug, breakpoint, 2) ->
-  [t_tuple([t_atom(), t_atom(), t_sup(t_integer(), t_atom('_'))]), t_boolean()];
-arg_types(erts_debug, disassemble, 1) ->
-  [t_sup(t_mfa(), t_integer())];
-arg_types(erts_debug, display, 1) ->
-  [t_any()];
-arg_types(erts_debug, dist_ext_to_term, 2) ->
-  [t_tuple(), t_binary()];
-arg_types(erts_debug, dump_monitors, 1) ->
-  [t_sup([t_pid(),t_atom()])];
-arg_types(erts_debug, dump_links, 1) ->
-  [t_sup([t_pid(),t_atom(),t_port()])];
-arg_types(erts_debug, flat_size, 1) ->
-  [t_any()];
-arg_types(erts_debug, get_internal_state, 1) ->
-  [t_any()];
-arg_types(erts_debug, instructions, 0) ->
-  [];
-arg_types(erts_debug, lock_counters, 1) ->
-  [t_sup([t_atom(enabled),
-	  t_atom(info),
-	  t_atom(clear),
-	  t_tuple([t_atom(copy_save), t_boolean()]),
-	  t_tuple([t_atom(process_locks), t_boolean()])])];
-arg_types(erts_debug, same, 2) ->
-  [t_any(), t_any()];
-arg_types(erts_debug, set_internal_state, 2) ->
-  [t_any(), t_any()];
 %%------- ets -----------------------------------------------------------------
-arg_types(ets, all, 0) ->
-  [];
-arg_types(ets, delete, 1) ->
-  [t_tab()];
-arg_types(ets, delete, 2) ->
-  [t_tab(), t_any()];
-arg_types(ets, delete_all_objects, 1) ->
-  [t_tab()];
-arg_types(ets, delete_object, 2) ->
-  [t_tab(), t_tuple()];
-arg_types(ets, first, 1) ->
-  [t_tab()];
-arg_types(ets, give_away, 3) ->
-  [t_tab(), t_pid(), t_any()];
-arg_types(ets, info, 1) ->
-  [t_tab()];
-arg_types(ets, info, 2) ->
-  [t_tab(), t_ets_info_items()];
-arg_types(ets, insert, 2) ->
-  [t_tab(), t_sup(t_tuple(), t_list(t_tuple()))];
-arg_types(ets, insert_new, 2) ->
-  [t_tab(), t_sup(t_tuple(), t_list(t_tuple()))];
-arg_types(ets, is_compiled_ms, 1) ->
-  [t_any()];
-arg_types(ets, last, 1) ->
-  arg_types(ets, first, 1);
-arg_types(ets, lookup, 2) ->
-  [t_tab(), t_any()];
-arg_types(ets, lookup_element, 3) ->
-  [t_tab(), t_any(), t_pos_fixnum()];
-arg_types(ets, match, 1) ->
-  [t_any()];
-arg_types(ets, match, 2) ->
-  [t_tab(), t_match_pattern()];
-arg_types(ets, match, 3) ->
-  [t_tab(), t_match_pattern(), t_pos_fixnum()];
-arg_types(ets, match_object, 1) ->
-  arg_types(ets, match, 1);
-arg_types(ets, match_object, 2) ->
-  arg_types(ets, match, 2);
-arg_types(ets, match_object, 3) ->
-  arg_types(ets, match, 3);
-arg_types(ets, match_spec_compile, 1) ->
-  [t_matchspecs()];
-arg_types(ets, match_spec_run_r, 3) ->
-  [t_list(t_tuple()),t_matchspecs(), t_list()];
-arg_types(ets, member, 2) ->
-  [t_tab(), t_any()];
-arg_types(ets, new, 2) ->
-  [t_atom(), t_ets_new_options()];
-arg_types(ets, next, 2) ->
-  [t_tab(), t_any()];
-arg_types(ets, prev, 2) ->
-  [t_tab(), t_any()];
 arg_types(ets, rename, 2) ->
   [t_atom(), t_atom()];
-arg_types(ets, safe_fixtable, 2) ->
-  [t_tab(), t_boolean()];
-arg_types(ets, select, 1) ->
-  [t_any()];
-arg_types(ets, select, 2) ->
-  [t_tab(), t_matchspecs()];
-arg_types(ets, select, 3) ->
-  [t_tab(), t_matchspecs(), t_pos_fixnum()];
-arg_types(ets, select_count, 2) ->
-  [t_tab(), t_matchspecs()];
-arg_types(ets, select_delete, 2) ->
-  [t_tab(), t_matchspecs()];
-arg_types(ets, select_reverse, 1) ->
-  arg_types(ets, select, 1);
-arg_types(ets, select_reverse, 2) ->
-  arg_types(ets, select, 2);
-arg_types(ets, select_reverse, 3) ->
-  arg_types(ets, select, 3);
-arg_types(ets, slot, 2) ->
-  [t_tab(), t_non_neg_fixnum()]; % 2nd arg can be 0
-arg_types(ets, setopts, 2) ->
-  Opt = t_sup([t_tuple([t_atom('heir'), t_pid(), t_any()]),
-	       t_tuple([t_atom('heir'), t_atom('none')]),
-	       t_tuple([t_atom('protection'),
-			t_sup([t_atom('protected'),
-			       t_atom('private'),
-			       t_atom('public')])])]),
-  [t_tab(), t_sup(Opt, t_list(Opt))];
-arg_types(ets, update_counter, 3) ->
-  Int = t_integer(),
-  UpdateOp = t_sup(t_tuple([Int, Int]), t_tuple([Int, Int, Int, Int])),
-  [t_tab(), t_any(), t_sup([UpdateOp, t_list(UpdateOp), Int])];
-arg_types(ets, update_element, 3) ->
-  PosValue = t_tuple([t_integer(), t_any()]),
-  [t_tab(), t_any(), t_sup(PosValue, t_list(PosValue))];
-%%------- file ----------------------------------------------------------------
-arg_types(file, native_name_encoding, 0) ->
-  [];
-%%-- prim_file ----------------------------------------------------------------
-arg_types(prim_file, internal_name2native, 1) ->
-  [t_prim_file_name()];
-arg_types(prim_file, internal_native2name, 1) ->
-  [t_binary()];
-arg_types(prim_file, internal_normalize_utf8, 1) ->
-  [t_binary()];
-%%------- gen_tcp -------------------------------------------------------------
-arg_types(gen_tcp, accept, 1) ->
-  [t_socket()];
-arg_types(gen_tcp, accept, 2) ->
-  [t_socket(), t_timeout()];
-arg_types(gen_tcp, connect, 3) ->
-  [t_gen_tcp_address(), t_gen_tcp_port(), t_list(t_gen_tcp_connect_option())];
-arg_types(gen_tcp, connect, 4) ->
-  arg_types(gen_tcp, connect, 3) ++ [t_timeout()];
-arg_types(gen_tcp, listen, 2) ->
-  [t_gen_tcp_port(), t_list(t_gen_tcp_listen_option())];
-arg_types(gen_tcp, recv, 2) ->
-  [t_socket(), t_non_neg_integer()];
-arg_types(gen_tcp, recv, 3) ->
-  arg_types(gen_tcp, recv, 2) ++ [t_timeout()];
-arg_types(gen_tcp, send, 2) ->
-  [t_socket(), t_packet()];
-arg_types(gen_tcp, shutdown, 2) ->
-  [t_socket(), t_sup([t_atom('read'), t_atom('write'), t_atom('read_write')])];
-%%------- gen_udp -------------------------------------------------------------
-arg_types(gen_udp, open, 1) ->
-  [t_gen_tcp_port()];
-arg_types(gen_udp, open, 2) ->
-  [t_gen_tcp_port(), t_list(t_gen_udp_connect_option())];
-arg_types(gen_udp, recv, 2) ->
-  arg_types(gen_tcp, recv, 2);
-arg_types(gen_udp, recv, 3) ->
-  arg_types(gen_tcp, recv, 3);
-arg_types(gen_udp, send, 4) ->
-  [t_socket(), t_gen_tcp_address(), t_gen_tcp_port(), t_packet()];
 %%------- hipe_bifs -----------------------------------------------------------
 arg_types(hipe_bifs, add_ref, 2) ->
   [t_mfa(), t_tuple([t_mfa(),
@@ -4228,28 +3474,6 @@ arg_types(hipe_bifs, write_u32, 2) ->
   [t_integer(), t_integer()];
 arg_types(hipe_bifs, write_u64, 2) ->
   [t_integer(), t_integer()];
-%%------- io ------------------------------------------------------------------
-arg_types(io, format, 1) ->
-  [t_io_format_string()];
-arg_types(io, format, 2) ->
-  [t_io_format_string(), t_list()];
-arg_types(io, format, 3) ->
-  [t_io_device(), t_io_format_string(), t_list()];
-arg_types(io, fwrite, 1) ->
-  arg_types(io, format, 1);
-arg_types(io, fwrite, 2) ->
-  arg_types(io, format, 2);
-arg_types(io, fwrite, 3) ->
-  arg_types(io, format, 3);
-arg_types(io, put_chars, 1) ->
-  [t_iodata()];
-arg_types(io, put_chars, 2) ->
-  [t_io_device(), t_iodata()];
-%%------- io_lib --------------------------------------------------------------
-arg_types(io_lib, format, 2) ->
-  arg_types(io, format, 2);
-arg_types(io_lib, fwrite, 2) ->
-  arg_types(io_lib, format, 2);
 %%------- lists ---------------------------------------------------------------
 arg_types(lists, all, 2) ->
   [t_fun([t_any()], t_boolean()), t_list()];
@@ -4321,10 +3545,6 @@ arg_types(lists, reverse, 1) ->
   [t_list()];
 arg_types(lists, reverse, 2) ->
   [t_list(), t_any()];
-arg_types(lists, seq, 2) ->
-  [t_integer(), t_integer()];
-arg_types(lists, seq, 3) ->
-  [t_integer(), t_integer(), t_integer()];
 arg_types(lists, sort, 1) ->
   [t_list()];
 arg_types(lists, sort, 2) ->
@@ -4353,97 +3573,12 @@ arg_types(lists, zipwith, 3) ->
   [t_fun([t_any(), t_any()], t_any()), t_list(), t_list()];
 arg_types(lists, zipwith3, 4) ->
   [t_fun([t_any(), t_any(), t_any()], t_any()), t_list(), t_list(), t_list()];
-%%------- math ----------------------------------------------------------------
-arg_types(math, acos, 1) ->
-  [t_number()];
-arg_types(math, acosh, 1) ->
-  [t_number()];
-arg_types(math, asin, 1) ->
-  [t_number()];
-arg_types(math, asinh, 1) ->
-  [t_number()];
-arg_types(math, atan, 1) ->
-  [t_number()];
-arg_types(math, atan2, 2) ->
-  [t_number(), t_number()];
-arg_types(math, atanh, 1) ->
-  [t_number()];
-arg_types(math, cos, 1) ->
-  [t_number()];
-arg_types(math, cosh, 1) ->
-  [t_number()];
-arg_types(math, erf, 1) ->
-  [t_number()];
-arg_types(math, erfc, 1) ->
-  [t_number()];
-arg_types(math, exp, 1) ->
-  [t_number()];
-arg_types(math, log, 1) ->
-  [t_number()];
-arg_types(math, log10, 1) ->
-  [t_number()];
-arg_types(math, pi, 0) ->
-  [];
-arg_types(math, pow, 2) ->
-  [t_number(), t_number()];
-arg_types(math, sin, 1) ->
-  [t_number()];
-arg_types(math, sinh, 1) ->
-  [t_number()];
-arg_types(math, sqrt, 1) ->
-  [t_number()];
-arg_types(math, tan, 1) ->
-  [t_number()];
-arg_types(math, tanh, 1) ->
-  [t_number()];
-%%-- net_kernel ---------------------------------------------------------------
-arg_types(net_kernel, dflag_unicode_io, 1) ->
-  [t_pid()];
-%%------- ordsets -------------------------------------------------------------
-arg_types(ordsets, filter, 2) ->
-  arg_types(lists, filter, 2);
-arg_types(ordsets, fold, 3) ->
-  arg_types(lists, foldl, 3);
-%%------- os ------------------------------------------------------------------
-arg_types(os, getenv, 0) ->
-  [];
-arg_types(os, getenv, 1) ->
-  [t_string()];
-arg_types(os, getpid, 0) ->
-  [];
-arg_types(os, putenv, 2) ->
-  [t_string(), t_string()];
-arg_types(os, timestamp, 0) ->
-  [];
-%%-- re -----------------------------------------------------------------------
-arg_types(re, compile, 1) ->
-  [t_iodata()];
-arg_types(re, compile, 2) ->
-  [t_sup(t_iodata(), t_charlist()), t_list(t_re_compile_option())];
-arg_types(re, run, 2) ->
-  [t_sup(t_iodata(), t_charlist()), t_re_RE()];
-arg_types(re, run, 3) ->
-  [t_sup(t_iodata(), t_charlist()), t_re_RE(), t_list(t_re_run_option())];
+
 %%------- string --------------------------------------------------------------
 arg_types(string, chars, 2) ->
   [t_char(), t_non_neg_integer()];
 arg_types(string, chars, 3) ->
   [t_char(), t_non_neg_integer(), t_any()];
-arg_types(string, concat, 2) ->
-  [t_string(), t_string()];
-arg_types(string, equal, 2) ->
-  [t_string(), t_string()];
-arg_types(string, to_float, 1) ->
-  [t_string()];
-arg_types(string, to_integer, 1) ->
-  [t_string()];
-%%------- unicode -------------------------------------------------------------
-arg_types(unicode, characters_to_binary, 2) ->
-  [t_ML(), t_encoding()];
-arg_types(unicode, characters_to_list, 2) ->
-  [t_ML(), t_encoding()];
-arg_types(unicode, bin_is_7bit, 1) ->
-  [t_binary()];
 %%-----------------------------------------------------------------------------
 arg_types(M, F, A) when is_atom(M), is_atom(F),
 			is_integer(A), 0 =< A, A =< 255 ->
@@ -4503,18 +3638,6 @@ check_fun_application(Fun, Args) ->
 
 
 %% =====================================================================
-%% These are basic types that should probably be moved to erl_types
-%% =====================================================================
-
-t_socket() -> t_port(). % alias
-
-t_ip_address() ->
-  T_int16 = t_from_range(0,  16#FFFF),
-  t_sup(t_tuple([t_byte(), t_byte(), t_byte(), t_byte()]),
-	t_tuple([T_int16, T_int16, T_int16, T_int16,
-		 T_int16, T_int16, T_int16, T_int16])).
-
-%% =====================================================================
 %% Some basic types used in various parts of the system
 %% =====================================================================
 
@@ -4595,27 +3718,6 @@ t_HttpString() ->
   t_sup(t_string(), t_binary()).
 
 %% =====================================================================
-%% These are used for the built-in functions of 'binary'
-%% =====================================================================
-
-t_binary_part() ->
-  t_tuple([t_non_neg_integer(), t_integer()]).
-
-t_binary_canonical_part() ->
-  t_tuple([t_non_neg_integer(), t_non_neg_integer()]).
-
-t_binary_pattern() ->
-  t_sup([t_binary(),
-	 t_list(t_binary()),
-	 t_binary_compiled_pattern()]).
-
-t_binary_compiled_pattern() ->
-  t_tuple([t_sup(t_atom('bm'), t_atom('ac')), t_binary()]).
-
-t_binary_options() ->
-  t_list(t_tuple([t_atom('scope'), t_binary_part()])).
-
-%% =====================================================================
 %% These are used for the built-in functions of 'code'
 %% =====================================================================
 
@@ -4822,126 +3924,6 @@ t_system_profile_return() ->
 	t_tuple([t_sup(t_pid(), t_port()), t_system_profile_options()])).
 
 %% =====================================================================
-%% These are used for the built-in functions of 'ets'
-%% =====================================================================
-
-t_tab() ->
-  t_sup(t_tid(), t_atom()).
-
-t_match_pattern() ->
-  t_sup(t_atom(), t_tuple()).
-
-t_matchspecs() ->
-  t_list(t_tuple([t_match_pattern(), t_list(), t_list()])).
-
-t_matchres() ->
-  t_sup(t_tuple([t_list(), t_any()]), t_atom('$end_of_table')).
-
-%% From the 'ets' documentation
-%%-----------------------------
-%%   Option = Type | Access | named_table | {keypos,Pos}
-%%          | {heir,pid(),HeirData} | {heir,none} | Tweaks
-%%     Type = set | ordered_set | bag | duplicate_bag
-%%   Access = public | protected | private
-%%   Tweaks = {write_concurrency,boolean()}
-%%          | {read_concurrency,boolean()} | compressed
-%%      Pos = integer()
-%% HeirData = term()
-t_ets_new_options() ->
-  t_list(t_sup([t_atom('set'),
-		t_atom('ordered_set'),
-		t_atom('bag'),
-		t_atom('duplicate_bag'),
-		t_atom('public'),
-		t_atom('protected'),
-		t_atom('private'),
-		t_atom('named_table'),
-		t_tuple([t_atom('keypos'), t_integer()]),
-		t_tuple([t_atom('heir'), t_pid(), t_any()]),
-		t_tuple([t_atom('heir'), t_atom('none')]),
-		t_tuple([t_atom('write_concurrency'), t_boolean()]),
-		t_tuple([t_atom('read_concurrency'), t_boolean()]),
-		t_atom('compressed')])).
-
-t_ets_info_items() ->
-  t_sup([t_atom('fixed'),
-	 t_atom('safe_fixed'),
-	 t_atom('keypos'),
-	 t_atom('memory'),
-	 t_atom('name'),
-	 t_atom('named_table'),
-	 t_atom('node'),
-	 t_atom('owner'),
-	 t_atom('protection'),
-	 t_atom('size'),
-	 t_atom('compressed'),
-	 t_atom('heir'),
-	 t_atom('stats'),
-	 t_atom('type')]).
-
-%% =====================================================================
-%% These are used for the built-in functions of 'gen_tcp'
-%% =====================================================================
-
-t_gen_tcp_accept() ->
-  t_sup(t_tuple([t_atom('ok'), t_socket()]),
-	t_tuple([t_atom('error'), t_sup([t_atom('closed'),
-					 t_atom('timeout'),
-					 t_inet_posix_error()])])).
-
-t_gen_tcp_address() ->
-  t_sup([t_string(), t_atom(), t_ip_address()]).
-
-t_gen_tcp_port() ->
-  t_from_range(0, 16#FFFF).
-
-t_gen_tcp_connect_option() ->
-  t_sup([t_atom('list'),
-	 t_atom('binary'),
-	 t_tuple([t_atom('ip'), t_ip_address()]),
-	 t_tuple([t_atom('port'), t_gen_tcp_port()]),
-	 t_tuple([t_atom('fd'), t_integer()]),
-	 t_atom('inet6'),
-	 t_atom('inet'),
-	 t_inet_setoption()]).
-
-t_gen_tcp_listen_option() ->
-  t_sup([t_atom('list'),
-	 t_atom('binary'),
-	 t_tuple([t_atom('backlog'), t_non_neg_integer()]),
-	 t_tuple([t_atom('ip'), t_ip_address()]),
-	 t_tuple([t_atom('fd'), t_integer()]),
-	 t_atom('inet6'),
-	 t_atom('inet'),
-	 t_inet_setoption()]).
-
-t_gen_tcp_recv() ->
-  t_sup(t_tuple([t_atom('ok'), t_packet()]),
-	t_tuple([t_atom('error'), t_sup([t_atom('closed'),
-					 t_inet_posix_error()])])).
-
-%% =====================================================================
-%% These are used for the built-in functions of 'gen_udp'
-%% =====================================================================
-
-t_gen_udp_connect_option() ->
-  t_sup([t_atom('list'),
-	 t_atom('binary'),
-	 t_tuple([t_atom('ip'), t_ip_address()]),
-	 t_tuple([t_atom('fd'), t_integer()]),
-	 t_atom('inet6'),
-	 t_atom('inet'),
-	 t_inet_setoption()]).
-
-t_gen_udp_recv() ->
-  t_sup(t_tuple([t_atom('ok'),
-		 t_tuple([t_ip_address(),
-			  t_gen_tcp_port(),
-			  t_packet()])]),
-	t_tuple([t_atom('error'),
-		 t_sup(t_atom('not_owner'), t_inet_posix_error())])).
-
-%% =====================================================================
 %% These are used for the built-in functions of 'hipe_bifs'
 %% =====================================================================
 
@@ -4976,31 +3958,6 @@ t_insn_type() ->
 %% These are used for the built-in functions of 'inet'
 %% =====================================================================
 
-t_inet_setoption() ->
-  t_sup([%% first the 2-tuple options
-	 t_tuple([t_atom('active'), t_sup(t_boolean(), t_atom('once'))]),
-	 t_tuple([t_atom('broadcast'), t_boolean()]),
-	 t_tuple([t_atom('delay_send'), t_boolean()]),
-	 t_tuple([t_atom('dontroute'), t_boolean()]),
-	 t_tuple([t_atom('exit_on_close'), t_boolean()]),
-	 t_tuple([t_atom('header'), t_non_neg_integer()]),
-	 t_tuple([t_atom('keepalive'), t_boolean()]),
-	 t_tuple([t_atom('nodelay'), t_boolean()]),
-	 t_tuple([t_atom('packet'), t_inet_setoption_packettype()]),
-	 t_tuple([t_atom('packet_size'), t_non_neg_integer()]),
-	 t_tuple([t_atom('read_packets'), t_non_neg_integer()]),
-	 t_tuple([t_atom('recbuf'), t_non_neg_integer()]),
-	 t_tuple([t_atom('reuseaddr'), t_boolean()]),
-	 t_tuple([t_atom('send_timeout'), t_non_neg_integer()]),
-	 t_tuple([t_atom('sndbuf'), t_non_neg_integer()]),
-	 t_tuple([t_atom('priority'), t_non_neg_integer()]),
-	 t_tuple([t_atom('tos'), t_non_neg_integer()]),
-	 %% and a 4-tuple option
-	 t_tuple([t_atom('raw'),
-		  t_non_neg_integer(),	% protocol level
-		  t_non_neg_integer(),	% option number
-		  t_binary()])]).	% actual option value
-
 t_inet_setoption_packettype() ->
   t_sup([t_atom('raw'),
 	 t_integers([0,1,2,4]),
@@ -5009,91 +3966,10 @@ t_inet_setoption_packettype() ->
 	 t_atom('http'),
 	 t_atom('http_bin')]).	%% but t_atom('httph') is not needed
 
-t_inet_posix_error() ->
-  t_atom().  %% XXX: Very underspecified
-
-%% =====================================================================
-%% These are used for the built-in functions of 'io'
-%% =====================================================================
-
-t_io_device() ->
-  t_sup(t_atom(), t_pid()).
-
-%% The documentation in R11B-4 reads
-%%	Format ::= atom() | string() | binary()
-%% but the Format can also be a (deep) list, hence the type below
-t_io_format_string() ->
-  t_sup([t_atom(), t_list(), t_binary()]).
-
-%% =====================================================================
-%% These are used for the built-in functions of 're'; the functions
-%% whose last name component starts with a capital letter are types
-%% =====================================================================
-
-t_re_MP() ->  %% it's supposed to be an opaque data type
-  t_tuple([t_atom('re_pattern'), t_integer(), t_integer(), t_binary()]).
-
-t_re_RE() ->
-  t_sup([t_re_MP(), t_iodata(), t_charlist()]).
-
-t_re_compile_option() ->
-  t_sup([t_atoms(['unicode', 'anchored', 'caseless', 'dollar_endonly',
-		  'dotall', 'extended', 'firstline', 'multiline',
-		  'no_auto_capture', 'dupnames', 'ungreedy']),
-	 t_tuple([t_atom('newline'), t_re_NLSpec()]),
-	 t_atoms(['bsr_anycrlf', 'bsr_unicode'])]).
-
-t_re_run_option() ->
-  t_sup([t_atoms(['anchored', 'global', 'notbol', 'noteol', 'notempty']),
-	 t_tuple([t_atom('offset'), t_integer()]),
-	 t_tuple([t_atom('newline'), t_re_NLSpec()]),
-	 t_tuple([t_atom('capture'), t_re_ValueSpec()]),
-	 t_tuple([t_atom('capture'), t_re_ValueSpec(), t_re_Type()]),
-	 t_re_compile_option()]).
-
-t_re_ErrorSpec() ->
-  t_tuple([t_string(), t_non_neg_integer()]).
-
-t_re_Type() ->
-  t_atoms(['index', 'list', 'binary']).
-
-t_re_NLSpec() ->
-  t_atoms(['cr', 'crlf', 'lf', 'anycrlf', 'any']).
-
-t_re_ValueSpec() ->
-  t_sup(t_atoms(['all', 'all_but_first', 'first', 'none']), t_re_ValueList()).
-
-t_re_ValueList() ->
-  t_list(t_sup([t_integer(), t_string(), t_atom()])).
-
-t_re_Captured() ->
-  t_list(t_sup(t_re_CapturedData(), t_list(t_re_CapturedData()))).
-
-t_re_CapturedData() ->
-  t_sup([t_tuple([t_integer(), t_integer()]), t_string(), t_binary()]).
-
-%% =====================================================================
-%% These are used for the built-in functions of 'prim_file'
-%% =====================================================================
-
-t_prim_file_name() ->
-   t_sup(t_unicode_string(), t_binary()).
-
 %% =====================================================================
 %% These are used for the built-in functions of 'unicode'
 %% =====================================================================
 
-t_ML() ->     % a binary or a possibly deep list of integers or binaries
-  t_sup(t_list(t_sup([t_integer(), t_binary(), t_list()])), t_binary()).
-
-t_encoding() ->
-  t_sup([t_atoms(['latin1', 'unicode', 'utf8', 'utf16', 'utf32']),
-	 t_tuple([t_atom('utf16'), t_endian()]),
-	 t_tuple([t_atom('utf32'), t_endian()])]).
-
-t_file_encoding() ->
-  t_atoms(['latin1', 'utf8']).
-
 t_encoding_a2b() -> % for the 2nd arg of atom_to_binary/2 and binary_to_atom/2
   t_atoms(['latin1', 'unicode', 'utf8']).
 
diff --git a/lib/kernel/doc/src/code.xml b/lib/kernel/doc/src/code.xml
index ee687511a3..bb111a2242 100644
--- a/lib/kernel/doc/src/code.xml
+++ b/lib/kernel/doc/src/code.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2011</year>
+      <year>1996</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -728,16 +728,13 @@ rpc:call(Node, code, load_binary, [Module, Filename, Binary]),
       </desc>
     </func>
     <func>
-      <name>is_module_native(Module) -> boolean() | undefined</name>
+      <name name="is_module_native" arity="1"/>
       <fsummary>Test whether a module has native code</fsummary>
-      <type>
-        <v>Module = module()</v>
-      </type>
       <desc>
-        <p>This function returns <c>true</c> if <c>Module</c> is 
+        <p>This function returns <c>true</c> if <c><anno>Module</anno></c> is
 	name of a loaded module that has native code loaded, and 
-	<c>false</c> if <c>Module</c> is loaded but does not have
-	native. If <c>Module</c> is not loaded, this function returns
+	<c>false</c> if <c><anno>Module</anno></c> is loaded but does not have
+	native. If <c><anno>Module</anno></c> is not loaded, this function returns
 	<c>undefined</c>.</p>
       </desc>
     </func>
diff --git a/lib/kernel/doc/src/erl_ddll.xml b/lib/kernel/doc/src/erl_ddll.xml
index 1911fb628e..26db11cfcd 100644
--- a/lib/kernel/doc/src/erl_ddll.xml
+++ b/lib/kernel/doc/src/erl_ddll.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1997</year><year>2011</year>
+      <year>1997</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -182,11 +182,8 @@
   </datatypes>
   <funcs>
     <func>
-      <name>demonitor(MonitorRef) -> ok</name>
+      <name name="demonitor" arity="1"/>
       <fsummary>Remove a monitor for a driver</fsummary>
-      <type>
-        <v>MonitorRef = reference()</v>
-      </type>
       <desc>
         <p>Removes a driver monitor in much the same way as 
           <seealso marker="erts:erlang#erlang:demonitor/1">erlang:demonitor/1</seealso> does with process
@@ -232,24 +229,19 @@
       </desc>
     </func>
     <func>
-      <name>info(Name, Tag) -> Value</name>
+      <name name="info" arity="2"/>
       <fsummary>Retrieve specific information about one driver</fsummary>
-      <type>
-        <v>Name = string() | atom()</v>
-        <v>Tag = processes | driver_options | port_count | linked_in_driver | permanent | awaiting_load | awaiting_unload</v>
-        <v>Value = term()</v>
-      </type>
       <desc>
         <p>This function returns specific information about one aspect
-          of a driver. The <c>Tag</c> parameter specifies which aspect
-          to get information about. The <c>Value</c> return differs
+          of a driver. The <c><anno>Tag</anno></c> parameter specifies which aspect
+          to get information about. The <c><anno>Value</anno></c> return differs
           between different tags:</p>
         <taglist>
           <tag><em>processes</em></tag>
           <item>
             <p>Return all processes containing <seealso marker="#users">users</seealso> of the specific drivers
-              as a list of tuples <c>{pid(),int()}</c>, where the
-              <c>int()</c> denotes the number of users in the process
+              as a list of tuples <c>{pid(),integer() >= 0}</c>, where the
+              <c>integer()</c> denotes the number of users in the process
               <c>pid()</c>.</p>
           </item>
           <tag><em>driver_options</em></tag>
@@ -261,16 +253,16 @@
           </item>
           <tag><em>port_count</em></tag>
           <item>
-            <p>Return the number of ports (an <c>int()</c>) using the driver.</p>
+            <p>Return the number of ports (an <c>integer >= 0()</c>) using the driver.</p>
           </item>
           <tag><em>linked_in_driver</em></tag>
           <item>
-            <p>Return a <c>bool()</c>, being <c>true</c> if the driver is a
+            <p>Return a <c>boolean()</c>, being <c>true</c> if the driver is a
               statically linked in one and <c>false</c> otherwise.</p>
           </item>
           <tag><em>permanent</em></tag>
           <item>
-            <p>Return a <c>bool()</c>, being <c>true</c> if the driver has made
+            <p>Return a <c>boolean()</c>, being <c>true</c> if the driver has made
               itself permanent (and is <em>not</em> a statically
               linked in driver). <c>false</c> otherwise.</p>
           </item>
@@ -278,14 +270,14 @@
           <item>
             <p>Return a list of all processes having monitors for
               <c>loading</c> active, each process returned as
-              <c>{pid(),int()}</c>, where the <c>int()</c> is the
+              <c>{pid(),integer() >= 0}</c>, where the <c>integer()</c> is the
               number of monitors held by the process <c>pid()</c>.</p>
           </item>
           <tag><em>awaiting_unload</em></tag>
           <item>
             <p>Return a list of all processes having monitors for
               <c>unloading</c> active, each process returned as
-              <c>{pid(),int()}</c>, where the <c>int()</c> is the
+              <c>{pid(),integer() >= 0}</c>, where the <c>integer()</c> is the
               number of monitors held by the process <c>pid()</c>.</p>
           </item>
         </taglist>
@@ -377,41 +369,34 @@
       </desc>
     </func>
     <func>
-      <name>monitor(Tag, Item) -> MonitorRef</name>
+      <name name="monitor" arity="2"/>
       <fsummary>Create a monitor for a driver</fsummary>
-      <type>
-        <v>Tag = driver </v>
-        <v>Item = {Name, When}</v>
-        <v>Name = atom() | string()</v>
-        <v>When = loaded | unloaded | unloaded_only</v>
-        <v>MonitorRef = reference()</v>
-      </type>
       <desc>
         <p>This function creates a driver monitor and works in many
           ways as the function <seealso marker="erts:erlang#erlang:monitor/2">erlang:monitor/2</seealso>,
           does for processes. When a driver changes state, the monitor
           results in a monitor-message being sent to the calling
-          process. The <c>MonitorRef</c> returned by this function is
+          process. The <c><anno>MonitorRef</anno></c> returned by this function is
           included in the message sent.</p>
         <p>As with process monitors, each driver monitor set will only
           generate <em>one single message</em>. The monitor is
           "destroyed" after the message is sent and there is then no
           need to call <seealso marker="#demonitor/1">demonitor/1</seealso>.</p>
-        <p>The <c>MonitorRef</c> can also be used in subsequent calls
+        <p>The <c><anno>MonitorRef</anno></c> can also be used in subsequent calls
           to <seealso marker="#demonitor/1">demonitor/1</seealso> to
           remove a monitor.</p>
         <p>The function accepts the following parameters:</p>
         <taglist>
-          <tag><em>Tag</em></tag>
+          <tag><em><anno>Tag</anno></em></tag>
           <item>
             <p>The monitor tag is always <c>driver</c> as this function
               can only be used to create driver monitors. In the future,
               driver monitors will be integrated with process monitors,
               why this parameter has to be given for consistence.</p>
           </item>
-          <tag><em>Item</em></tag>
+          <tag><em><anno>Item</anno></em></tag>
           <item>
-            <p>The <c>Item</c> parameter specifies which driver one
+            <p>The <c><anno>Item</anno></c> parameter specifies which driver one
               wants to monitor (the name of the driver) as well as
               which state change one wants to monitor. The parameter
               is a tuple of arity two whose first element is the
@@ -588,22 +573,8 @@
       </desc>
     </func>
     <func>
-      <name>try_load(Path, Name, OptionList) -> {ok,Status} | {ok, PendingStatus, Ref} | {error, ErrorDesc}</name>
+      <name name="try_load" arity="3"/>
       <fsummary>Load a driver</fsummary>
-      <type>
-        <v>Path = Name = string() | atom()</v>
-        <v>OptionList = [ Option ]</v>
-        <v>Option = {driver_options, DriverOptionList} | {monitor, MonitorOption} | {reload, ReloadOption}</v>
-        <v>DriverOptionList = [ DriverOption ]</v>
-        <v>DriverOption = kill_ports</v>
-        <v>MonitorOption = pending_driver | pending</v>
-        <v>ReloadOption = pending_driver | pending</v>
-        <v>Status = loaded | already_loaded | PendingStatus </v>
-        <v>PendingStatus = pending_driver | pending_process</v>
-        <v>Ref = reference()</v>
-        <v>ErrorDesc = ErrorAtom | OpaqueError</v>
-        <v>ErrorAtom = linked_in_driver | inconsistent | permanent | not_loaded_by_this_process | not_loaded |  pending_reload | pending_process</v>
-      </type>
       <desc>
         <p>This function provides more control than the
           <c>load/2</c>/<c>reload/2</c> and
@@ -655,65 +626,65 @@
         <p>When the function returns <c>{ok, pending_driver}</c> or
           <c>{ok, pending_process}</c>, one might want to get information
           about when the driver is <em>actually</em> loaded. This can
-          be achieved by using the <c>{monitor, PendingOption}</c> option.</p>
+          be achieved by using the <c>{monitor, <anno>MonitorOption</anno>}</c> option.</p>
         <p>When monitoring is requested, and a corresponding <c>{ok, pending_driver}</c> or <c>{ok, pending_process}</c> would be
-          returned, the function will instead return a tuple <c>{ok, PendingStatus, reference()}</c> and the process will, at a later
+          returned, the function will instead return a tuple <c>{ok, <anno>PendingStatus</anno>, reference()}</c> and the process will, at a later
           time when the driver actually gets loaded, get a monitor
           message. The monitor message one can expect is described in
           the <seealso marker="#monitor/2">monitor/2</seealso>
           function description. </p>
         <note>
           <p>Note that in case of loading, monitoring can
-            <em>not</em> only get triggered by using the <c>{reload, ReloadOption}</c> option, but also in special cases where
+            <em>not</em> only get triggered by using the <c>{reload, <anno>ReloadOption</anno>}</c> option, but also in special cases where
             the load-error is transient, why <c>{monitor, pending_driver}</c> should be used under basically
             <em>all</em> real world circumstances!</p>
         </note>
         <p>The function accepts the following parameters:</p>
         <taglist>
-          <tag><em>Path</em></tag>
+          <tag><em><anno>Path</anno></em></tag>
           <item>
             <p>The filesystem path to the directory where the driver
               object file is situated. The filename of the object file
               (minus extension) must correspond to the driver name
               (used in the name parameter) and the driver must
               identify itself with the very same name. The
-              <c>Path</c> might be provided as an <em>io_list</em>,
-              meaning it can be a list of other io_lists, characters
+              <c><anno>Path</anno></c> might be provided as an <em>iolist()</em>,
+              meaning it can be a list of other <c>iolist()</c>s, characters
               (eight bit integers) or binaries, all to be flattened
               into a sequence of characters.</p>
-            <p>The (possibly flattened) <c>Path</c> parameter must be
+            <p>The (possibly flattened) <c><anno>Path</anno></c> parameter must be
               consistent throughout the system, a driver should, by
               all <seealso marker="#users">users</seealso>, be loaded
-              using the same <em>literal</em><c>Path</c>. The
+              using the same <em>literal</em><c><anno>Path</anno></c>. The
               exception is when <em>reloading</em> is requested, in
-              which case the <c>Path</c> may be specified
+              which case the <c><anno>Path</anno></c> may be specified
               differently. Note that all <seealso marker="#users">users</seealso> trying to load the
-              driver at a later time will need to use the <em>new</em><c>Path</c> if the <c>Path</c> is changed using a
+              driver at a later time will need to use the <em>new</em><c><anno>Path</anno></c> if the <c><anno>Path</anno></c> is changed using a
               <c>reload</c> option. This is yet another reason
               to have <em>only one loader</em> of a driver one wants to
               upgrade in a running system!  </p>
           </item>
-          <tag><em>Name</em></tag>
+          <tag><em><anno>Name</anno></em></tag>
           <item>
             <p>The name parameter is the name of the driver to be used
               in subsequent calls to <seealso marker="erts:erlang#open_port/2">open_port</seealso>. The
-              name can be specified either as an <c>io_list()</c> or
+              name can be specified either as an <c>iolist()</c> or
               as an <c>atom()</c>. The name given when loading is used
               to find the actual object file (with the
-              help of the <c>Path</c> and the system implied
+              help of the <c><anno>Path</anno></c> and the system implied
               extension suffix, i.e. <c>.so</c>). The name by which
               the driver identifies itself must also be consistent
-              with this <c>Name</c> parameter, much as a beam-file's
+              with this <c><anno>Name</anno></c> parameter, much as a beam-file's
               module name much correspond to its filename.</p>
           </item>
-          <tag><em>OptionList</em></tag>
+          <tag><em><anno>OptionList</anno></em></tag>
           <item>
             <p>A number of options can be specified to control the
               loading operation. The options are given as a list of
               two-tuples, the tuples having the following values and
               meanings:</p>
             <taglist>
-              <tag><em>{driver_options, DriverOptionsList}</em></tag>
+              <tag><em>{driver_options, <anno>DriverOptionList</anno>}</em></tag>
               <item>
                 <p>This option is to provide options that will change
                   its general behavior and will "stick" to the driver
@@ -729,14 +700,14 @@
                   when the last <seealso marker="#users">user</seealso> calls <seealso marker="#try_unload/2">try_unload/2</seealso>, or
                   the last process having loaded the driver exits.</p>
               </item>
-              <tag><em>{monitor, MonitorOption}</em></tag>
+              <tag><em>{monitor, <anno>MonitorOption</anno>}</em></tag>
               <item>
-                <p>A <c>MonitorOption</c> tells <c>try_load/3</c> to
+                <p>A <c><anno>MonitorOption</anno></c> tells <c>try_load/3</c> to
                   trigger a driver monitor under certain
                   conditions. When the monitor is triggered, the
-                  function will return a three-tuple <c>{ok, PendingStatus, reference()}</c>, where the <c>reference()</c> is
+                  function will return a three-tuple <c>{ok, <anno>PendingStatus</anno>, reference()}</c>, where the <c>reference()</c> is
                   the monitor ref for the driver monitor.</p>
-                <p>Only one <c>MonitorOption</c> can be specified and
+                <p>Only one <c><anno>MonitorOption</anno></c> can be specified and
                   it is either the atom <c>pending</c>, which means
                   that a monitor should be created whenever a load
                   operation is delayed, and the atom
@@ -747,7 +718,7 @@
                   is present for completeness, it is very well defined
                   which reload-options might give rise to which
                   delays. It might, however, be a good idea to use the
-                  same <c>MonitorOption</c> as the <c>ReloadOption</c>
+                  same <c><anno>MonitorOption</anno></c> as the <c><anno>ReloadOption</anno></c>
                   if present.</p>
                 <p>If reloading is not requested, it might still be
                   useful to specify the <c>monitor</c> option, as
@@ -760,12 +731,12 @@
                   <c>{monitor, pending_driver}</c> in production
                   code (see the monitor discussion above). </p>
               </item>
-              <tag><em>{reload,RealoadOption}</em></tag>
+              <tag><em>{reload,<anno>ReloadOption</anno>}</em></tag>
               <item>
                 <p>This option is used when one wants to
                   <em>reload</em> a driver from disk, most often in a
                   code upgrade scenario. Having a <c>reload</c> option
-                  also implies that the <c>Path</c> parameter need
+                  also implies that the <c><anno>Path</anno></c> parameter need
                   <em>not</em> be consistent with earlier loads of
                   the driver.</p>
                 <p>To reload a driver, the process needs to have previously
@@ -814,9 +785,9 @@
           <tag><em>{error,inconsistent}</em></tag>
           <item>
             <p>The driver has already been loaded with either other
-              <c>DriverOptions</c> or a different <em>literal</em><c>Path</c> argument.</p>
+              <c><anno>DriverOptionList</anno></c> or a different <em>literal</em><c>Path</c> argument.</p>
             <p>This can happen even if a <c>reload</c> option is given,
-              if the <c>DriverOptions</c> differ from the current.</p>
+              if the <c>DriverOptionList</c> differ from the current.</p>
           </item>
           <tag><em>{error, permanent}</em></tag>
           <item>
@@ -830,19 +801,19 @@
           </item>
           <tag><em>{error, pending_reload}</em></tag>
           <item>
-            <p>Driver reload is already requested by another <seealso marker="#users">user</seealso> when the <c>{reload, ReloadOption}</c> option was given.</p>
+            <p>Driver reload is already requested by another <seealso marker="#users">user</seealso> when the <c>{reload, <anno>ReloadOption</anno>}</c> option was given.</p>
           </item>
           <tag><em>{error, not_loaded_by_this_process}</em></tag>
           <item>
             <p>Appears when the <c>reload</c> option is given. The
-              driver <c>Name</c> is present in the system, but there is no
+              driver <c><anno>Name</anno></c> is present in the system, but there is no
               <seealso marker="#users">user</seealso> of it in this
               process.</p>
           </item>
           <tag><em>{error, not_loaded}</em></tag>
           <item>
             <p>Appears when the <c>reload</c> option is given. The
-              driver <c>Name</c> is not in the system. Only drivers
+              driver <c><anno>Name</anno></c> is not in the system. Only drivers
               loaded by this process can be reloaded.</p>
           </item>
         </taglist>
@@ -856,18 +827,8 @@
       </desc>
     </func>
     <func>
-      <name>try_unload(Name, OptionList) -> {ok,Status} | {ok, PendingStatus, Ref} | {error, ErrorAtom}</name>
+      <name name="try_unload" arity="2"/>
       <fsummary>Unload a driver</fsummary>
-      <type>
-        <v>Name = string() | atom()</v>
-        <v>OptionList = [ Option ]</v>
-        <v>Option = {monitor, MonitorOption} | kill_ports</v>
-        <v>MonitorOption = pending_driver | pending</v>
-        <v>Status = unloaded | PendingStatus </v>
-        <v>PendingStatus = pending_driver | pending_process</v>
-        <v>Ref = reference()</v>
-        <v>ErrorAtom = linked_in_driver | not_loaded |  not_loaded_by_this_process | permanent</v>
-      </type>
       <desc>
         <p>This is the low level function to unload (or decrement
           reference counts of) a driver. It can be used to force port
@@ -948,15 +909,15 @@
         </taglist>
         <p>The function accepts the following parameters:</p>
         <taglist>
-          <tag><em>Name</em></tag>
+          <tag><em><anno>Name</anno></em></tag>
           <item>
             <p>The name parameter is the name of the driver to be
               unloaded. The name can be specified either as an
-              <c>io_list()</c> or as an <c>atom()</c>. </p>
+              <c>iolist()</c> or as an <c>atom()</c>. </p>
           </item>
-          <tag><em>OptionList</em></tag>
+          <tag><em><anno>OptionList</anno></em></tag>
           <item>
-            <p>The <c>OptionList</c> argument can be used to specify
+            <p>The <c><anno>OptionList</anno></c> argument can be used to specify
               certain behavior regarding ports as well as triggering
               monitors under certain conditions:</p>
             <taglist>
@@ -972,10 +933,10 @@
                   unloads, one should use the driver option
                   <c>kill_ports</c> when loading the driver instead.</p>
               </item>
-              <tag><em>{monitor, MonitorOption}</em></tag>
+              <tag><em>{monitor, <anno>MonitorOption</anno>}</em></tag>
               <item>
                 <p>This option creates a driver monitor if the condition
-                  given in <c>MonitorOptions</c> is true. The valid
+                  given in <c><anno>MonitorOption</anno></c> is true. The valid
                   options are:</p>
                 <taglist>
                   <tag><em>pending_driver</em></tag>
@@ -989,7 +950,7 @@
                       <c>{ok, pending_driver}</c> or <c>{ok, pending_process}</c>.</p>
                   </item>
                 </taglist>
-                <p>The <c>pending_driver</c> <c>MonitorOption</c> is by far
+                <p>The <c>pending_driver</c> <c><anno>MonitorOption</anno></c> is by far
                   the most useful and it has to be used to ensure that the
                   driver has really been unloaded and the ports closed
                   whenever the <c>kill_ports</c> option is used or the
@@ -1016,11 +977,11 @@
           </item>
           <tag><em>{error, not_loaded}</em></tag>
           <item>
-            <p>The driver <c>Name</c> is not present in the system.</p>
+            <p>The driver <c><anno>Name</anno></c> is not present in the system.</p>
           </item>
           <tag><em>{error, not_loaded_by_this_process}</em></tag>
           <item>
-            <p>The driver <c>Name</c> is present in the system, but
+            <p>The driver <c><anno>Name</anno></c> is present in the system, but
               there is no <seealso marker="#users">user</seealso> of
               it in this process. </p>
             <p>As a special case, drivers can be unloaded from
@@ -1088,12 +1049,8 @@
       </desc>
     </func>
     <func>
-      <name>loaded_drivers() -> {ok, Drivers}</name>
+      <name name="loaded_drivers" arity="0"/>
       <fsummary>List loaded drivers</fsummary>
-      <type>
-        <v>Drivers = [Driver]</v>
-        <v>Driver = string()</v>
-      </type>
       <desc>
         <p>Returns a list of all the available drivers, both
           (statically) linked-in and dynamically loaded ones.</p>
diff --git a/lib/kernel/doc/src/error_logger.xml b/lib/kernel/doc/src/error_logger.xml
index 2d95f96ac7..5781591cca 100644
--- a/lib/kernel/doc/src/error_logger.xml
+++ b/lib/kernel/doc/src/error_logger.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2011</year>
+      <year>1996</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -127,11 +127,8 @@ ok</pre>
       </desc>
     </func>
     <func>
-      <name>warning_map() -> Tag</name>
+      <name name="warning_map" arity="0"/>
       <fsummary>Return the current mapping for warning events</fsummary>
-      <type>
-        <v>Tag = error | warning | info</v>
-      </type>
       <desc>
         <p>Returns the current mapping for warning events. Events sent
           using <c>warning_msg/1,2</c> or <c>warning_report/1,2</c>
diff --git a/lib/kernel/doc/src/file.xml b/lib/kernel/doc/src/file.xml
index 772eff13cc..b2a259080d 100644
--- a/lib/kernel/doc/src/file.xml
+++ b/lib/kernel/doc/src/file.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2011</year>
+      <year>1996</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -412,7 +412,7 @@
       </desc>
     </func>
     <func>
-      <name>file_info(Filename) -> {ok, FileInfo} | {error, Reason}</name>
+      <name name="file_info" arity="1"/>
       <fsummary>Get information about a file (deprecated)</fsummary>
       <desc>
         <p>This function is obsolete. Use <c>read_file_info/1,2</c>
@@ -598,7 +598,7 @@
       </desc>
     </func>
     <func>
-      <name>native_name_encoding() -> latin1 | utf8</name>
+      <name name="native_name_encoding" arity="0"/>
       <fsummary>Return the VM's configured filename encoding.</fsummary>
       <desc>
         <p>This function returns the configured default file name encoding to use for raw file names. Generally an application supplying file names raw (as binaries), should obey the character encoding returned by this function.</p>
diff --git a/lib/kernel/doc/src/os.xml b/lib/kernel/doc/src/os.xml
index e94119845a..1bc5b9e464 100644
--- a/lib/kernel/doc/src/os.xml
+++ b/lib/kernel/doc/src/os.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1997</year><year>2011</year>
+      <year>1997</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -73,7 +73,7 @@ DirOut = os:cmd("dir"), % on Win32 platform</code>
       </desc>
     </func>
     <func>
-      <name>getenv() -> [string()]</name>
+      <name name="getenv" arity="0"/>
       <fsummary>List all environment variables</fsummary>
       <desc>
         <p>Returns a list of all environment variables.
@@ -83,55 +83,41 @@ DirOut = os:cmd("dir"), % on Win32 platform</code>
       </desc>
     </func>
     <func>
-      <name>getenv(VarName) -> Value | false</name>
+      <name name="getenv" arity="1"/>
       <fsummary>Get the value of an environment variable</fsummary>
-      <type>
-        <v>VarName = string() </v>
-        <v>Value = string()</v>
-      </type>
       <desc>
-        <p>Returns the <c>Value</c> of the environment variable
-          <c>VarName</c>, or <c>false</c> if the environment variable
+        <p>Returns the <c><anno>Value</anno></c> of the environment variable
+          <c><anno>VarName</anno></c>, or <c>false</c> if the environment variable
           is undefined.</p>
       </desc>
     </func>
     <func>
-      <name>getpid() -> Value </name>
+      <name name="getpid" arity="0"/>
       <fsummary>Return the process identifier of the emulator process</fsummary>
-      <type>
-        <v>Value = string()</v>
-      </type>
       <desc>
         <p>Returns the process identifier of the current Erlang emulator
           in the format most commonly used by the operating system
-          environment. <c>Value</c> is returned as a string containing
+          environment. <c><anno>Value</anno></c> is returned as a string containing
           the (usually) numerical identifier for a process. On Unix,
           this is typically the return value of the <c>getpid()</c>
-          system call. On VxWorks, <c>Value</c> contains the task id
+          system call. On VxWorks, <c><anno>Value</anno></c> contains the task id
           (decimal notation) of the Erlang task. On Windows,
           the process id as returned by the <c>GetCurrentProcessId()</c>
           system call is used.</p>
       </desc>
     </func>
     <func>
-      <name>putenv(VarName, Value) -> true</name>
+      <name name="putenv" arity="2"/>
       <fsummary>Set a new value for an environment variable</fsummary>
-      <type>
-        <v>VarName = string() </v>
-        <v>Value = string()</v>
-      </type>
       <desc>
-        <p>Sets a new <c>Value</c> for the environment variable
-          <c>VarName</c>.</p>
+        <p>Sets a new <c><anno>Value</anno></c> for the environment variable
+          <c><anno>VarName</anno></c>.</p>
       </desc>
     </func>
     <func>
-      <name>timestamp() -> Timestamp</name>
+      <name name="timestamp" arity="0"/>
+      <type_desc variable="Timestamp">Timestamp = {MegaSecs, Secs, MicroSecs}</type_desc>
       <fsummary>Returna a timestamp from the OS in the erlang:now/0 format</fsummary>
-      <type>
-        <v>Timestamp = {MegaSecs, Secs, MicroSecs} = <seealso marker="erts:erlang#type-timestamp">erlang:timestamp()</seealso></v>
-        <v>MegaSecs = Secs = MicroSecs = integer() >= 0</v>
-      </type>
       <desc>
       <p>Returns a tuple in the same format as <seealso marker="erts:erlang#now/0">erlang:now/0</seealso>. The difference is that this function returns what the operating system thinks (a.k.a. the wall clock time) without any attempts at time correction. The result of two different calls to this function is <em>not</em> guaranteed to be different.</p>
       <p>The most obvious use for this function is logging. The tuple can be used together with the function <seealso marker="stdlib:calendar#now_to_universal_time/1">calendar:now_to_universal_time/1</seealso> 
diff --git a/lib/kernel/src/code.erl b/lib/kernel/src/code.erl
index b7fda69ce0..a9259817ea 100644
--- a/lib/kernel/src/code.erl
+++ b/lib/kernel/src/code.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -70,46 +70,6 @@
 
 -include_lib("kernel/include/file.hrl").
 
-%% User interface.
-%%
-%% objfile_extension()		 -> ".beam"
-%% get_path()			 -> [Dir]
-%% set_path([Dir])		 -> true | {error, bad_directory | bad_path}
-%% add_path(Dir)		 -> true | {error, bad_directory}
-%% add_patha(Dir)		 -> true | {error, bad_directory}
-%% add_pathz(Dir)		 -> true | {error, bad_directory}
-%% add_paths([Dir])              -> ok
-%% add_pathsa([Dir])             -> ok
-%% add_pathsz([Dir])             -> ok
-%% del_path(Dir)		 -> boolean() | {error, bad_name}
-%% replace_path(Name, Dir)       -> true | {error, bad_directory | bad_name
-%%                                                 | {badarg,_}}
-%% load_file(Module)		 -> {module, Module} | {error, What :: atom()}
-%% load_abs(File)		 -> {module, Module} | {error, What :: atom()}
-%% load_abs(File, Module)	 -> {module, Module} | {error, What :: atom()}
-%% load_binary(Module, File, Bin)-> {module, Module} | {error, What :: atom()}
-%% ensure_loaded(Module)         -> {module, Module} | {error, What :: atom()}
-%% delete(Module)                -> boolean()
-%% purge(Module)                 -> boolean()  kills all procs running old code
-%% soft_purge(Module)            -> boolean()
-%% is_loaded(Module)	         -> {file, loaded_filename()} | false
-%% all_loaded()		         -> [{Module, loaded_filename()}]
-%% get_object_code(Module)       -> {Module, Bin, Filename} | error
-%% stop()                        -> no_return()
-%% root_dir()                    -> Dir
-%% compiler_dir()                -> Dir
-%% lib_dir()                     -> Dir
-%% lib_dir(Application)          -> Dir | {error, bad_name}
-%% priv_dir(Application)         -> Dir | {error, bad_name}
-%% stick_dir(Dir)                -> ok | error
-%% unstick_dir(Dir)              -> ok | error
-%% stick_mod(Module)             -> true
-%% unstick_mod(Module)           -> true
-%% is_sticky(Module)             -> boolean()
-%% which(Module)                 -> Filename | loaded_ret_atoms() | non_existing
-%% set_primary_archive((FileName, Bin, FileInfo) -> ok | {error, Reason}
-%% clash()                       -> ok         prints out number of clashes
-
 %%----------------------------------------------------------------------------
 %% Some types for basic exported functions of this module
 %%----------------------------------------------------------------------------
@@ -125,6 +85,39 @@
 -type loaded_ret_atoms() :: 'cover_compiled' | 'preloaded'.
 -type loaded_filename() :: (Filename :: file:filename()) | loaded_ret_atoms().
 
+%%% BIFs
+
+-export([get_chunk/2, is_module_native/1, make_stub_module/3, module_md5/1]).
+
+-spec get_chunk(Bin, Chunk) ->
+                       binary() | undefined when
+      Bin :: binary(),
+      Chunk :: string().
+
+get_chunk(_, _) ->
+    erlang:nif_error(undef).
+
+-spec is_module_native(Module) -> true | false | undefined when
+      Module :: module().
+
+is_module_native(_) ->
+    erlang:nif_error(undef).
+
+-spec make_stub_module(Module, Beam, Info) -> Module when
+      Module :: module(),
+      Beam :: binary(),
+      Info :: {list(), list()}.
+
+make_stub_module(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec module_md5(binary()) -> binary() | undefined.
+
+module_md5(_) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 %%----------------------------------------------------------------------------
 %% User interface
 %%----------------------------------------------------------------------------
diff --git a/lib/kernel/src/erl_ddll.erl b/lib/kernel/src/erl_ddll.erl
index 646cac99c5..f967fcc2ef 100644
--- a/lib/kernel/src/erl_ddll.erl
+++ b/lib/kernel/src/erl_ddll.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -30,9 +30,99 @@
 %%----------------------------------------------------------------------------
 
 -type path()   :: string() | atom().
--type driver() :: string() | atom().
+-type driver() :: iolist() | atom().
 
 %%----------------------------------------------------------------------------
+%%% BIFs
+
+-export([demonitor/1, info/2, format_error_int/1, monitor/2,
+         try_load/3, try_unload/2, loaded_drivers/0]).
+
+-spec demonitor(MonitorRef) -> ok when
+      MonitorRef :: reference().
+
+demonitor(_) ->
+    erlang:nif_error(undef).
+
+-spec info(Name, Tag) -> Value when
+      Name :: driver(),
+      Tag :: processes | driver_options | port_count | linked_in_driver
+           | permanent | awaiting_load | awaiting_unload,
+      Value :: term().
+
+info(_, _) ->
+    erlang:nif_error(undef).
+
+-spec format_error_int(ErrSpec) -> string() when
+      ErrSpec :: inconsisten | linked_in_driver | permanent
+               | not_loaded | not_loaded_by_this_process | not_pending
+               | already_loaded | unloading.
+
+format_error_int(_) ->
+    erlang:nif_error(undef).
+
+-spec monitor(Tag, Item) -> MonitorRef when
+      Tag :: driver,
+      Item :: {Name, When},
+      Name :: driver(),
+      When :: loaded | unloaded | unloaded_only,
+      MonitorRef :: reference().
+
+monitor(_, _) ->
+    erlang:nif_error(undef).
+
+-spec try_load(Path, Name, OptionList) ->
+                      {ok,Status} |
+                      {ok, PendingStatus, Ref} |
+                      {error, ErrorDesc} when
+      Path :: path(),
+      Name :: driver(),
+      OptionList :: [Option],
+      Option :: {driver_options, DriverOptionList}
+              | {monitor, MonitorOption}
+              | {reload, ReloadOption},
+      DriverOptionList :: [DriverOption],
+      DriverOption :: kill_ports,
+      MonitorOption :: pending_driver | pending,
+      ReloadOption :: pending_driver | pending,
+      Status :: loaded | already_loaded | PendingStatus,
+      PendingStatus :: pending_driver | pending_process,
+      Ref :: reference(),
+      ErrorDesc :: ErrorAtom | OpaqueError,
+      ErrorAtom :: linked_in_driver | inconsistent | permanent
+                 | not_loaded_by_this_process | not_loaded
+                 |  pending_reload | pending_process,
+      OpaqueError :: term().
+
+try_load(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec try_unload(Name, OptionList) ->
+                        {ok, Status} |
+                        {ok, PendingStatus, Ref} |
+                        {error, ErrorAtom} when
+      Name :: driver(),
+      OptionList :: [Option],
+      Option :: {monitor, MonitorOption} | kill_ports,
+      MonitorOption :: pending_driver | pending,
+      Status :: unloaded | PendingStatus,
+      PendingStatus :: pending_driver | pending_process,
+      Ref :: reference(),
+      ErrorAtom :: linked_in_driver | not_loaded |
+                   not_loaded_by_this_process | permanent.
+
+try_unload(_, _) ->
+    erlang:nif_error(undef).
+
+-spec loaded_drivers() -> {ok, Drivers} when
+      Drivers :: [Driver],
+      Driver :: string().
+
+loaded_drivers() ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 
 -spec start() -> {'error', {'already_started', 'undefined'}}.
 
diff --git a/lib/kernel/src/error_logger.erl b/lib/kernel/src/error_logger.erl
index f94cca000f..92c1eb80dc 100644
--- a/lib/kernel/src/error_logger.erl
+++ b/lib/kernel/src/error_logger.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -42,6 +42,18 @@
 
 -type state()   :: {non_neg_integer(), non_neg_integer(), [term()]}.
 
+%%% BIF
+
+-export([warning_map/0]).
+
+-spec warning_map() -> Tag when
+      Tag :: error | warning | info.
+
+warning_map() ->
+    erlang:nif_error(undef).
+
+%%% End of BIF
+
 %%-----------------------------------------------------------------
 
 -spec start() -> {'ok', pid()} | {'error', any()}.
diff --git a/lib/kernel/src/erts_debug.erl b/lib/kernel/src/erts_debug.erl
index 7d6a5ade94..b3d54ddc1d 100644
--- a/lib/kernel/src/erts_debug.erl
+++ b/lib/kernel/src/erts_debug.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1999-2009. All Rights Reserved.
+%% Copyright Ericsson AB 1999-2012. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -28,6 +28,135 @@
 %%   same/2
 %%   flat_size/1
 
+%%% BIFs
+
+-export([breakpoint/2, disassemble/1, display/1, dist_ext_to_term/2,
+         dump_monitors/1, dump_links/1, flat_size/1,
+         get_internal_state/1, instructions/0, lock_counters/1,
+         same/2, set_internal_state/2]).
+
+-spec breakpoint(MFA, Flag) -> non_neg_integer() when
+      MFA :: {Module :: module(),
+              Function :: atom(),
+              Arity :: arity() | '_'},
+      Flag :: boolean().
+
+breakpoint(_, _) ->
+    erlang:nif_error(undef).
+
+-spec disassemble(What) -> false | undef | Result when
+      What :: MFA | Address,
+      Result :: {Address, Code, MFA},
+      MFA :: mfa(),
+      Address :: non_neg_integer(),
+      Code :: binary().
+
+disassemble(_) ->
+    erlang:nif_error(undef).
+
+-spec display(Term) -> string() when
+      Term :: term().
+
+display(_) ->
+    erlang:nif_error(undef).
+
+-spec dist_ext_to_term(Tuple, Binary) -> term() when
+      Tuple :: tuple(),
+      Binary :: binary().
+
+dist_ext_to_term(_, _) ->
+    erlang:nif_error(undef).
+
+-spec dump_monitors(Id) -> true when
+      Id :: pid() | atom().
+
+dump_monitors(_) ->
+    erlang:nif_error(undef).
+
+-spec dump_links(Id) -> true when
+      Id :: pid() | port() | atom().
+
+dump_links(_) ->
+    erlang:nif_error(undef).
+
+-spec flat_size(Term) -> non_neg_integer() when
+      Term :: term().
+
+flat_size(_) ->
+    erlang:nif_error(undef).
+
+-spec get_internal_state(W) -> term() when
+      W :: reds_left | node_and_dist_references | monitoring_nodes
+         | next_pid | 'DbTable_words' | check_io_debug
+         | process_info_args | processes | processes_bif_info
+         | max_atom_out_cache_index | nbalance | available_internal_state
+         | force_heap_frags | memory
+         | {process_status, pid()}
+         | {link_list, pid() | port() | node()}
+         | {monitor_list, pid() | node()}
+         | {channel_number, non_neg_integer()}
+         | {have_pending_exit, pid() | port() | atom()}
+         | {binary_info, binary()}
+         | {term_to_binary_no_funs, term()}
+         | {dist_port, port()}
+         | {atom_out_cache_index, atom()}
+         | {fake_scheduler_bindings,
+            default_bind | spread | processor_spread | thread_spread
+            | thread_no_node_processor_spread | no_node_processor_spread
+            | no_node_thread_spread | no_spread | unbound}
+         | {reader_groups_map, non_neg_integer()}.
+
+get_internal_state(_) ->
+    erlang:nif_error(undef).
+
+-spec instructions() -> [string()].
+
+instructions() ->
+    erlang:nif_error(undef).
+
+-spec lock_counters(info) -> term();
+                      (clear) -> ok;
+                      ({copy_save, boolean()}) -> boolean();
+                      ({process_locks, boolean()}) -> boolean().
+
+lock_counters(_) ->
+    erlang:nif_error(undef).
+
+-spec same(Term1, Term2) -> boolean() when
+      Term1 :: term(),
+      Term2 :: term().
+
+same(_, _) ->
+    erlang:nif_error(undef).
+
+-spec set_internal_state(available_internal_state, boolean()) -> boolean();
+                           (reds_left, non_neg_integer()) -> true;
+                           (block, non_neg_integer()) -> true;
+                           (sleep, non_neg_integer()) -> true;
+                           (block_scheduler, non_neg_integer()) -> true;
+                           (next_pid, non_neg_integer()) -> false | integer();
+                           (force_gc, pid() | atom()) -> boolean();
+                           (send_fake_exit_signal, {pid() | port(), pid(), term()}) -> dead | message | unaffected | exit;
+                           (colliding_names, {atom(), non_neg_integer()}) ->
+                                   [atom()];
+                           (binary_loop_limit, default) -> -1;
+                           (binary_loop_limit, non_neg_integer()) -> non_neg_integer();
+                           (re_loop_limit, default) -> -1;
+                           (re_loop_limit, non_neg_integer()) -> non_neg_integer();
+                           (unicode_loop_limit, default) -> -1;
+                           (unicode_loop_limit, non_neg_integer()) -> non_neg_integer();
+                           (hipe_test_reschedule_suspend, term()) -> nil();
+                           (hipe_test_reschedule_resume, pid() | port()) -> boolean();
+                           (test_long_gc_sleep, non_neg_integer()) -> true;
+                           (kill_dist_connection, port()) -> boolean();
+                           (not_running_optimization, boolean()) -> boolean();
+                           (wait, deallocations) -> ok.
+
+set_internal_state(_, _) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 %% size(Term)
 %%  Returns the size of Term in actual heap words. Shared subterms are
 %%  counted once.  Example: If A = [a,b], B =[A,A] then size(B) returns 8,
diff --git a/lib/kernel/src/file.erl b/lib/kernel/src/file.erl
index 4028dd4f0b..101a830ad3 100644
--- a/lib/kernel/src/file.erl
+++ b/lib/kernel/src/file.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -111,6 +111,24 @@
 -type sendfile_option() :: {chunk_size, non_neg_integer()}.
 -type file_info_option() :: {'time', 'local'} | {'time', 'universal'} 
 			  | {'time', 'posix'}.
+%%% BIFs
+
+-export([file_info/1, native_name_encoding/0]).
+
+-spec file_info(Filename) -> {ok, FileInfo} | {error, Reason} when
+      Filename :: name(),
+      FileInfo :: file_info(),
+      Reason :: posix() | badarg.
+
+file_info(_) ->
+    erlang:nif_error(undef).
+
+-spec native_name_encoding() -> latin1 | utf8.
+
+native_name_encoding() ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
 
 
 %%%-----------------------------------------------------------------
diff --git a/lib/kernel/src/net_kernel.erl b/lib/kernel/src/net_kernel.erl
index 9e3d730cee..0d59e7af67 100644
--- a/lib/kernel/src/net_kernel.erl
+++ b/lib/kernel/src/net_kernel.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -142,6 +142,17 @@
 
 -include("net_address.hrl").
 
+%%% BIF
+
+-export([dflag_unicode_io/1]).
+
+-spec dflag_unicode_io(pid()) -> boolean().
+
+dflag_unicode_io(_) ->
+    erlang:nif_error(undef).
+
+%%% End of BIF
+
 %% Interface functions
 
 kernel_apply(M,F,A) ->         request({apply,M,F,A}).
diff --git a/lib/kernel/src/os.erl b/lib/kernel/src/os.erl
index f6769df585..b986f3a61e 100644
--- a/lib/kernel/src/os.erl
+++ b/lib/kernel/src/os.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1997-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1997-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -24,6 +24,42 @@
 
 -include("file.hrl").
 
+%%% BIFs
+
+-export([getenv/0, getenv/1, getpid/0, putenv/2, timestamp/0]).
+
+-spec getenv() -> [string()].
+
+getenv() -> erlang:nif_error(undef).
+
+-spec getenv(VarName) -> Value | false when
+      VarName :: string(),
+      Value :: string().
+
+getenv(_) ->
+    erlang:nif_error(undef).
+
+-spec getpid() -> Value when
+      Value :: string().
+
+getpid() ->
+    erlang:nif_error(undef).
+
+-spec putenv(VarName, Value) -> true when
+      VarName :: string(),
+      Value :: string().
+
+putenv(_, _) ->
+    erlang:nif_error(undef).
+
+-spec timestamp() -> Timestamp when
+      Timestamp :: erlang:timestamp().
+
+timestamp() ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 -spec type() -> vxworks | {Osfamily, Osname} when
       Osfamily :: unix | win32,
       Osname :: atom().
diff --git a/lib/stdlib/doc/src/binary.xml b/lib/stdlib/doc/src/binary.xml
index 88ce77e0d0..06cfad0b0b 100644
--- a/lib/stdlib/doc/src/binary.xml
+++ b/lib/stdlib/doc/src/binary.xml
@@ -5,7 +5,7 @@
   <header>
     <copyright>
       <year>2009</year>
-      <year>2011</year>
+      <year>2012</year>
       <holder>Ericsson AB, All Rights Reserved</holder>
     </copyright>
     <legalnotice>
@@ -77,41 +77,30 @@
   </datatypes>
   <funcs>
     <func>
-      <name>at(Subject, Pos) -> byte()</name>
+    <name name="at" arity="2"/>
       <fsummary>Returns the byte at a specific position in a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Pos = integer() >= 0</v>
-      </type>
       <desc>
 
-      <p>Returns the byte at position <c>Pos</c> (zero-based) in the binary
-      <c>Subject</c> as an integer. If <c>Pos</c> &gt;= <c>byte_size(Subject)</c>,
+      <p>Returns the byte at position <c><anno>Pos</anno></c> (zero-based) in the binary
+      <c><anno>Subject</anno></c> as an integer. If <c><anno>Pos</anno></c> &gt;= <c>byte_size(<anno>Subject</anno>)</c>,
       a <c>badarg</c>
       exception is raised.</p>
 
       </desc>
     </func>
     <func>
-      <name>bin_to_list(Subject) -> [byte()]</name>
+      <name name="bin_to_list" arity="1"/>
       <fsummary>Convert a binary to a list of integers</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-      </type>
       <desc>
-      <p>The same as <c>bin_to_list(Subject,{0,byte_size(Subject)})</c>.</p>
+      <p>The same as <c>bin_to_list(<anno>Subject</anno>,{0,byte_size(<anno>Subject</anno>)})</c>.</p>
       </desc>
     </func>
     <func>
-      <name>bin_to_list(Subject, PosLen) -> [byte()]</name>
+      <name name="bin_to_list" arity="2"/>
       <fsummary>Convert a binary to a list of integers</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>PosLen = part()</v>
-      </type>
       <desc>
 
-      <p>Converts <c>Subject</c> to a list of <c>byte()</c>s, each representing
+      <p>Converts <c><anno>Subject</anno></c> to a list of <c>byte()</c>s, each representing
       the value of one byte. The <c>part()</c> denotes which part of the
       <c>binary()</c> to convert. Example:</p>
 
@@ -120,27 +109,19 @@
 "rla"
 %% or [114,108,97] in list notation.
 </code>
-      <p>If <c>PosLen</c> in any way references outside the binary, a <c>badarg</c> exception is raised.</p>
+      <p>If <c><anno>PosLen</anno></c> in any way references outside the binary, a <c>badarg</c> exception is raised.</p>
       </desc>
     </func>
     <func>
-      <name>bin_to_list(Subject, Pos, Len) -> [byte()]</name>
+      <name name="bin_to_list" arity="3"/>
       <fsummary>Convert a binary to a list of integers</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Pos = integer() >= 0</v>
-        <v>Len = integer() >= 0</v>
-      </type>
       <desc>
-      <p>The same as<c> bin_to_list(Subject,{Pos,Len})</c>.</p>
+      <p>The same as<c> bin_to_list(<anno>Subject</anno>,{<anno>Pos</anno>,<anno>Len</anno>})</c>.</p>
       </desc>
     </func>
     <func>
-      <name>compile_pattern(Pattern) -> cp()</name>
+      <name name="compile_pattern" arity="1"/>
       <fsummary>Pre-compiles a binary search pattern</fsummary>
-      <type>
-        <v>Pattern = binary() | [ binary() ]</v>
-      </type>
       <desc>
 
       <p>Builds an internal structure representing a compilation of a
@@ -155,7 +136,7 @@
       <p>When a list of binaries is given, it denotes a set of
       alternative binaries to search for. I.e if
       <c>[&lt;&lt;"functional"&gt;&gt;,&lt;&lt;"programming"&gt;&gt;]</c>
-      is given as <c>Pattern</c>, this
+      is given as <c><anno>Pattern</anno></c>, this
       means "either <c>&lt;&lt;"functional"&gt;&gt;</c> or
       <c>&lt;&lt;"programming"&gt;&gt;</c>". The pattern is a set of
       alternatives; when only a single binary is given, the set has
@@ -163,32 +144,25 @@
 
       <p>The list of binaries used for search alternatives shall be flat and proper.</p>
 
-      <p>If <c>Pattern</c> is not a binary or a flat proper list of binaries with length &gt; 0,
+      <p>If <c><anno>Pattern</anno></c> is not a binary or a flat proper list of binaries with length &gt; 0,
       a <c>badarg</c> exception will be raised.</p>
 
       </desc>
     </func>
     <func>
-      <name>copy(Subject) -> binary()</name>
+      <name name="copy" arity="1"/>
       <fsummary>Creates a duplicate of a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-      </type>
       <desc>
-      <p>The same as <c>copy(Subject, 1)</c>.</p>
+      <p>The same as <c>copy(<anno>Subject</anno>, 1)</c>.</p>
       </desc>
     </func>
     <func>
-      <name>copy(Subject,N) -> binary()</name>
+      <name name="copy" arity="2"/>
       <fsummary>Duplicates a binary N times and creates a new</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>N = integer() >= 0</v>
-      </type>
       <desc>
-      <p>Creates a binary with the content of <c>Subject</c> duplicated <c>N</c> times.</p>
+      <p>Creates a binary with the content of <c><anno>Subject</anno></c> duplicated <c><anno>N</anno></c> times.</p>
 
-      <p>This function will always create a new binary, even if <c>N =
+      <p>This function will always create a new binary, even if <c><anno>N</anno> =
       1</c>. By using <c>copy/1</c> on a binary referencing a larger binary, one
       might free up the larger binary for garbage collection.</p>
 
@@ -201,32 +175,23 @@
       large binaries are no longer used in any process, deliberate
       copying might be a good idea.</p> </note>
 
-      <p>If <c>N</c> &lt; <c>0</c>, a <c>badarg</c> exception is raised.</p>
+      <p>If <c><anno>N</anno></c> &lt; <c>0</c>, a <c>badarg</c> exception is raised.</p>
       </desc>
     </func>
     <func>
-      <name>decode_unsigned(Subject) -> Unsigned</name>
+      <name name="decode_unsigned" arity="1"/>
       <fsummary>Decode a whole binary into an integer of arbitrary size</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Unsigned = integer() >= 0</v>
-      </type>
       <desc>
-      <p>The same as <c>decode_unsigned(Subject,big)</c>.</p>
+      <p>The same as <c>decode_unsigned(<anno>Subject</anno>, big)</c>.</p>
       </desc>
     </func>
     <func>
-      <name>decode_unsigned(Subject, Endianess) -> Unsigned</name>
+      <name name="decode_unsigned" arity="2"/>
       <fsummary>Decode a whole binary into an integer of arbitrary size</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Endianess = big | little</v>
-        <v>Unsigned = integer() >= 0</v>
-      </type>
       <desc>
 
       <p>Converts the binary digit representation, in big or little
-      endian, of a positive integer in <c>Subject</c> to an Erlang <c>integer()</c>.</p>
+      endian, of a positive integer in <c><anno>Subject</anno></c> to an Erlang <c>integer()</c>.</p>
 
       <p>Example:</p>
 
@@ -237,22 +202,15 @@
       </desc>
     </func>
     <func>
-      <name>encode_unsigned(Unsigned) -> binary()</name>
+      <name name="encode_unsigned" arity="1"/>
       <fsummary>Encodes an unsigned integer into the minimal binary</fsummary>
-      <type>
-        <v>Unsigned = integer() >= 0</v>
-      </type>
       <desc>
-      <p>The same as <c>encode_unsigned(Unsigned,big)</c>.</p>
+      <p>The same as <c>encode_unsigned(<anno>Unsigned</anno>, big)</c>.</p>
       </desc>
     </func>
     <func>
-      <name>encode_unsigned(Unsigned,Endianess) -> binary()</name>
+      <name name="encode_unsigned" arity="2"/>
       <fsummary>Encodes an unsigned integer into the minimal binary</fsummary>
-      <type>
-        <v>Unsigned = integer() >= 0</v>
-        <v>Endianess = big | little</v>
-      </type>
       <desc>
 
       <p>Converts a positive integer to the smallest possible
@@ -268,51 +226,39 @@
       </desc>
     </func>
     <func>
-      <name>first(Subject) -> byte()</name>
+      <name name="first" arity="1"/>
       <fsummary>Returns the first byte of a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-      </type>
       <desc>
 
-      <p>Returns the first byte of the binary <c>Subject</c> as an integer. If the
-      size of <c>Subject</c> is zero, a <c>badarg</c> exception is raised.</p>
+      <p>Returns the first byte of the binary <c><anno>Subject</anno></c> as an integer. If the
+      size of <c><anno>Subject</anno></c> is zero, a <c>badarg</c> exception is raised.</p>
 
       </desc>
     </func>
     <func>
-      <name>last(Subject) -> byte()</name>
+      <name name="last" arity="1"/>
       <fsummary>Returns the last byte of a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-      </type>
       <desc>
 
-      <p>Returns the last byte of the binary <c>Subject</c> as an integer. If the
-      size of <c>Subject</c> is zero, a <c>badarg</c> exception is raised.</p>
+      <p>Returns the last byte of the binary <c><anno>Subject</anno></c> as an integer. If the
+      size of <c><anno>Subject</anno></c> is zero, a <c>badarg</c> exception is raised.</p>
 
       </desc>
     </func>
     <func>
-      <name>list_to_bin(ByteList) -> binary()</name>
+      <name name="list_to_bin" arity="1"/>
       <fsummary>Convert a list of integers and binaries to a binary</fsummary>
-      <type>
-        <v>ByteList = iodata() (see module erlang)</v>
-      </type>
       <desc>
       <p>Works exactly as <c>erlang:list_to_binary/1</c>, added for completeness.</p>
       </desc>
     </func>
     <func>
-      <name>longest_common_prefix(Binaries) -> integer() >= 0</name>
+      <name name="longest_common_prefix" arity="1"/>
       <fsummary>Returns length of longest common prefix for a set of binaries</fsummary>
-      <type>
-        <v>Binaries = [ binary() ]</v>
-      </type>
       <desc>
 
       <p>Returns the length of the longest common prefix of the
-      binaries in the list <c>Binaries</c>. Example:</p>
+      binaries in the list <c><anno>Binaries</anno></c>. Example:</p>
 
 <code>
 1> binary:longest_common_prefix([&lt;&lt;"erlang"&gt;&gt;,&lt;&lt;"ergonomy"&gt;&gt;]).
@@ -321,19 +267,16 @@
 0
 </code>
 
-      <p>If <c>Binaries</c> is not a flat list of binaries, a <c>badarg</c> exception is raised.</p>
+      <p>If <c><anno>Binaries</anno></c> is not a flat list of binaries, a <c>badarg</c> exception is raised.</p>
       </desc>
     </func>
     <func>
-      <name>longest_common_suffix(Binaries) -> integer() >= 0</name>
+      <name name="longest_common_suffix" arity="1"/>
       <fsummary>Returns length of longest common suffix for a set of binaries</fsummary>
-      <type>
-        <v>Binaries = [ binary() ]</v>
-      </type>
       <desc>
 
       <p>Returns the length of the longest common suffix of the
-      binaries in the list <c>Binaries</c>. Example:</p>
+      binaries in the list <c><anno>Binaries</anno></c>. Example:</p>
 
 <code>
 1> binary:longest_common_suffix([&lt;&lt;"erlang"&gt;&gt;,&lt;&lt;"fang"&gt;&gt;]).
@@ -347,35 +290,24 @@
       </desc>
     </func>
     <func>
-      <name>match(Subject, Pattern) -> Found | <c>nomatch</c></name>
+      <name name="match" arity="2"/>
       <fsummary>Searches for the first match of a pattern in a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-	<v>Pattern = binary() | [ binary() ] | cp()</v>
-	<v>Found = part()</v>
-      </type>
       <desc>
-      <p>The same as <c>match(Subject, Pattern, [])</c>.</p>
+      <p>The same as <c>match(<anno>Subject</anno>, <anno>Pattern</anno>, [])</c>.</p>
       </desc>
     </func>
     <func>
-      <name>match(Subject,Pattern,Options) -> Found | <c>nomatch</c></name>
+      <name name="match" arity="3"/>
+      <type name="part"/>
       <fsummary>Searches for the first match of a pattern in a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-	<v>Pattern = binary() | [ binary() ] | cp()</v>
-	<v>Found = part()</v>
-        <v>Options = [ Option ]</v>
-	<v>Option = {scope, part()}</v>
-      </type>
       <desc>
 
-      <p>Searches for the first occurrence of <c>Pattern</c> in <c>Subject</c> and
+      <p>Searches for the first occurrence of <c><anno>Pattern</anno></c> in <c><anno>Subject</anno></c> and
       returns the position and length.</p>
 
-      <p>The function will return <c>{Pos,Length}</c> for the binary
-      in <c>Pattern</c> starting at the lowest position in
-      <c>Subject</c>, Example:</p>
+      <p>The function will return <c>{Pos, Length}</c> for the binary
+      in <c><anno>Pattern</anno></c> starting at the lowest position in
+      <c><anno>Subject</anno></c>, Example:</p>
 
 <code>
 1> binary:match(&lt;&lt;"abcde"&gt;&gt;, [&lt;&lt;"bcde"&gt;&gt;,&lt;&lt;"cd"&gt;&gt;],[]).
@@ -391,16 +323,16 @@
       <p>Summary of the options:</p>
 
       <taglist>
-      <tag>{scope, {Start, Length}}</tag>
+      <tag>{scope, {<anno>Start</anno>, <anno>Length</anno>}}</tag>
       <item><p>Only the given part is searched. Return values still have
-      offsets from the beginning of <c>Subject</c>. A negative <c>Length</c> is
-      allowed as described in the <c>TYPES</c> section of this manual.</p></item>
+      offsets from the beginning of <c><anno>Subject</anno></c>. A negative <c>Length</c> is
+      allowed as described in the <c>DATA TYPES</c> section of this manual.</p></item>
       </taglist>
 
       <p>If none of the strings in
-      <c>Pattern</c> is found, the atom <c>nomatch</c> is returned.</p>
+      <c><anno>Pattern</anno></c> is found, the atom <c>nomatch</c> is returned.</p>
 
-      <p>For a description of <c>Pattern</c>, see
+      <p>For a description of <c><anno>Pattern</anno></c>, see
       <seealso marker="#compile_pattern-1">compile_pattern/1</seealso>.</p>
 
       <p>If <c>{scope, {Start,Length}}</c> is given in the options
@@ -412,32 +344,21 @@
       </desc>
     </func>
     <func>
-      <name>matches(Subject, Pattern) -> Found</name>
+      <name name="matches" arity="2"/>
       <fsummary>Searches for all matches of a pattern in a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Pattern = binary() | [ binary() ] | cp()</v>
-        <v>Found = [ part() ] | []</v>
-      </type>
       <desc>
-      <p>The same as <c>matches(Subject, Pattern, [])</c>.</p>
+      <p>The same as <c>matches(<anno>Subject</anno>, <anno>Pattern</anno>, [])</c>.</p>
       </desc>
     </func>
     <func>
-      <name>matches(Subject,Pattern,Options) -> Found</name>
+      <name name="matches" arity="3"/>
+      <type name="part"/>
       <fsummary>Searches for all matches of a pattern in a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Pattern = binary() | [ binary() ] | cp()</v>
-        <v>Found = [ part() ] | []</v>
-        <v>Options = [ Option ]</v>
-        <v>Option = {scope, part()}</v>
-      </type>
       <desc>
 
-      <p>Works like match, but the <c>Subject</c> is searched until
+      <p>Works like <c>match/2</c>, but the <c><anno>Subject</anno></c> is searched until
       exhausted and a list of all non-overlapping parts matching
-      <c>Pattern</c> is returned (in order). </p>
+      <c><anno>Pattern</anno></c> is returned (in order). </p>
 
       <p>The first and longest match is preferred to a shorter,
       which is illustrated by the following example:</p>
@@ -458,26 +379,22 @@
 
        <p>If none of the strings in pattern is found, an empty list is returned.</p>
 
-       <p>For a description of <c>Pattern</c>, see <seealso marker="#compile_pattern-1">compile_pattern/1</seealso> and for a
+       <p>For a description of <c><anno>Pattern</anno></c>, see <seealso marker="#compile_pattern-1">compile_pattern/1</seealso> and for a
        description of available options, see <seealso marker="#match-3">match/3</seealso>.</p>
 
-       <p>If <c>{scope, {Start,Length}}</c> is given in the options such that
-       <c>Start</c> is larger than the size of <c>Subject</c>, <c>Start + Length</c> is
-       less than zero or <c>Start + Length</c> is larger than the size of
-       <c>Subject</c>, a <c>badarg</c> exception is raised.</p>
+       <p>If <c>{scope, {<anno>Start</anno>,<anno>Length</anno>}}</c> is given in the options such that
+       <c><anno>Start</anno></c> is larger than the size of <c><anno>Subject</anno></c>, <c><anno>Start</anno> + <anno>Length</anno></c> is
+       less than zero or <c><anno>Start</anno> + <anno>Length</anno></c> is larger than the size of
+       <c><anno>Subject</anno></c>, a <c>badarg</c> exception is raised.</p>
 
      </desc>
     </func>
     <func>
-      <name>part(Subject, PosLen) -> binary()</name>
+      <name name="part" arity="2"/>
       <fsummary>Extracts a part of a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>PosLen = part()</v>
-      </type>
       <desc>
 
-      <p>Extracts the part of the binary <c>Subject</c> described by <c>PosLen</c>.</p>
+      <p>Extracts the part of the binary <c><anno>Subject</anno></c> described by <c><anno>PosLen</anno></c>.</p>
 
       <p>Negative length can be used to extract bytes at the end of a binary:</p>
 
@@ -494,25 +411,20 @@
       <c>binary_part/3</c>. Those BIFs are allowed in guard tests.</p>
       </note>
 
-      <p>If <c>PosLen</c> in any way references outside the binary, a <c>badarg</c> exception
+      <p>If <c><anno>PosLen</anno></c> in any way references outside the binary, a <c>badarg</c> exception
       is raised.</p>
 
       </desc>
     </func>
     <func>
-      <name>part(Subject, Pos, Len) -> binary()</name>
+      <name name="part" arity="3"/>
       <fsummary>Extracts a part of a binary</fsummary>
-      <type>
-        <v>Subject = binary()</v>
-        <v>Pos = integer() >= 0</v>
-        <v>Len = integer() >= 0</v>
-      </type>
       <desc>
-      <p>The same as <c>part(Subject, {Pos, Len})</c>.</p>
+      <p>The same as <c>part(<anno>Subject</anno>, {<anno>Pos</anno>, <anno>Len</anno>})</c>.</p>
       </desc>
     </func>
     <func>
-      <name>referenced_byte_size(binary()) -> integer() >= 0</name>
+      <name name="referenced_byte_size" arity="1"/>
       <fsummary>Determines the size of the actual binary pointed out by a sub-binary</fsummary>
       <desc>
 
diff --git a/lib/stdlib/doc/src/ets.xml b/lib/stdlib/doc/src/ets.xml
index efd9514db6..27608e9176 100644
--- a/lib/stdlib/doc/src/ets.xml
+++ b/lib/stdlib/doc/src/ets.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2011</year>
+      <year>1996</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -128,11 +128,17 @@
 
   <datatypes>
     <datatype>
+      <name name="access"/>
+    </datatype>
+    <datatype>
       <name><marker id="type-continuation">continuation()</marker></name>
       <desc>
         <p>Opaque continuation used by <seealso marker="#select/1">
-          <c>select/1</c></seealso> and <seealso marker="#select/3">
-          <c>select/3</c></seealso>.</p>
+          <c>select/1,3</c></seealso>, <seealso marker="#select_reverse/1">
+          <c>select_reverse/1,3</c></seealso>, <seealso
+          marker="#match/1">
+          <c>match/1,3</c></seealso>, and <seealso marker="#match_object/1">
+          <c>match_object/1,3</c></seealso>.</p>
       </desc>
     </datatype>
     <datatype>
@@ -149,14 +155,14 @@
       <name name="tid"/>
       <desc><p>A table identifier, as returned by new/2.</p></desc>
     </datatype>
+    <datatype>
+      <name name="type"/>
+    </datatype>
   </datatypes>
   <funcs>
     <func>
-      <name>all() -> [Tab]</name>
+      <name name="all" arity="0"/>
       <fsummary>Return a list of all ETS tables.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-      </type>
       <desc>
         <p>Returns a list of all tables at the node. Named tables are
           given by their names, unnamed tables are given by their
@@ -164,48 +170,34 @@
       </desc>
     </func>
     <func>
-      <name>delete(Tab) -> true</name>
+      <name name="delete" arity="1"/>
       <fsummary>Delete an entire ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-      </type>
       <desc>
-        <p>Deletes the entire table <c>Tab</c>.</p>
+        <p>Deletes the entire table <c><anno>Tab</anno></c>.</p>
       </desc>
     </func>
     <func>
-      <name>delete(Tab, Key) -> true</name>
+      <name name="delete" arity="2"/>
       <fsummary>Delete all objects with a given key from an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v>
-      </type>
       <desc>
-        <p>Deletes all objects with the key <c>Key</c> from the table
-          <c>Tab</c>.</p>
+        <p>Deletes all objects with the key <c><anno>Key</anno></c> from the table
+          <c><anno>Tab</anno></c>.</p>
       </desc>
     </func>
     <func>
-      <name>delete_all_objects(Tab) -> true</name>
+      <name name="delete_all_objects" arity="1"/>
       <fsummary>Delete all objects in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-      </type>
       <desc>
-        <p>Delete all objects in the ETS table <c>Tab</c>. 
+        <p>Delete all objects in the ETS table <c><anno>Tab</anno></c>.
          The operation is guaranteed to be
          <seealso marker="#concurrency">atomic and isolated</seealso>.</p>
       </desc>
     </func>
     <func>
-      <name>delete_object(Tab,Object) -> true</name>
+      <name name="delete_object" arity="2"/>
       <fsummary>Deletes a specific from an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Object = tuple()</v>
-      </type>
       <desc>
-        <p>Delete the exact object <c>Object</c> from the ETS table,
+        <p>Delete the exact object <c><anno>Object</anno></c> from the ETS table,
           leaving objects with the same key but other differences
           (useful for type <c>bag</c>). In a <c>duplicate_bag</c>, all
           instances of the object will be deleted.</p>
@@ -257,14 +249,10 @@
       </desc>
     </func>
     <func>
-      <name>first(Tab) -> Key | '$end_of_table'</name>
+      <name name="first" arity="1"/>
       <fsummary>Return the first key in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v>
-      </type>
       <desc>
-        <p>Returns the first key <c>Key</c> in the table <c>Tab</c>.
+        <p>Returns the first key <c><anno>Key</anno></c> in the table <c><anno>Tab</anno></c>.
           If the table is of the <c>ordered_set</c> type, the first key
           in Erlang term order will be returned. If the table is of any
           other type, the first key according to the table's internal
@@ -336,7 +324,7 @@
           the source file.</p>
         <p>The fun is very restricted, it can take only a single
           parameter (the object to match): a sole variable or a
-          tuple. It needs to use the <c>is_</c>XXX guard tests.
+          tuple. It needs to use the <c>is_</c> guard tests.
           Language constructs that have no representation
           in a match_spec (like <c>if</c>, <c>case</c>, <c>receive</c>
           etc) are not allowed.</p>
@@ -386,19 +374,14 @@ Error: fun containing local Erlang function calls
       </desc>
     </func>
     <func>
-      <name>give_away(Tab, Pid, GiftData) -> true</name>
+      <name name="give_away" arity="3"/>
       <fsummary>Change owner of a table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Pid = pid()</v>
-        <v>GiftData = term()</v>
-      </type>
       <desc>
-        <p>Make process <c>Pid</c> the new owner of table <c>Tab</c>.
+        <p>Make process <c><anno>Pid</anno></c> the new owner of table <c><anno>Tab</anno></c>.
           If successful, the message
-          <c>{'ETS-TRANSFER',Tab,FromPid,GiftData}</c> will be sent
+          <c>{'ETS-TRANSFER',<anno>Tab</anno>,FromPid,<anno>GiftData</anno>}</c> will be sent
           to the new owner.</p>
-        <p>The process <c>Pid</c> must be alive, local and not already the
+        <p>The process <c><anno>Pid</anno></c> must be alive, local and not already the
           owner of the table. The calling process must be the table owner.</p>
         <p>Note that <c>give_away</c> does not at all affect the
           <seealso marker="#heir">heir</seealso> option of the table. A table
@@ -421,81 +404,72 @@ Error: fun containing local Erlang function calls
       </desc>
     </func>
     <func>
-      <name>info(Tab) -> [{Item, Value}] | undefined</name>
+      <name name="info" arity="1"/>
       <fsummary>Return information about an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Item = atom(), see below</v>
-        <v>Value = term(), see below</v>
-      </type>
       <desc>
-        <p>Returns information about the table <c>Tab</c> as a list of
-          <c>{Item, Value}</c> tuples. If <c>Tab</c> has the correct type
+        <p>Returns information about the table <c><anno>Tab</anno></c> as a list of
+          tuples. If <c><anno>Tab</anno></c> has the correct type
 	  for a table identifier, but does not refer to an existing ETS
-	  table, <c>undefined</c> is returned. If <c>Tab</c> is not of the
+	  table, <c>undefined</c> is returned. If <c><anno>Tab</anno></c> is not of the
 	  correct type, this function fails with reason <c>badarg</c>.</p>
 
         <list type="bulleted">
-          <item><c>Item=memory, Value=integer()</c>          <br></br>
-
-           The number of words allocated to the table.</item>
-          <item><c>Item=owner, Value=pid()</c>          <br></br>
+           <item><c>{compressed, boolean()}</c>          <br></br>
 
-           The pid of the owner of the table.</item>
-          <item><c>Item=heir, Value=pid()|none</c>          <br></br>
+            Indicates if the table is compressed or not.</item>
+          <item><c>{heir, pid() | none}</c>          <br></br>
 
            The pid of the heir of the table, or <c>none</c> if no heir is set.</item>
-          <item><c>Item=name, Value=atom()</c>          <br></br>
+          <item><c>{keypos, integer() >= 1}</c>          <br></br>
 
-           The name of the table.</item>
-          <item><c>Item=size, Value=integer()</c>          <br></br>
+           The key position.</item>
+          <item><c>{memory, integer() >= 0</c>          <br></br>
 
-           The number of objects inserted in the table.</item>
-          <item><c>Item=node, Value=atom()</c>          <br></br>
+           The number of words allocated to the table.</item>
+          <item><c>{name, atom()}</c>          <br></br>
 
-           The node where the table is stored. This field is no longer
-           meaningful as tables cannot be accessed from other nodes.</item>
-          <item><c>Item=named_table, Value=true|false</c>          <br></br>
+           The name of the table.</item>
+          <item><c>{named_table, boolean()}</c>          <br></br>
 
            Indicates if the table is named or not.</item>
-          <item><c>Item=type, Value=set|ordered_set|bag|duplicate_bag</c>          <br></br>
+          <item><c>{node, node()}</c>          <br></br>
 
-           The table type.</item>
-          <item><c>Item=keypos, Value=integer()</c>          <br></br>
+           The node where the table is stored. This field is no longer
+           meaningful as tables cannot be accessed from other nodes.</item>
+          <item><c>{owner, pid()}</c>          <br></br>
 
-           The key position.</item>
-          <item><c>Item=protection, Value=public|protected|private</c>          <br></br>
+           The pid of the owner of the table.</item>
+          <item><c>{protection, <seealso marker="#type-access">access()</seealso>}</c>          <br></br>
 
            The table access rights.</item>
-           <item><c>Item=compressed, Value=true|false</c>          <br></br>
+          <item><c>{size, integer() >= 0</c>          <br></br>
 
-            Indicates if the table is compressed or not.</item>
+           The number of objects inserted in the table.</item>
+          <item><c>{type, <seealso marker="#type-type">type()</seealso>}</c>          <br></br>
+
+           The table type.</item>
         </list>
       </desc>
     </func>
     <func>
-      <name>info(Tab, Item) -> Value | undefined</name>
+      <name name="info" arity="2"/>
       <fsummary>Return the information associated with given item for an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Item, Value - see below</v>
-      </type>
       <desc>
         <p>Returns the information associated with <c>Item</c> for
-          the table <c>Tab</c>, or returns <c>undefined</c> if <c>Tab</c>
+          the table <c><anno>Tab</anno></c>, or returns <c>undefined</c> if <c>Tab</c>
 	  does not refer an existing ETS table.
-	  If <c>Tab</c> is not of the correct type, or if <c>Item</c> is not
+	  If <c><anno>Tab</anno></c> is not of the correct type, or if <c><anno>Item</anno></c> is not
 	  one of the allowed values, this function fails with reason <c>badarg</c>.</p>
 
 	  <warning><p>In R11B and earlier, this function would not fail but return
 	  <c>undefined</c> for invalid values for <c>Item</c>.</p>
 	  </warning>
 
-	  <p>In addition to the <c>{Item,Value}</c>
+	  <p>In addition to the <c>{<anno>Item</anno>,<anno>Value</anno>}</c>
           pairs defined for <c>info/1</c>, the following items are
           allowed:</p>
         <list type="bulleted">
-          <item><c>Item=fixed, Value=true|false</c>          <br></br>
+          <item><c>Item=fixed, Value=boolean()</c>          <br></br>
 
            Indicates if the table is fixed by any process or not.</item>
           <item>
@@ -547,15 +521,11 @@ Error: fun containing local Erlang function calls
       </desc>
     </func>
     <func>
-      <name>insert(Tab, ObjectOrObjects) -> true</name>
+      <name name="insert" arity="2"/>
       <fsummary>Insert an object into an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>ObjectOrObjects = tuple() | [tuple()]</v>
-      </type>
       <desc>
         <p>Inserts the object or all of the objects in the list
-          <c>ObjectOrObjects</c> into the table <c>Tab</c>.  
+          <c><anno>ObjectOrObjects</anno></c> into the table <c><anno>Tab</anno></c>.
           If the table is a <c>set</c> and the key of the inserted
           objects <em>matches</em> the key of any object in the table,
           the old object will be replaced. If the table is an
@@ -572,19 +542,15 @@ Error: fun containing local Erlang function calls
       </desc>
     </func>
     <func>
-      <name>insert_new(Tab, ObjectOrObjects) -> boolean()</name>
+      <name name="insert_new" arity="2"/>
       <fsummary>Insert an object into an ETS table if the key is not already present.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>ObjectOrObjects = tuple() | [tuple()]</v>
-      </type>
       <desc>
         <p>This function works exactly like <c>insert/2</c>, with the
           exception that instead of overwriting objects with the same
           key (in the case of <c>set</c> or <c>ordered_set</c>) or
           adding more objects with keys already existing in the table
           (in the case of <c>bag</c> and <c>duplicate_bag</c>), it
-          simply returns <c>false</c>. If <c>ObjectOrObjects</c> is a
+          simply returns <c>false</c>. If <c><anno>ObjectOrObjects</anno></c> is a
           list, the function checks <em>every</em> key prior to
           inserting anything. Nothing will be inserted if not
           <em>all</em> keys present in the list are absent from the
@@ -593,11 +559,8 @@ Error: fun containing local Erlang function calls
       </desc>
     </func>
     <func>
-      <name>is_compiled_ms(Term) -> boolean()</name>
+      <name name="is_compiled_ms" arity="1"/>
       <fsummary>Checks if an Erlang term is the result of ets:match_spec_compile</fsummary>
-      <type>
-        <v>Term = term()</v>
-      </type>
       <desc>
         <p>This function is used to check if a term is a valid
           compiled <seealso marker="#match_spec">match_spec</seealso>.
@@ -626,14 +589,10 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>last(Tab) -> Key | '$end_of_table'</name>
+      <name name="last" arity="1"/>
       <fsummary>Return the last key in an ETS table of type<c>ordered_set</c>.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v>
-      </type>
       <desc>
-        <p>Returns the last key <c>Key</c> according to Erlang term
+        <p>Returns the last key <c><anno>Key</anno></c> according to Erlang term
           order in the table <c>Tab</c> of the <c>ordered_set</c> type.
           If the table is of any other type, the function is synonymous
           to <c>first/2</c>. If the table is empty,
@@ -642,16 +601,11 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>lookup(Tab, Key) -> [Object]</name>
+      <name name="lookup" arity="2"/>
       <fsummary>Return all objects with a given key in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v>
-        <v>Object = tuple()</v>
-      </type>
       <desc>
-        <p>Returns a list of all objects with the key <c>Key</c> in
-          the table <c>Tab</c>.</p>
+        <p>Returns a list of all objects with the key <c><anno>Key</anno></c> in
+          the table <c><anno>Tab</anno></c>.</p>
         <p>In the case of <c>set, bag and duplicate_bag</c>, an object
           is returned only if the given key <em>matches</em> the key
           of the object in the table. If the table is an
@@ -681,22 +635,16 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>lookup_element(Tab, Key, Pos) -> Elem</name>
+      <name name="lookup_element" arity="3"/>
       <fsummary>Return the <c>Pos</c>:th element of all objects with a given key in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v>
-        <v>Pos = integer()</v>
-        <v>Elem = term() | [term()]</v>
-      </type>
       <desc>
-        <p>If the table <c>Tab</c> is of type <c>set</c> or
-          <c>ordered_set</c>, the function returns the <c>Pos</c>:th
-          element of the object with the key <c>Key</c>.</p>
+        <p>If the table <c><anno>Tab</anno></c> is of type <c>set</c> or
+          <c>ordered_set</c>, the function returns the <c><anno>Pos</anno></c>:th
+          element of the object with the key <c><anno>Key</anno></c>.</p>
         <p>If the table is of type <c>bag</c> or <c>duplicate_bag</c>,
-          the functions returns a list with the <c>Pos</c>:th element of
-          every object with the key <c>Key</c>.</p>
-        <p>If no object with the key <c>Key</c> exists, the function
+          the functions returns a list with the <c><anno>Pos</anno></c>:th element of
+          every object with the key <c><anno>Key</anno></c>.</p>
+        <p>If no object with the key <c><anno>Key</anno></c> exists, the function
           will exit with reason <c>badarg</c>.</p>
         <p>The difference between <c>set</c>, <c>bag</c> and 
           <c>duplicate_bag</c> on one hand, and <c>ordered_set</c> on
@@ -708,16 +656,11 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match(Tab, Pattern) -> [Match]</name>
+      <name name="match" arity="2"/>
       <fsummary>Match the objects in an ETS table against a pattern.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Pattern = tuple()</v>
-        <v>Match = [term()]</v>
-      </type>
       <desc>
-        <p>Matches the objects in the table <c>Tab</c> against the
-          pattern <c>Pattern</c>.</p>
+        <p>Matches the objects in the table <c><anno>Tab</anno></c> against the
+          pattern <c><anno>Pattern</anno></c>.</p>
         <p>A pattern is a term that may contain:</p>
         <list type="bulleted">
           <item>bound parts (Erlang terms),</item>
@@ -744,18 +687,12 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match(Tab, Pattern, Limit) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="match" arity="3"/>
       <fsummary>Match the objects in an ETS table against a pattern and returns part of the answers.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Pattern = tuple()</v>
-        <v>Match = [term()]</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
         <p>Works like <c>ets:match/2</c> but only returns a limited
-          (<c>Limit</c>) number of matching objects. The
-          <c>Continuation</c> term can then be used in subsequent calls
+          (<c><anno>Limit</anno></c>) number of matching objects. The
+          <c><anno>Continuation</anno></c> term can then be used in subsequent calls
           to <c>ets:match/1</c> to get the next chunk of matching
           objects. This is a space efficient way to work on objects in a
           table which is still faster than traversing the table object
@@ -764,16 +701,12 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match(Continuation) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="match" arity="1"/>
       <fsummary>Continues matching objects in an ETS table.</fsummary>
-      <type>
-        <v>Match = [term()]</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
         <p>Continues a match started with <c>ets:match/3</c>. The next
           chunk of the size given in the initial <c>ets:match/3</c>
-          call is returned together with a new <c>Continuation</c>
+          call is returned together with a new <c><anno>Continuation</anno></c>
           that can be used in subsequent calls to this function.</p>
         <p><c>'$end_of_table'</c> is returned when there are no more
           objects in the table.</p>
@@ -789,15 +722,11 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match_object(Tab, Pattern) -> [Object]</name>
+      <name name="match_object" arity="2"/>
       <fsummary>Match the objects in an ETS table against a pattern.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Pattern = Object = tuple()</v>
-      </type>
       <desc>
-        <p>Matches the objects in the table <c>Tab</c> against the
-          pattern <c>Pattern</c>. See <c>match/2</c> for a description
+        <p>Matches the objects in the table <c><anno>Tab</anno></c> against the
+          pattern <c><anno>Pattern</anno></c>. See <c>match/2</c> for a description
           of patterns. The function returns a list of all objects which
           match the pattern.</p>
         <p>If the key is specified in the pattern, the match is very
@@ -809,18 +738,12 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match_object(Tab, Pattern, Limit) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="match_object" arity="3"/>
       <fsummary>Match the objects in an ETS table against a pattern and returns part of the answers.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Pattern = tuple()</v>
-        <v>Match = [term()]</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
         <p>Works like <c>ets:match_object/2</c> but only returns a
-          limited (<c>Limit</c>) number of matching objects. The
-          <c>Continuation</c> term can then be used in subsequent calls
+          limited (<c><anno>Limit</anno></c>) number of matching objects. The
+          <c><anno>Continuation</anno></c> term can then be used in subsequent calls
           to <c>ets:match_object/1</c> to get the next chunk of matching
           objects. This is a space efficient way to work on objects in a
           table which is still faster than traversing the table object
@@ -829,29 +752,23 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match_object(Continuation) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="match_object" arity="1"/>
       <fsummary>Continues matching objects in an ETS table.</fsummary>
-      <type>
-        <v>Match = [term()]</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
         <p>Continues a match started with <c>ets:match_object/3</c>.
           The next chunk of the size given in the initial
           <c>ets:match_object/3</c> call is returned together with a
-          new <c>Continuation</c> that can be used in subsequent calls
+          new <c><anno>Continuation</anno></c> that can be used in subsequent calls
           to this function.</p>
         <p><c>'$end_of_table'</c> is returned when there are no more
           objects in the table.</p>
       </desc>
     </func>
     <func>
-      <name>match_spec_compile(MatchSpec) -> CompiledMatchSpec</name>
+      <name name="match_spec_compile" arity="1"/>
+      <type name="comp_match_spec"/>
+      <type_desc name="comp_match_spec">A compiled match specification.</type_desc>
       <fsummary>Compiles a match specification into its internal representation</fsummary>
-      <type>
-        <v>MatchSpec = match_spec()</v>
-        <v>CompiledMatchSpec = comp_match_spec()</v>
-      </type>
       <desc>
         <p>This function transforms a
           <seealso marker="#match_spec">match_spec</seealso> into an
@@ -863,7 +780,7 @@ ets:is_compiled_ms(Broken).</code>
           valid compiled match_spec, nor can it be stored on disk).
           The validity of a compiled match_spec can be checked using
           <c>ets:is_compiled_ms/1</c>.</p>
-        <p>If the term <c>MatchSpec</c> can not be compiled (does not
+        <p>If the term <c><anno>MatchSpec</anno></c> can not be compiled (does not
           represent a valid match_spec), a <c>badarg</c> fault is
           thrown.</p>
         <note>
@@ -873,25 +790,23 @@ ets:is_compiled_ms(Broken).</code>
       </desc>
     </func>
     <func>
-      <name>match_spec_run(List,CompiledMatchSpec) -> list()</name>
+      <name name="match_spec_run" arity="2"/>
+      <type name="comp_match_spec"/>
+      <type_desc name="comp_match_spec">A compiled match specification.</type_desc>
       <fsummary>Performs matching, using a compiled match_spec, on a list of tuples</fsummary>
-      <type>
-        <v>List = [ tuple() ]</v>
-        <v>CompiledMatchSpec = comp_match_spec()</v>
-      </type>
       <desc>
         <p>This function executes the matching specified in a
           compiled <seealso marker="#match_spec">match_spec</seealso> on
-          a list of tuples. The <c>CompiledMatchSpec</c> term should be
+          a list of tuples. The <c><anno>CompiledMatchSpec</anno></c> term should be
           the result of a call to <c>ets:match_spec_compile/1</c> and
           is hence the internal representation of the match_spec one
           wants to use.</p>
-        <p>The matching will be executed on each element in <c>List</c>
+        <p>The matching will be executed on each element in <c><anno>List</anno></c>
           and the function returns a list containing all results. If an
-          element in <c>List</c> does not match, nothing is returned
+          element in <c><anno>List</anno></c> does not match, nothing is returned
           for that element. The length of the result list is therefore
           equal or less than the the length of the parameter
-          <c>List</c>. The two calls in the following example will give
+          <c><anno>List</anno></c>. The two calls in the following example will give
           the same result (but certainly not the same execution
           time...):</p>
         <code type="none">
@@ -910,37 +825,23 @@ ets:select(Table,MatchSpec),</code>
       </desc>
     </func>
     <func>
-      <name>member(Tab, Key) -> true | false</name>
+      <name name="member" arity="2"/>
       <fsummary>Tests for occurrence of a key in an ETS table</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v>
-      </type>
       <desc>
         <p>Works like <c>lookup/2</c>, but does not return the objects.
           The function returns <c>true</c> if one or more elements in
-          the table has the key <c>Key</c>, <c>false</c> otherwise.</p>
+          the table has the key <c><anno>Key</anno></c>, <c>false</c> otherwise.</p>
       </desc>
     </func>
     <func>
-      <name>new(Name, Options) -> tid() | atom()</name>
+      <name name="new" arity="2"/>
       <fsummary>Create a new ETS table.</fsummary>
-      <type>
-        <v>Name = atom()</v>
-        <v>Options = [Option]</v>
-        <v>&nbsp;Option = Type | Access | named_table | {keypos,Pos} | {heir,pid(),HeirData} | {heir,none} | Tweaks</v>
-        <v>&nbsp;&nbsp;Type = set | ordered_set | bag | duplicate_bag</v>
-        <v>&nbsp;&nbsp;Access = public | protected | private</v>
-        <v>&nbsp;&nbsp;Tweaks = {write_concurrency,boolean()} | {read_concurrency,boolean()} | compressed</v>
-        <v>&nbsp;&nbsp;Pos = integer()</v>
-        <v>&nbsp;&nbsp;HeirData = term()</v>
-      </type>
       <desc>
         <p>Creates a new table and returns a table identifier which can
           be used in subsequent operations. The table identifier can be
           sent to other processes so that a table can be shared between
           different processes within a node.</p>
-        <p>The parameter <c>Options</c> is a list of atoms which
+        <p>The parameter <c><anno>Options</anno></c> is a list of atoms which
           specifies table type, access rights, key position and if the
           table is named or not. If one or more options are left out,
           the default values are used. This means that not specifying
@@ -997,27 +898,27 @@ ets:select(Table,MatchSpec),</code>
           </item>
           <item>
             <p><c>named_table</c>
-              If this option is present, the name <c>Name</c> is
+              If this option is present, the name <c><anno>Name</anno></c> is
               associated with the table identifier. The name can then
               be used instead of the table identifier in subsequent
               operations.</p>
           </item>
           <item>
-            <p><c>{keypos,Pos}</c>
+            <p><c>{keypos,<anno>Pos</anno>}</c>
               Specfies which element in the stored tuples should be
               used as key. By default, it is the first element, i.e.
-              <c>Pos=1</c>. However, this is not always appropriate. In
+              <c><anno>Pos</anno>=1</c>. However, this is not always appropriate. In
               particular, we do not want the first element to be the
               key if we want to store Erlang records in a table.</p>
             <p>Note that any tuple stored in the table must have at
-              least <c>Pos</c> number of elements.</p>
+              least <c><anno>Pos</anno></c> number of elements.</p>
           </item>
           <item>
             <marker id="heir"></marker>
-            <p><c>{heir,Pid,HeirData} | {heir,none}</c><br></br>
+            <p><c>{heir,<anno>Pid</anno>,<anno>HeirData</anno>} | {heir,none}</c><br></br>
               Set a process as heir. The heir will inherit the table if
               the owner terminates. The message
-              <c>{'ETS-TRANSFER',tid(),FromPid,HeirData}</c> will be sent to
+              <c>{'ETS-TRANSFER',tid(),FromPid,<anno>HeirData</anno>}</c> will be sent to
               the heir when that happens. The heir must be a local process.
               Default heir is <c>none</c>, which will destroy the table when
               the owner terminates.</p>
@@ -1082,15 +983,11 @@ ets:select(Table,MatchSpec),</code>
       </desc>
     </func>
     <func>
-      <name>next(Tab, Key1) -> Key2 | '$end_of_table'</name>
+      <name name="next" arity="2"/>
       <fsummary>Return the next key in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key1 = Key2 = term()</v>
-      </type>
       <desc>
-        <p>Returns the next key <c>Key2</c>, following the key
-          <c>Key1</c> in the table <c>Tab</c>. If the table is of the
+        <p>Returns the next key <c><anno>Key2</anno></c>, following the key
+          <c><anno>Key1</anno></c> in the table <c><anno>Tab</anno></c>. If the table is of the
           <c>ordered_set</c> type, the next key in Erlang term order is
           returned. If the table is of any other type, the next key
           according to the table's internal order is returned. If there
@@ -1105,16 +1002,12 @@ ets:select(Table,MatchSpec),</code>
       </desc>
     </func>
     <func>
-      <name>prev(Tab, Key1) -> Key2 | '$end_of_table'</name>
+      <name name="prev" arity="2"/>
       <fsummary>Return the previous key in an ETS table of type<c>ordered_set</c>.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key1 = Key2 = term()</v>
-      </type>
       <desc>
-        <p>Returns the previous key <c>Key2</c>, preceding the key
-          <c>Key1</c> according the Erlang term order in the table
-          <c>Tab</c> of the <c>ordered_set</c> type. If the table is of
+        <p>Returns the previous key <c><anno>Key2</anno></c>, preceding the key
+          <c><anno>Key1</anno></c> according the Erlang term order in the table
+          <c><anno>Tab</anno></c> of the <c>ordered_set</c> type. If the table is of
           any other type, the function is synonymous to <c>next/2</c>.
           If there is no previous key, <c>'$end_of_table'</c> is
           returned.</p>
@@ -1122,14 +1015,11 @@ ets:select(Table,MatchSpec),</code>
       </desc>
     </func>
     <func>
-      <name>rename(Tab, Name) -> Name</name>
+      <name name="rename" arity="2"/>
       <fsummary>Rename a named ETS table.</fsummary>
-      <type>
-        <v>Tab = Name = atom()</v>
-      </type>
       <desc>
-        <p>Renames the named table <c>Tab</c> to the new name
-          <c>Name</c>. Afterwards, the old name can not be used to
+        <p>Renames the named table <c><anno>Tab</anno></c> to the new name
+          <c><anno>Name</anno></c>. Afterwards, the old name can not be used to
           access the table. Renaming an unnamed table has no effect.</p>
       </desc>
     </func>
@@ -1186,18 +1076,15 @@ ets:select(ets:repair_continuation(Broken,MS)).</code>
       </desc>
     </func>
     <func>
-      <name>safe_fixtable(Tab, true|false) -> true</name>
+      <name name="safe_fixtable" arity="2"/>
       <fsummary>Fix an ETS table for safe traversal.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-      </type>
       <desc>
         <p>Fixes a table of the <c>set</c>, <c>bag</c> or
           <c>duplicate_bag</c> table type for safe traversal.</p>
         <p>A process fixes a table by calling
-          <c>safe_fixtable(Tab,true)</c>. The table remains fixed until
+          <c>safe_fixtable(<anno>Tab</anno>, true)</c>. The table remains fixed until
           the process releases it by calling
-          <c>safe_fixtable(Tab,false)</c>, or until the process
+          <c>safe_fixtable(<anno>Tab</anno>, false)</c>, or until the process
           terminates.</p>
         <p>If several processes fix a table, the table will remain fixed
           until all processes have released it (or terminated).
@@ -1242,15 +1129,10 @@ clean_all_with_value(Tab,X,Key) ->
       </desc>
     </func>
     <func>
-      <name>select(Tab, MatchSpec) -> [Match]</name>
+      <name name="select" arity="2"/>
       <fsummary>Match the objects in an ETS table against a match_spec.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Match = term()</v>
-        <v>MatchSpec = match_spec()</v>
-      </type>
       <desc>
-        <p>Matches the objects in the table <c>Tab</c> using a
+        <p>Matches the objects in the table <c><anno>Tab</anno></c> using a
           <seealso marker="#match_spec">match_spec</seealso>. This is a
           more general call than the <c>ets:match/2</c> and
           <c>ets:match_object/2</c> calls. In its simplest forms the
@@ -1337,18 +1219,12 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>select(Tab, MatchSpec, Limit) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="select" arity="3"/>
       <fsummary>Match the objects in an ETS table against a match_spec and returns part of the answers.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Match = term()</v>
-        <v>MatchSpec = match_spec()</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
         <p>Works like <c>ets:select/2</c> but only returns a limited
-          (<c>Limit</c>) number of matching objects. The
-          <c>Continuation</c> term can then be used in subsequent calls
+          (<c><anno>Limit</anno></c>) number of matching objects. The
+          <c><anno>Continuation</anno></c> term can then be used in subsequent calls
           to <c>ets:select/1</c> to get the next chunk of matching
           objects. This is a space efficient way to work on objects in a
           table which is still faster than traversing the table object
@@ -1357,33 +1233,23 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>select(Continuation) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="select" arity="1"/>
       <fsummary>Continue matching objects in an ETS table.</fsummary>
-      <type>
-        <v>Match = term()</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
         <p>Continues a match started with
           <c>ets:select/3</c>. The next
           chunk of the size given in the initial <c>ets:select/3</c>
-          call is returned together with a new <c>Continuation</c>
+          call is returned together with a new <c><anno>Continuation</anno></c>
           that can be used in subsequent calls to this function.</p>
         <p><c>'$end_of_table'</c> is returned when there are no more
           objects in the table.</p>
       </desc>
     </func>
     <func>
-      <name>select_count(Tab, MatchSpec) -> NumMatched</name>
+      <name name="select_count" arity="2"/>
       <fsummary>Match the objects in an ETS table against a match_spec and returns the number of objects for which the match_spec returned 'true'</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Object = tuple()</v>
-        <v>MatchSpec = match_spec()</v>
-        <v>NumMatched = integer()</v>
-      </type>
       <desc>
-        <p>Matches the objects in the table <c>Tab</c> using a
+        <p>Matches the objects in the table <c><anno>Tab</anno></c> using a
           <seealso marker="#match_spec">match_spec</seealso>. If the
           match_spec returns <c>true</c> for an object, that object
           considered a match and is counted. For any other result from
@@ -1396,16 +1262,10 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>select_delete(Tab, MatchSpec) -> NumDeleted</name>
+      <name name="select_delete" arity="2"/>
       <fsummary>Match the objects in an ETS table against a match_spec and deletes objects where the match_spec returns 'true'</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Object = tuple()</v>
-        <v>MatchSpec = match_spec()</v>
-        <v>NumDeleted = integer()</v>
-      </type>
       <desc>
-        <p>Matches the objects in the table <c>Tab</c> using a
+        <p>Matches the objects in the table <c><anno>Tab</anno></c> using a
           <seealso marker="#match_spec">match_spec</seealso>. If the
           match_spec returns <c>true</c> for an object, that object is
           removed from the table. For any other result from the
@@ -1422,13 +1282,8 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>select_reverse(Tab, MatchSpec) -> [Match]</name>
+      <name name="select_reverse" arity="2"/>
       <fsummary>Match the objects in an ETS table against a match_spec.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Match = term()</v>
-        <v>MatchSpec = match_spec()</v>
-      </type>
       <desc>
 
       <p>Works like <c>select/2</c>, but returns the list in reverse
@@ -1438,14 +1293,8 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>select_reverse(Tab, MatchSpec, Limit) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="select_reverse" arity="3"/>
       <fsummary>Match the objects in an ETS table against a match_spec and returns part of the answers.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Match = term()</v>
-        <v>MatchSpec = match_spec()</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
 
       <p>Works like <c>select/3</c>, but for the <c>ordered_set</c>
@@ -1456,18 +1305,14 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
 
       <p>Note that this is <em>not</em> equivalent to
       reversing the result list of a <c>select/3</c> call, as the result list
-      is not only reversed, but also contains the last <c>Limit</c>
+      is not only reversed, but also contains the last <c><anno>Limit</anno></c>
       matching objects in the table, not the first.</p>
 
       </desc>
     </func>
     <func>
-      <name>select_reverse(Continuation) -> {[Match],Continuation} | '$end_of_table'</name>
+      <name name="select_reverse" arity="1"/>
       <fsummary>Continue matching objects in an ETS table.</fsummary>
-      <type>
-        <v>Match = term()</v>
-        <v>Continuation = term()</v>
-      </type>
       <desc>
 
       <p>Continues a match started with
@@ -1477,7 +1322,7 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       returned list will also contain objects with keys in reverse
       order.</p>
 
-      <p>For all other table types, the behaviour is exatly that of <c>select/1</c>.</p>
+      <p>For all other table types, the behaviour is exactly that of <c>select/1</c>.</p>
       <p>Example:</p>
       <code>
 1> T = ets:new(x,[ordered_set]).
@@ -1501,14 +1346,8 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>setopts(Tab, Opts) -> true</name>
+      <name name="setopts" arity="2"/>
       <fsummary>Set table options.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Opts = Opt | [Opt]</v>
-        <v>Opt = {heir,pid(),HeirData} | {heir,none}</v>
-        <v>HeirData = term()</v>
-      </type>
       <desc>
         <p>Set table options. The only option that currently is allowed to be
           set after the table has been created is
@@ -1517,28 +1356,23 @@ is_integer(X), is_integer(Y), X + Y < 4711]]></code>
       </desc>
     </func>
     <func>
-      <name>slot(Tab, I) -> [Object] | '$end_of_table'</name>
+      <name name="slot" arity="2"/>
       <fsummary>Return all objects in a given slot of an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>I = integer()</v>
-        <v>Object = tuple()</v>
-      </type>
       <desc>
         <p>This function is mostly for debugging purposes, Normally
           one should use <c>first/next</c> or <c>last/prev</c> instead.</p>
-        <p>Returns all objects in the <c>I</c>:th slot of the table
-          <c>Tab</c>. A table can be traversed by repeatedly calling
-          the function, starting with the first slot <c>I=0</c> and
+        <p>Returns all objects in the <c><anno>I</anno></c>:th slot of the table
+          <c><anno>Tab</anno></c>. A table can be traversed by repeatedly calling
+          the function, starting with the first slot <c><anno>I</anno>=0</c> and
           ending when <c>'$end_of_table'</c> is returned.
           The function will fail with reason <c>badarg</c> if the
-          <c>I</c> argument is out of range.</p>
+          <c><anno>I</anno></c> argument is out of range.</p>
         <p>Unless a table of type <c>set</c>, <c>bag</c> or
           <c>duplicate_bag</c> is protected using
           <c>safe_fixtable/2</c>, see above, a traversal may fail if
           concurrent updates are made to the table. If the table is of
           type <c>ordered_set</c>, the function returns a list
-          containing the <c>I</c>:th object in Erlang term order.</p>
+          containing the <c><anno>I</anno></c>:th object in Erlang term order.</p>
       </desc>
     </func>
     <func>
@@ -1754,16 +1588,16 @@ true</pre>
       </desc>
     </func>
     <func> 
-      <name>update_counter(Tab, Key, UpdateOp) -> Result</name>
-      <name>update_counter(Tab, Key, [UpdateOp]) -> [Result]</name>
-      <name>update_counter(Tab, Key, Incr) -> Result</name>
+      <name name="update_counter" arity="3" clause_i="1"/>
+      <name name="update_counter" arity="3" clause_i="2"/>
+      <name name="update_counter" arity="3" clause_i="3"/>
+      <type variable="Tab"/>
+      <type variable="Key"/>
+      <type variable="UpdateOp" name_i="1"/>
+      <type variable="Pos" name_i="1"/>
+      <type variable="Threshold" name_i="1"/>
+      <type variable="SetValue" name_i="1"/>
       <fsummary>Update a counter object in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = term()</v> 
-        <v>UpdateOp = {Pos,Incr} | {Pos,Incr,Threshold,SetValue}</v>
-        <v>Pos = Incr = Threshold = SetValue = Result = integer()</v>
-      </type>
       <desc>
         <p>This function provides an efficient way to update one or more 
           counters, without the hassle of having to look up an object, update 
@@ -1771,22 +1605,22 @@ true</pre>
           into the table again. (The update is done atomically; i.e. no process 
           can access the ets table in the middle of the operation.)
         </p>
-        <p>It will destructively update the object with key <c>Key</c>
-          in the table <c>Tab</c> by adding <c>Incr</c> to the element
-          at the <c>Pos</c>:th position. The new counter value is
+        <p>It will destructively update the object with key <c><anno>Key</anno></c>
+          in the table <c><anno>Tab</anno></c> by adding <c><anno>Incr</anno></c> to the element
+          at the <c><anno>Pos</anno></c>:th position. The new counter value is
           returned. If no position is specified, the element directly
           following the key (<c><![CDATA[<keypos>+1]]></c>) is updated.</p>
-        <p>If a <c>Threshold</c> is specified, the counter will be
-          reset to the value <c>SetValue</c> if the following
+        <p>If a <c><anno>Threshold</anno></c> is specified, the counter will be
+          reset to the value <c><anno>SetValue</anno></c> if the following
           conditions occur:</p>
         <list type="bulleted">
-          <item>The <c>Incr</c> is not negative (<c>>= 0</c>) and the
-           result would be greater than (<c>></c>) <c>Threshold</c></item>
-          <item>The <c>Incr</c> is negative (<c><![CDATA[< 0]]></c>) and the
+          <item>The <c><anno>Incr</anno></c> is not negative (<c>>= 0</c>) and the
+           result would be greater than (<c>></c>) <c><anno>Threshold</anno></c></item>
+          <item>The <c><anno>Incr</anno></c> is negative (<c><![CDATA[< 0]]></c>) and the
            result would be less than (<c><![CDATA[<]]></c>)
-          <c>Threshold</c></item>
+          <c><anno>Threshold</anno></c></item>
         </list>
-        <p>A list of <c>UpdateOp</c> can be supplied to do several update 
+        <p>A list of <c><anno>UpdateOp</anno></c> can be supplied to do several update
             operations within the object. The operations are carried out in the
             order specified in the list. If the same counter position occurs 
             more than one time in the list, the corresponding counter will thus 
@@ -1797,7 +1631,7 @@ true</pre>
             returned. If the function should fail, no updates will be done at 
             all.
         </p>
-        <p>The given Key is used to identify the object by either
+        <p>The given <c><anno>Key</anno></c> is used to identify the object by either
           <em>matching</em> the key of an object in a <c>set</c> table,
           or <em>compare equal</em> to the key of an object in an
           <c>ordered_set</c> table (see 
@@ -1812,29 +1646,28 @@ true</pre>
           <item>the object has the wrong arity,</item>
           <item>the element to update is not an integer,</item>
           <item>the element to update is also the key, or,</item>
-          <item>any of <c>Pos</c>, <c>Incr</c>, <c>Threshold</c> or
-          <c>SetValue</c> is not an integer</item>
+          <item>any of <c><anno>Pos</anno></c>, <c><anno>Incr</anno></c>, <c><anno>Threshold</anno></c> or
+          <c><anno>SetValue</anno></c> is not an integer</item>
         </list>
       </desc>
     </func>
     <func>
-      <name>update_element(Tab, Key, {Pos,Value}) -> true | false</name>
-      <name>update_element(Tab, Key, [{Pos,Value}]) -> true | false</name>
+      <name name="update_element" arity="3" clause_i="1"/>
+      <name name="update_element" arity="3" clause_i="2"/>
+      <type variable="Tab"/>
+      <type variable="Key"/>
+      <type variable="Value"/>
+      <type variable="Pos"/>
       <fsummary>Updates the <c>Pos</c>:th element of the object with a given key in an ETS table.</fsummary>
-      <type>
-        <v>Tab = tid() | atom()</v>
-        <v>Key = Value = term()</v>
-        <v>Pos = integer()</v>
-      </type>
       <desc>
         <p>This function provides an efficient way to update one or more 
           elements within an object, without the hassle of having to look up, 
           update and write back the entire object.
         </p>
-        <p>It will destructively update the object with key <c>Key</c>
-          in the table <c>Tab</c>. The element at the <c>Pos</c>:th position 
-          will be given the value <c>Value</c>. </p>
-        <p>A list of <c>{Pos,Value}</c> can be supplied to update several
+        <p>It will destructively update the object with key <c><anno>Key</anno></c>
+          in the table <c><anno>Tab</anno></c>. The element at the <c><anno>Pos</anno></c>:th position
+          will be given the value <c><anno>Value</anno></c>. </p>
+        <p>A list of <c>{<anno>Pos</anno>,<anno>Value</anno>}</c> can be supplied to update several
             elements within the same object. If the same position occurs more 
             than one in the list, the last value in the list will be written. If 
             the list is empty or the function fails, no updates will be done at
@@ -1842,9 +1675,9 @@ true</pre>
             can never see any intermediate results.
         </p>
         <p>The function returns <c>true</c> if an object with the key
-        <c>Key</c> was found, <c>false</c> otherwise.
+        <c><anno>Key</anno></c> was found, <c>false</c> otherwise.
         </p>
-        <p>The given Key is used to identify the object by either
+        <p>The given <c><anno>Key</anno></c> is used to identify the object by either
           <em>matching</em> the key of an object in a <c>set</c> table,
           or <em>compare equal</em> to the key of an object in an
           <c>ordered_set</c> table (see 
@@ -1855,7 +1688,7 @@ true</pre>
         <list type="bulleted">
           <item>the table is not of type <c>set</c> or
           <c>ordered_set</c>,</item> 
-          <item><c>Pos</c> is less than 1 or greater than the object
+          <item><c><anno>Pos</anno></c> is less than 1 or greater than the object
           arity, or,</item>
           <item>the element to update is also the key</item>
         </list>
diff --git a/lib/stdlib/doc/src/lists.xml b/lib/stdlib/doc/src/lists.xml
index 7042c84437..fc58f3e4d2 100644
--- a/lib/stdlib/doc/src/lists.xml
+++ b/lib/stdlib/doc/src/lists.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2011</year>
+      <year>1996</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -248,18 +248,13 @@ flatmap(Fun, List1) ->
       </desc>
     </func>
     <func>
-      <name>keyfind(Key, N, TupleList) -> Tuple | false</name>
+      <name name="keyfind" arity="3"/>
+      <type_desc variable="N">1..tuple_size(<anno>Tuple</anno>)</type_desc>
       <fsummary>Search for an element in a list of tuples</fsummary>
-      <type>
-        <v>Key = term()</v>
-        <v>N = 1..tuple_size(Tuple)</v>
-        <v>TupleList = [Tuple]</v>
-        <v>Tuple = tuple()</v>
-      </type>
-      <desc>
-        <p>Searches the list of tuples <c>TupleList</c> for a
-          tuple whose <c>N</c>th element compares equal to <c>Key</c>.
-          Returns <c>Tuple</c> if such a tuple is found,
+      <desc>
+        <p>Searches the list of tuples <c><anno>TupleList</anno></c> for a
+          tuple whose <c><anno>N</anno></c>th element compares equal to <c><anno>Key</anno></c>.
+          Returns <c><anno>Tuple</anno></c> if such a tuple is found,
           otherwise <c>false</c>.</p>
       </desc>
     </func>
@@ -281,17 +276,12 @@ flatmap(Fun, List1) ->
       </desc>
     </func>
     <func>
-      <name>keymember(Key, N, TupleList) -> boolean()</name>
+      <name name="keymember" arity="3"/>
+      <type_desc variable="N">1..tuple_size(<anno>Tuple</anno>)</type_desc>
       <fsummary>Test for membership of a list of tuples</fsummary>
-      <type>
-        <v>Key = term()</v>
-        <v>N = 1..tuple_size(Tuple)</v>
-        <v>TupleList = [Tuple]</v>
-        <v>&nbsp;Tuple = tuple()</v>
-      </type>
-      <desc>
-        <p>Returns <c>true</c> if there is a tuple in <c>TupleList</c>
-          whose <c>N</c>th element compares equal to <c>Key</c>, otherwise
+      <desc>
+        <p>Returns <c>true</c> if there is a tuple in <c><anno>TupleList</anno></c>
+          whose <c><anno>N</anno></c>th element compares equal to <c><anno>Key</anno></c>, otherwise
           <c>false</c>.</p>
       </desc>
     </func>
@@ -321,18 +311,13 @@ flatmap(Fun, List1) ->
       </desc>
     </func>
     <func>
-      <name>keysearch(Key, N, TupleList) -> {value, Tuple} | false</name>
+      <name name="keysearch" arity="3"/>
+      <type_desc variable="N">1..tuple_size(<anno>Tuple</anno>)</type_desc>
       <fsummary>Search for an element in a list of tuples</fsummary>
-      <type>
-        <v>Key = term()</v>
-        <v>N = 1..tuple_size(Tuple)</v>
-        <v>TupleList = [Tuple]</v>
-        <v>Tuple = tuple()</v>
-      </type>
-      <desc>
-        <p>Searches the list of tuples <c>TupleList</c> for a
-          tuple whose <c>N</c>th element compares equal to <c>Key</c>.
-          Returns <c>{value, Tuple}</c> if such a tuple is found,
+      <desc>
+        <p>Searches the list of tuples <c><anno>TupleList</anno></c> for a
+          tuple whose <c><anno>N</anno></c>th element compares equal to <c><anno>Key</anno></c>.
+          Returns <c>{value, <anno>Tuple</anno>}</c> if such a tuple is found,
           otherwise <c>false</c>.</p>
       <note><p>This function is retained for backward compatibility.
       The function <c>lists:keyfind/3</c> (introduced in R13A)
@@ -425,15 +410,11 @@ flatmap(Fun, List1) ->
       </desc>
     </func>
     <func>
-      <name>member(Elem, List) -> boolean()</name>
+      <name name="member" arity="2"/>
       <fsummary>Test for membership of a list</fsummary>
-      <type>
-        <v>Elem = term()</v>
-        <v>List = [term()]</v>
-      </type>
       <desc>
-        <p>Returns <c>true</c> if <c>Elem</c> matches some element of
-          <c>List</c>, otherwise <c>false</c>.</p>
+        <p>Returns <c>true</c> if <c><anno>Elem</anno></c> matches some element of
+          <c><anno>List</anno></c>, otherwise <c>false</c>.</p>
       </desc>
     </func>
     <func>
@@ -562,14 +543,11 @@ c</pre>
       </desc>
     </func>
     <func>
-      <name>reverse(List1, Tail) -> List2</name>
+      <name name="reverse" arity="2"/>
       <fsummary>Reverse a list appending a tail</fsummary>
-      <type>
-        <v>List1 = Tail = List2 = [term()]</v>
-      </type>
       <desc>
-        <p>Returns a list with the elements in <c>List1</c>
-          in reverse order, with the tail <c>Tail</c> appended. For
+        <p>Returns a list with the elements in <c><anno>List1</anno></c>
+          in reverse order, with the tail <c><anno>Tail</anno></c> appended. For
           example:</p>
         <pre>
 > <input>lists:reverse([1, 2, 3, 4], [a, b, c]).</input>
diff --git a/lib/stdlib/doc/src/math.xml b/lib/stdlib/doc/src/math.xml
index 518457d5d8..0219dcce10 100644
--- a/lib/stdlib/doc/src/math.xml
+++ b/lib/stdlib/doc/src/math.xml
@@ -5,7 +5,7 @@
   <header>
     <copyright>
       <year>1996</year>
-      <year>2011</year>
+      <year>2012</year>
       <holder>Ericsson AB, All Rights Reserved</holder>
     </copyright>
     <legalnotice>
@@ -52,54 +52,47 @@
       </desc>
     </func>
     <func>
-      <name>sin(X)</name>
-      <name>cos(X)</name>
-      <name>tan(X)</name>
-      <name>asin(X)</name>
-      <name>acos(X)</name>
-      <name>atan(X)</name>
-      <name>atan2(Y, X)</name>
-      <name>sinh(X)</name>
-      <name>cosh(X)</name>
-      <name>tanh(X)</name>
-      <name>asinh(X)</name>
-      <name>acosh(X)</name>
-      <name>atanh(X)</name>
-      <name>exp(X)</name>
-      <name>log(X)</name>
-      <name>log10(X)</name>
-      <name>pow(X, Y)</name>
-      <name>sqrt(X)</name>
+      <name name="sin" arity="1"/>
+      <name name="cos" arity="1"/>
+      <name name="tan" arity="1"/>
+      <name name="asin" arity="1"/>
+      <name name="acos" arity="1"/>
+      <name name="atan" arity="1"/>
+      <name name="atan2" arity="2"/>
+      <name name="sinh" arity="1"/>
+      <name name="cosh" arity="1"/>
+      <name name="tanh" arity="1"/>
+      <name name="asinh" arity="1"/>
+      <name name="acosh" arity="1"/>
+      <name name="atanh" arity="1"/>
+      <name name="exp" arity="1"/>
+      <name name="log" arity="1"/>
+      <name name="log10" arity="1"/>
+      <name name="pow" arity="2"/>
+      <name name="sqrt" arity="1"/>
+      <type variable="X" name_i="7"/>
+      <type variable="Y" name_i="7"/>
       <fsummary>Diverse math functions</fsummary>
-      <type>
-        <v>X = Y = number()</v>
-      </type>
       <desc>
         <p>A collection of math functions which return floats. Arguments
           are numbers. </p>
       </desc>
     </func>
     <func>
-      <name>erf(X) -> float()</name>
+      <name name="erf" arity="1"/>
       <fsummary>Error function.</fsummary>
-      <type>
-        <v>X = number()</v>
-      </type>
       <desc>
-        <p>Returns the error function of <c>X</c>, where</p>
+        <p>Returns the error function of <c><anno>X</anno></c>, where</p>
         <pre>
 erf(X) = 2/sqrt(pi)*integral from 0 to X of exp(-t*t) dt.        </pre>
       </desc>
     </func>
     <func>
-      <name>erfc(X) -> float()</name>
+      <name name="erfc" arity="1"/>
       <fsummary>Another error function</fsummary>
-      <type>
-        <v>X = number()</v>
-      </type>
       <desc>
         <p><c>erfc(X)</c> returns  <c>1.0 - erf(X)</c>, computed  by
-          methods that avoid cancellation for large <c>X</c>. </p>
+          methods that avoid cancellation for large <c><anno>X</anno></c>. </p>
       </desc>
     </func>
   </funcs>
diff --git a/lib/stdlib/doc/src/re.xml b/lib/stdlib/doc/src/re.xml
index 6d5336796c..c6f45fb1e1 100644
--- a/lib/stdlib/doc/src/re.xml
+++ b/lib/stdlib/doc/src/re.xml
@@ -5,7 +5,7 @@
   <header>
     <copyright>
       <year>2007</year>
-      <year>2011</year>
+      <year>2012</year>
       <holder>Ericsson AB, All Rights Reserved</holder>
     </copyright>
     <legalnotice>
@@ -78,28 +78,15 @@
   </datatypes>
   <funcs>
     <func>
-      <name>compile(Regexp) -> {ok, MP} | {error, ErrSpec}</name>
+      <name name="compile" arity="1"/>
       <fsummary>Compile a regular expression into a match program</fsummary>
-      <type>
-        <v>Regexp = iodata()</v>
-      </type>
       <desc>
-      <p>The same as <c>compile(Regexp,[])</c></p>
+      <p>The same as <c>compile(<anno>Regexp</anno>,[])</c></p>
       </desc>
     </func> 
     <func>
-      <name>compile(Regexp,Options) -> {ok, MP} | {error, ErrSpec}</name>
+      <name name="compile" arity="2"/>
       <fsummary>Compile a regular expression into a match program</fsummary>
-      <type>
-        <v>Regexp = iodata() | <seealso marker="unicode#type-charlist">io:charlist()</seealso></v>
-	<v>Options = [ Option ]</v>
-	<v>Option = <seealso marker="#type-compile_option">compile_option()</seealso></v>
-	<v>NLSpec = <seealso marker="#type-nl_spec">nl_spec()</seealso></v>
-	<v>MP = <seealso marker="#type-mp">mp()</seealso></v>
-	<v>ErrSpec = {ErrString, Position}</v>
-	<v>ErrString = string()</v>
-	<v>Position = non_neg_integer()</v>
-      </type>
       <desc>
       <p>This function compiles a regular expression with the syntax
       described below into an internal format to be used later as a
@@ -165,44 +152,23 @@ This option makes it possible to include comments inside complicated patterns. N
     </func> 
 
     <func>
-      <name>run(Subject,RE) -> {match, Captured} | nomatch</name>
+      <name name="run" arity="2"/>
       <fsummary>Match a subject against regular expression and capture subpatterns</fsummary>
-      <type>
-	<v>Subject = iodata() | <seealso marker="unicode#type-charlist">io:charlist()</seealso></v>
-        <v>RE = <seealso marker="#type-mp">mp()</seealso> | iodata()</v>
-	<v>Captured = [ CaptureData ]</v>
-	<v>CaptureData = {integer(),integer()}</v>
-      </type>
       <desc>
-      <p>The same as <c>run(Subject,RE,[])</c>.</p>
+      <p>The same as <c>run(<anno>Subject</anno>,<anno>RE</anno>,[])</c>.</p>
       </desc>
     </func> 
     <func>
-      <name>run(Subject,RE,Options) -> {match, Captured} | match | nomatch</name>
+      <name name="run" arity="3"/>
+      <type_desc variable="CompileOpt">See <seealso marker="#compile_options">compile/2</seealso> above.</type_desc>
       <fsummary>Match a subject against regular expression and capture subpatterns</fsummary>
-      <type>
-	<v>Subject = iodata() | <seealso marker="unicode#type-charlist">io:charlist()</seealso></v>
-        <v>RE = <seealso marker="#type-mp">mp()</seealso> | iodata() | <seealso marker="unicode#type-charlist">io:charlist()</seealso></v>
-	<v>Options = [ Option ]</v>
-	<v>Option = anchored | global | notbol | noteol | notempty | {offset, integer() >= 0} | {newline, NLSpec} | bsr_anycrlf | bsr_unicode | {capture, ValueSpec} | {capture, ValueSpec, Type} | CompileOpt</v>
-	<v>Type = index | list | binary</v>
-	<v>ValueSpec = all | all_but_first | first | none | ValueList</v>
-	<v>ValueList = [ ValueID ]</v>
-	<v>ValueID = integer() | string() | atom()</v>
-	<v>CompileOpt = <seealso marker="#type-compile_option">compile_option()</seealso></v>
-        <d>See <seealso marker="#compile_options">compile/2</seealso> above.</d>
-	<v>NLSpec = <seealso marker="#type-nl_spec">nl_spec()</seealso></v>
-	<v>Captured = [ CaptureData ] | [ [ CaptureData ] ... ]</v>
-	<v>CaptureData = {integer(),integer()} | ListConversionData | binary()</v>
-	<v>ListConversionData = string() | {error, string(), binary()} | {incomplete, string(), binary()}</v>
-      </type>
       <desc>
 
       <p>Executes a regexp matching, returning <c>match/{match,
-      Captured}</c> or <c>nomatch</c>. The regular expression can be
+      <anno>Captured</anno>}</c> or <c>nomatch</c>. The regular expression can be
       given either as <c>iodata()</c> in which case it is
       automatically compiled (as by <c>re:compile/2</c>) and executed,
-      or as a pre compiled <c>mp()</c> in which case it is executed
+      or as a pre-compiled <c>mp()</c> in which case it is executed
       against the subject directly.</p>
 
       <p>When compilation is involved, the exception <c>badarg</c> is
@@ -214,23 +180,23 @@ This option makes it possible to include comments inside complicated patterns. N
       list can only contain the options <c>anchored</c>,
       <c>global</c>, <c>notbol</c>, <c>noteol</c>,
       <c>notempty</c>, <c>{offset, integer() >= 0}</c>, <c>{newline,
-      NLSpec}</c> and <c>{capture, ValueSpec}/{capture, ValueSpec,
-      Type}</c>.  Otherwise all options valid for the
+      <anno>NLSpec</anno>}</c> and <c>{capture, <anno>ValueSpec</anno>}/{capture, <anno>ValueSpec</anno>,
+      <anno>Type</anno>}</c>.  Otherwise all options valid for the
       <c>re:compile/2</c> function are allowed as well. Options
       allowed both for compilation and execution of a match, namely
-      <c>anchored</c> and <c>{newline, NLSpec}</c>, will affect both
+      <c>anchored</c> and <c>{newline, <anno>NLSpec</anno>}</c>, will affect both
       the compilation and execution if present together with a non
       pre-compiled regular expression.</p>
 
       <p>If the regular expression was previously compiled with the
-      option <c>unicode</c>, the <c>Subject</c> should be provided as
+      option <c>unicode</c>, the <c><anno>Subject</anno></c> should be provided as
       a valid Unicode <c>charlist()</c>, otherwise any <c>iodata()</c>
       will do. If compilation is involved and the option
-      <c>unicode</c> is given, both the <c>Subject</c> and the regular
+      <c>unicode</c> is given, both the <c><anno>Subject</anno></c> and the regular
       expression should be given as valid Unicode
       <c>charlists()</c>.</p>
 
-      <p>The <c>{capture, ValueSpec}/{capture, ValueSpec, Type}</c>
+      <p>The <c>{capture, <anno>ValueSpec</anno>}/{capture, <anno>ValueSpec</anno>, <anno>Type</anno>}</c>
       defines what to return from the function upon successful
       matching. The <c>capture</c> tuple may contain both a
       value specification telling which of the captured
@@ -244,9 +210,9 @@ This option makes it possible to include comments inside complicated patterns. N
       at all is to be done (<c>{capture, none}</c>), the function will
       return the single atom <c>match</c> upon successful matching,
       otherwise the tuple
-      <c>{match, ValueList}</c> is returned. Disabling capturing can
+      <c>{match, <anno>ValueList</anno>}</c> is returned. Disabling capturing can
       be done either by specifying <c>none</c> or an empty list as
-      <c>ValueSpec</c>.</p>
+      <c><anno>ValueSpec</anno></c>.</p>
 
       <p>The options relevant for execution are:</p>
 
@@ -266,7 +232,7 @@ This option makes it possible to include comments inside complicated patterns. N
       Perl). Each match is returned as a separate
       <c>list()</c> containing the specific match as well as any
       matching subexpressions (or as specified by the <c>capture
-      option</c>). The <c>Captured</c> part of the return value will
+      option</c>). The <c><anno>Captured</anno></c> part of the return value will
       hence be a <c>list()</c> of <c>list()</c>s when this
       option is given.</p>
 
@@ -362,7 +328,7 @@ This option makes it possible to include comments inside complicated patterns. N
       subject string. The offset is zero-based, so that the default is
       <c>{offset,0}</c> (all of the subject string).</item>
 
-      <tag><c>{newline, NLSpec}</c></tag>
+      <tag><c>{newline, <anno>NLSpec</anno>}</c></tag>
       <item>
       <p>Override the default definition of a newline in the subject string, which is LF (ASCII 10) in Erlang.</p>
       <taglist>
@@ -383,7 +349,7 @@ This option makes it possible to include comments inside complicated patterns. N
       <tag><c>bsr_unicode</c></tag>
       <item>Specifies specifically that \R is to match all the Unicode newline characters (including crlf etc, the default).(overrides compilation option)</item>
 
-      <tag><c>{capture, ValueSpec}</c>/<c>{capture, ValueSpec, Type}</c></tag>
+      <tag><c>{capture, <anno>ValueSpec</anno>}</c>/<c>{capture, <anno>ValueSpec</anno>, <anno>Type</anno>}</c></tag>
       <item>
 
       <p>Specifies which captured substrings are returned and in what
@@ -392,7 +358,7 @@ This option makes it possible to include comments inside complicated patterns. N
       substring as well as all capturing subpatterns (all of the
       pattern is automatically captured). The default return type is
       (zero-based) indexes of the captured parts of the string, given as
-      <c>{Offset,Length}</c> pairs (the <c>index</c> <c>Type</c> of
+      <c>{Offset,Length}</c> pairs (the <c>index</c> <c><anno>Type</anno></c> of
       capturing).</p>
 
       <p>As an example of the default behavior, the following call:</p>
@@ -422,8 +388,8 @@ This option makes it possible to include comments inside complicated patterns. N
 
       <p>The capture tuple is built up as follows:</p>
       <taglist>
-      <tag><c>ValueSpec</c></tag>
-      <item><p>Specifies which captured (sub)patterns are to be returned. The ValueSpec can either be an atom describing a predefined set of return values, or a list containing either the indexes or the names of specific subpatterns to return.</p>
+      <tag><c><anno>ValueSpec</anno></c></tag>
+      <item><p>Specifies which captured (sub)patterns are to be returned. The <c><anno>ValueSpec</anno></c> can either be an atom describing a predefined set of return values, or a list containing either the indexes or the names of specific subpatterns to return.</p>
       <p>The predefined sets of subpatterns are:</p>
         <taglist>
         <tag><c>all</c></tag>
@@ -437,7 +403,7 @@ This option makes it possible to include comments inside complicated patterns. N
         </taglist>
       <p>The value list is a list of indexes for the subpatterns to return, where index 0 is for all of the pattern, and 1 is for the first explicit capturing subpattern in the regular expression, and so forth. When using named captured subpatterns (see below) in the regular expression, one can use <c>atom()</c>s or <c>string()</c>s to specify the subpatterns to be returned. For example, consider the regular expression:</p>
       <code>    ".*(abcd).*"</code>
-      <p>matched against the string ""ABCabcdABC", capturing only the "abcd" part (the first explicit subpattern):</p>
+      <p>matched against the string "ABCabcdABC", capturing only the "abcd" part (the first explicit subpattern):</p>
       <code>    re:run("ABCabcdABC",".*(abcd).*",[{capture,[1]}]).</code>
       <p>The call will yield the following result:</p>
       <code>    {match,[{3,4}]}</code>
@@ -460,8 +426,8 @@ This option makes it possible to include comments inside complicated patterns. N
       or list respectively.</p>
 
       </item>      
-      <tag><c>Type</c></tag>
-      <item><p>Optionally specifies how captured substrings are to be returned. If omitted, the default of <c>index</c> is used. The <c>Type</c> can be one of the following:</p>
+      <tag><c><anno>Type</anno></c></tag>
+      <item><p>Optionally specifies how captured substrings are to be returned. If omitted, the default of <c>index</c> is used. The <c><anno>Type</anno></c> can be one of the following:</p>
         <taglist>
         <tag><c>index</c></tag> 
         <item>Return captured substrings as pairs of byte indexes into the subject string and length of the matching string in the subject (as if the subject string was flattened with <c>iolist_to_binary/1</c> or <c>unicode:characters_to_binary/2</c> prior to matching). Note that the <c>unicode</c> option results in <em>byte-oriented</em> indexes in a (possibly virtual) <em>UTF-8 encoded</em> binary. A byte index tuple <c>{0,2}</c> might therefore represent one or two characters when <c>unicode</c> is in effect. This might seem counter-intuitive, but has been deemed the most effective and useful way to way to do it. To return lists instead might result in simpler code if that is desired. This return type is the default.</item>
@@ -478,7 +444,7 @@ This option makes it possible to include comments inside complicated patterns. N
 <code>    "ABCabcdABC"</code>
       <p>the subpattern at index 2 won't match, as "abdd" is not present in the string, but the complete pattern matches (due to the alternative <c>a(..d)</c>. The subpattern at index 2 is therefore unassigned and the default return value will be:</p>
 <code>    {match,[{0,10},{3,4},{-1,0},{4,3}]}</code>
-      <p>Setting the capture <c>Type</c> to <c>binary</c> would give the following:</p>
+      <p>Setting the capture <c><anno>Type</anno></c> to <c>binary</c> would give the following:</p>
 <code>    {match,[&lt;&lt;"ABCabcdABC"&gt;&gt;,&lt;&lt;"abcd"&gt;&gt;,&lt;&lt;&gt;&gt;,&lt;&lt;"bcd"&gt;&gt;]}</code>
       <p>where the empty binary (<c>&lt;&lt;&gt;&gt;</c>) represents the unassigned subpattern. In the <c>binary</c> case, some information about the matching is therefore lost, the <c>&lt;&lt;&gt;&gt;</c> might just as well be an empty string captured.</p>
       <p>If differentiation between empty matches and non existing subpatterns is necessary, use the <c>type</c> <c>index</c>
diff --git a/lib/stdlib/doc/src/string.xml b/lib/stdlib/doc/src/string.xml
index 48867ffe72..549c871aed 100644
--- a/lib/stdlib/doc/src/string.xml
+++ b/lib/stdlib/doc/src/string.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>1996</year><year>2011</year>
+      <year>1996</year><year>2012</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -255,18 +255,12 @@ sub_string("Hello World", 4, 8).
       </desc>
     </func>
     <func>
-      <name>to_float(String) -> {Float,Rest} | {error,Reason} </name>
+      <name name="to_float" arity="1"/>
       <fsummary>Returns a float whose text representation is the integers (ASCII values) in String.</fsummary>
-      <type>
-        <v>String = string()</v>
-        <v>Float = float()</v>
-        <v>Rest = string()</v>
-        <v>Reason = no_float | not_a_list</v>
-      </type>
       <desc>
-        <p>Argument <c>String</c> is expected to start with a valid text
+        <p>Argument <c><anno>String</anno></c> is expected to start with a valid text
           represented float (the digits being ASCII values). Remaining characters 
-          in the string after the float are returned in <c>Rest</c>.</p>
+          in the string after the float are returned in <c><anno>Rest</anno></c>.</p>
         <p>Example:</p>
         <code type="none">
           > {F1,Fs} = string:to_float("1.0-1.0e-1"),
@@ -280,18 +274,12 @@ sub_string("Hello World", 4, 8).
       </desc>
     </func>
     <func>
-      <name>to_integer(String) -> {Int,Rest} | {error,Reason} </name>
+      <name name="to_integer" arity="1"/>
       <fsummary>Returns an integer whose text representation is the integers (ASCII values) in String.</fsummary>
-      <type>
-        <v>String = string()</v>
-        <v>Int = integer()</v>
-        <v>Rest = string()</v>
-        <v>Reason = no_integer | not_a_list</v>
-      </type>
       <desc>
-        <p>Argument <c>String</c> is expected to start with a valid text
+        <p>Argument <c><anno>String</anno></c> is expected to start with a valid text
           represented integer (the digits being ASCII values). Remaining characters 
-          in the string after the integer are returned in <c>Rest</c>.</p>
+          in the string after the integer are returned in <c><anno>Rest</anno></c>.</p>
         <p>Example:</p>
         <code type="none">
           > {I1,Is} = string:to_integer("33+22"),
diff --git a/lib/stdlib/doc/src/unicode.xml b/lib/stdlib/doc/src/unicode.xml
index 1001ebbae4..1f6cbaccd7 100644
--- a/lib/stdlib/doc/src/unicode.xml
+++ b/lib/stdlib/doc/src/unicode.xml
@@ -5,7 +5,7 @@
   <header>
     <copyright>
       <year>1996</year>
-      <year>2011</year>
+      <year>2012</year>
       <holder>Ericsson AB, All Rights Reserved</holder>
     </copyright>
     <legalnotice>
@@ -130,34 +130,24 @@
       </desc>
     </func>
     <func>
-      <name>characters_to_list(Data, InEncoding) -> Result</name>
+      <name name="characters_to_list" arity="2"/>
       <fsummary>Convert a collection of characters to list of Unicode characters</fsummary>
-      <type>
-        <v>Data = <seealso marker="#type-latin1_chardata">latin1_chardata()</seealso>
-                | <seealso marker="#type-chardata">chardata()</seealso>
-                | <seealso marker="#type-external_chardata">external_chardata()</seealso></v>
-        <v>Result = list() | {error, list(), RestData} | {incomplete, list(), binary()}</v>
-        <v>RestData = <seealso marker="#type-latin1_chardata">latin1_chardata()</seealso>
-                    | <seealso marker="#type-chardata">chardata()</seealso>
-                    | <seealso marker="#type-external_chardata">external_chardata()</seealso></v>
-        <v>InEncoding = <seealso marker="#type-encoding">encoding()</seealso></v>
-      </type>
       <desc>
 
       <p>This function converts a possibly deep list of integers and
       binaries into a list of integers representing unicode
       characters. The binaries in the input may have characters
       encoded as latin1 (0 - 255, one character per byte), in which
-      case the <c>InEncoding</c> parameter should be given as
+      case the <c><anno>InEncoding</anno></c> parameter should be given as
       <c>latin1</c>, or have characters encoded as one of the
-      UTF-encodings, which is given as the <c>InEncoding</c>
-      parameter. Only when the <c>InEncoding</c> is one of the UTF
+      UTF-encodings, which is given as the <c><anno>InEncoding</anno></c>
+      parameter. Only when the <c><anno>InEncoding</anno></c> is one of the UTF
       encodings, integers in the list are allowed to be grater than
       255.</p>
       
-      <p>If <c>InEncoding</c> is <c>latin1</c>, the <c>Data</c> parameter
+      <p>If <c><anno>InEncoding</anno></c> is <c>latin1</c>, the <c><anno>Data</anno></c> parameter
       corresponds to the <c>iodata()</c> type, but for <c>unicode</c>,
-      the <c>Data</c> parameter can contain integers greater than 255
+      the <c><anno>Data</anno></c> parameter can contain integers greater than 255
       (unicode characters beyond the iso-latin-1 range), which would
       make it invalid as <c>iodata()</c>.</p>
 
@@ -188,16 +178,16 @@
       depth as the original data. The error occurs when traversing the
       list and whatever's left to decode is simply returned as is.</p>
 
-      <p>However, if the input <c>Data</c> is a pure binary, the third
+      <p>However, if the input <c><anno>Data</anno></c> is a pure binary, the third
       part of the error tuple is guaranteed to be a binary as
       well.</p>
 
       <p>Errors occur for the following reasons:</p>
       <list type="bulleted">
 
-           <item>Integers out of range - If <c>InEncoding</c> is
+           <item>Integers out of range - If <c><anno>InEncoding</anno></c> is
 	   <c>latin1</c>, an error occurs whenever an integer greater
-	   than 255 is found in the lists. If <c>InEncoding</c> is
+	   than 255 is found in the lists. If <c><anno>InEncoding</anno></c> is
 	   of a Unicode type, an error occurs whenever an integer
 	   <list type="bulleted">
 	     <item>greater than <c>16#10FFFF</c>
@@ -208,7 +198,7 @@
 	   is found.
 	   </item>
 
-	   <item>UTF encoding incorrect - If <c>InEncoding</c> is
+	   <item>UTF encoding incorrect - If <c><anno>InEncoding</anno></c> is
 	   one of the UTF types, the bytes in any binaries have to be valid
 	   in that encoding. Errors can occur for various
 	   reasons, including &quot;pure&quot; decoding errors 
@@ -220,7 +210,7 @@
 	   number should have been encoded in fewer bytes. The
 	   case of a truncated UTF is handled specially, see the
 	   paragraph about incomplete binaries below. If
-	   <c>InEncoding</c> is <c>latin1</c>, binaries are always valid 
+	   <c><anno>InEncoding</anno></c> is <c>latin1</c>, binaries are always valid
 	   as long as they contain whole bytes,
 	   as each byte falls into the valid iso-latin-1 range.</item>
 
@@ -238,7 +228,7 @@
       the first part of a (so far) valid UTF character.</p>
 
       <p>If one UTF characters is split over two consecutive
-      binaries in the <c>Data</c>, the conversion succeeds. This means
+      binaries in the <c><anno>Data</anno></c>, the conversion succeeds. This means
       that a character can be decoded from a range of binaries as long
       as the whole range is given as input without errors
       occurring. Example:</p>
@@ -274,21 +264,11 @@
       </desc>
     </func>
     <func>    
-     <name>characters_to_binary(Data,InEncoding) -> Result</name>
+     <name name="characters_to_binary" arity="2"/>
       <fsummary>Convert a collection of characters to an UTF-8 binary</fsummary>
 
-      <type>
-        <v>Data = <seealso marker="#type-latin1_chardata">latin1_chardata()</seealso>
-                | <seealso marker="#type-chardata">chardata()</seealso>
-                | <seealso marker="#type-external_chardata">external_chardata()</seealso></v>
-        <v>Result = binary() | {error, binary(), RestData} | {incomplete, binary(), binary()}</v>
-        <v>RestData = <seealso marker="#type-latin1_chardata">latin1_chardata()</seealso>
-                    | <seealso marker="#type-chardata">chardata()</seealso>
-                    | <seealso marker="#type-external_chardata">external_chardata()</seealso></v>
-        <v>InEncoding = <seealso marker="#type-encoding">encoding()</seealso></v>
-      </type>
       <desc>
-      <p>Same as characters_to_binary(Data, InEncoding, unicode).</p>
+      <p>Same as characters_to_binary(<anno>Data</anno>, <anno>InEncoding</anno>, unicode).</p>
       </desc>
     </func>    
     <func>
diff --git a/lib/stdlib/src/binary.erl b/lib/stdlib/src/binary.erl
index cb1e12ae46..0e95372a76 100644
--- a/lib/stdlib/src/binary.erl
+++ b/lib/stdlib/src/binary.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2010-2011. All Rights Reserved.
+%% Copyright Ericsson AB 2010-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -18,29 +18,185 @@
 %%
 -module(binary).
 %%
-%% The following functions implemented as BIF's
-%%  binary:compile_pattern/1
-%%  binary:match/{2,3}
-%%  binary:matches/{2,3}
-%%  binary:longest_common_prefix/1
-%%  binary:longest_common_suffix/1
-%%  binary:first/1
-%%  binary:last/1
-%%  binary:at/2
-%%  binary:part/{2,3}
-%%  binary:bin_to_list/{1,2,3}
-%%  binary:list_to_bin/1
-%%  binary:copy/{1,2}
-%%  binary:referenced_byte_size/1
-%%  binary:decode_unsigned/{1,2}
-%% - Not yet:
-%%
 %% Implemented in this module:
 -export([split/2,split/3,replace/3,replace/4]).
 
 -opaque cp() :: tuple().
 -type part() :: {Start :: non_neg_integer(), Length :: integer()}.
 
+%%% BIFs.
+
+-export([at/2, bin_to_list/1, bin_to_list/2, bin_to_list/3,
+         compile_pattern/1, copy/1, copy/2, decode_unsigned/1,
+         decode_unsigned/2, encode_unsigned/1, encode_unsigned/2,
+         first/1, last/1, list_to_bin/1, longest_common_prefix/1,
+         longest_common_suffix/1, match/2, match/3, matches/2,
+         matches/3, part/2, part/3, referenced_byte_size/1]).
+
+-spec at(Subject, Pos) -> byte() when
+      Subject :: binary(),
+      Pos :: non_neg_integer().
+
+at(_, _) ->
+    erlang:nif_error(undef).
+
+-spec bin_to_list(Subject) -> [byte()] when
+      Subject :: binary().
+
+bin_to_list(_) ->
+    erlang:nif_error(undef).
+
+-spec bin_to_list(Subject, PosLen) -> [byte()] when
+      Subject :: binary(),
+      PosLen :: part().
+
+bin_to_list(_, _) ->
+    erlang:nif_error(undef).
+
+-spec bin_to_list(Subject, Pos, Len) -> [byte()] when
+      Subject :: binary(),
+      Pos :: non_neg_integer(),
+      Len :: non_neg_integer().
+
+bin_to_list(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec compile_pattern(Pattern) -> cp() when
+      Pattern :: binary() | [binary()].
+
+compile_pattern(_) ->
+    erlang:nif_error(undef).
+
+-spec copy(Subject) -> binary() when
+      Subject :: binary().
+
+copy(_) ->
+    erlang:nif_error(undef).
+
+-spec copy(Subject, N) -> binary() when
+      Subject :: binary(),
+      N :: non_neg_integer().
+
+copy(_, _) ->
+    erlang:nif_error(undef).
+
+-spec decode_unsigned(Subject) -> Unsigned when
+      Subject :: binary(),
+      Unsigned :: non_neg_integer().
+
+decode_unsigned(_) ->
+    erlang:nif_error(undef).
+
+-spec decode_unsigned(Subject, Endianess) -> Unsigned when
+      Subject :: binary(),
+      Endianess :: big | little,
+      Unsigned :: non_neg_integer().
+
+decode_unsigned(_, _) ->
+    erlang:nif_error(undef).
+
+-spec encode_unsigned(Unsigned) -> binary() when
+      Unsigned :: non_neg_integer().
+
+encode_unsigned(_) ->
+    erlang:nif_error(undef).
+
+-spec encode_unsigned(Unsigned, Endianess) -> binary() when
+      Unsigned :: non_neg_integer(),
+      Endianess :: big | little.
+
+encode_unsigned(_, _) ->
+    erlang:nif_error(undef).
+
+-spec first(Subject) -> byte() when
+      Subject :: binary().
+
+first(_) ->
+    erlang:nif_error(undef).
+
+-spec last(Subject) -> byte() when
+      Subject :: binary().
+
+last(_) ->
+    erlang:nif_error(undef).
+
+-spec list_to_bin(ByteList) -> binary() when
+      ByteList :: iodata().
+
+list_to_bin(_) ->
+    erlang:nif_error(undef).
+
+-spec longest_common_prefix(Binaries) -> non_neg_integer() when
+      Binaries :: [binary()].
+
+longest_common_prefix(_) ->
+    erlang:nif_error(undef).
+
+-spec longest_common_suffix(Binaries) -> non_neg_integer() when
+      Binaries :: [binary()].
+
+longest_common_suffix(_) ->
+    erlang:nif_error(undef).
+
+-spec match(Subject, Pattern) -> Found | nomatch when
+      Subject :: binary(),
+      Pattern :: binary() | [binary()] | cp(),
+      Found :: part().
+
+match(_, _) ->
+    erlang:nif_error(undef).
+
+-spec match(Subject, Pattern, Options) -> Found | nomatch when
+      Subject :: binary(),
+      Pattern :: binary() | [binary()] | cp(),
+      Found :: part(),
+      Options :: [Option],
+      Option :: {scope, part()}.
+
+match(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec matches(Subject, Pattern) -> Found when
+      Subject :: binary(),
+      Pattern :: binary() | [binary()] | cp(),
+      Found :: [part()].
+
+matches(_, _) ->
+    erlang:nif_error(undef).
+
+-spec matches(Subject, Pattern, Options) -> Found when
+      Subject :: binary(),
+      Pattern :: binary() | [binary()] | cp(),
+      Found :: [part()],
+      Options :: [Option],
+      Option :: {scope, part()}.
+
+matches(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec part(Subject, PosLen) -> binary() when
+      Subject :: binary(),
+      PosLen :: part().
+
+part(_, _) ->
+    erlang:nif_error(undef).
+
+-spec part(Subject, Pos, Len) -> binary() when
+      Subject :: binary(),
+      Pos :: non_neg_integer(),
+      Len :: non_neg_integer().
+
+part(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec referenced_byte_size(Binary) -> non_neg_integer() when
+      Binary :: binary().
+
+referenced_byte_size(_) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs.
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %% split
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
diff --git a/lib/stdlib/src/ets.erl b/lib/stdlib/src/ets.erl
index afa914a456..4a96808810 100644
--- a/lib/stdlib/src/ets.erl
+++ b/lib/stdlib/src/ets.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -46,7 +46,12 @@
 
 %%-----------------------------------------------------------------------------
 
+-type access()     :: public | protected | private.
 -type tab()        :: atom() | tid().
+-type type()       :: set | ordered_set | bag | duplicate_bag.
+-type continuation() :: '$end_of_table'
+                      | {tab(),integer(),integer(),binary(),list(),integer()}
+                      | {tab(),_,_,integer(),binary(),list(),integer(),integer()}.
 
 %% a similar definition is also in erl_types
 -opaque tid()      :: integer().
@@ -57,59 +62,397 @@
 
 %%-----------------------------------------------------------------------------
 
-%% The following functions used to be found in this module, but
-%% are now BIFs (i.e. implemented in C).
-%%
-%% all/0
-%% new/2
-%% delete/1
-%% delete/2
-%% first/1
-%% info/1
-%% info/2
-%% safe_fixtable/2
-%% lookup/2
-%% lookup_element/3
-%% insert/2
-%% is_compiled_ms/1
-%% last/1
-%% member/2
-%% next/2
-%% prev/2
-%% rename/2
-%% slot/2
-%% match/1
-%% match/2
-%% match/3
-%% match_object/1
-%% match_object/2
-%% match_object/3
-%% match_spec_compile/1
-%% match_spec_run_r/3
-%% select/1
-%% select/2
-%% select/3
-%% select_count/2
-%% select_reverse/1
-%% select_reverse/2
-%% select_reverse/3
-%% select_delete/2
-%% setopts/2
-%% update_counter/3
-%% update_element/3
-%%
+%%% BIFs
+
+-export([all/0, delete/1, delete/2, delete_all_objects/1,
+         delete_object/2, first/1, give_away/3, info/1, info/2,
+         insert/2, insert_new/2, is_compiled_ms/1, last/1, lookup/2,
+         lookup_element/3, match/1, match/2, match/3, match_object/1,
+         match_object/2, match_object/3, match_spec_compile/1,
+         match_spec_run_r/3, member/2, new/2, next/2, prev/2,
+         rename/2, safe_fixtable/2, select/1, select/2, select/3,
+         select_count/2, select_delete/2, select_reverse/1,
+         select_reverse/2, select_reverse/3, setopts/2, slot/2,
+         update_counter/3, update_element/3]).
+
+-spec all() -> [Tab] when
+      Tab :: tab().
+
+all() ->
+    erlang:nif_error(undef).
+
+-spec delete(Tab) -> true when
+      Tab :: tab().
+
+delete(_) ->
+    erlang:nif_error(undef).
+
+-spec delete(Tab, Key) -> true when
+      Tab :: tab(),
+      Key :: term().
+
+delete(_, _) ->
+    erlang:nif_error(undef).
+
+-spec delete_all_objects(Tab) -> true when
+      Tab :: tab().
+
+delete_all_objects(_) ->
+    erlang:nif_error(undef).
+
+-spec delete_object(Tab, Object) -> true when
+      Tab :: tab(),
+      Object :: tuple().
+
+delete_object(_, _) ->
+    erlang:nif_error(undef).
+
+-spec first(Tab) -> Key | '$end_of_table' when
+      Tab :: tab(),
+      Key :: term().
+
+first(_) ->
+    erlang:nif_error(undef).
+
+-spec give_away(Tab, Pid, GiftData) -> true when
+      Tab :: tab(),
+      Pid :: pid(),
+      GiftData :: term().
+
+give_away(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec info(Tab) -> InfoList | undefined when
+      Tab :: tab(),
+      InfoList :: [InfoTuple],
+      InfoTuple :: {compressed, boolean()}
+                 | {heir, pid() | none}
+                 | {keypos, pos_integer()}
+                 | {memory, non_neg_integer()}
+                 | {name, atom()}
+                 | {named_table, boolean()}
+                 | {node, node()}
+                 | {owner, pid()}
+                 | {protection, access()}
+                 | {size, non_neg_integer()}
+                 | {type, type()}.
+
+info(_) ->
+    erlang:nif_error(undef).
+
+-spec info(Tab, Item) -> Value | undefined when
+      Tab :: tab(),
+      Item :: compressed | fixed | heir | keypos | memory
+            | name | named_table | node | owner | protection
+            | safe_fixed | size | stats | type,
+      Value :: term().
+
+info(_, _) ->
+    erlang:nif_error(undef).
+
+-spec insert(Tab, ObjectOrObjects) -> true when
+      Tab :: tab(),
+      ObjectOrObjects :: tuple() | [tuple()].
+
+insert(_, _) ->
+    erlang:nif_error(undef).
+
+-spec insert_new(Tab, ObjectOrObjects) -> boolean() when
+      Tab :: tab(),
+      ObjectOrObjects :: tuple() | [tuple()].
+
+insert_new(_, _) ->
+    erlang:nif_error(undef).
+
+-spec is_compiled_ms(Term) -> boolean() when
+      Term :: term().
+
+is_compiled_ms(_) ->
+    erlang:nif_error(undef).
+
+-spec last(Tab) -> Key | '$end_of_table' when
+      Tab :: tab(),
+      Key :: term().
+
+last(_) ->
+    erlang:nif_error(undef).
+
+-spec lookup(Tab, Key) -> [Object] when
+      Tab :: tab(),
+      Key :: term(),
+      Object :: tuple().
+
+lookup(_, _) ->
+    erlang:nif_error(undef).
+
+-spec lookup_element(Tab, Key, Pos) -> Elem when
+      Tab :: tab(),
+      Key :: term(),
+      Pos :: pos_integer(),
+      Elem :: term() | [term()].
+
+lookup_element(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec match(Tab, Pattern) -> [Match] when
+      Tab :: tab(),
+      Pattern :: match_pattern(),
+      Match :: [term()].
+
+match(_, _) ->
+    erlang:nif_error(undef).
+
+-spec match(Tab, Pattern, Limit) -> {[Match], Continuation} |
+                                       '$end_of_table'  when
+      Tab :: tab(),
+      Pattern :: match_pattern(),
+      Limit :: pos_integer(),
+      Match :: [term()],
+      Continuation :: continuation().
+
+match(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec match(Continuation) -> {[Match], Continuation} |
+                                '$end_of_table'  when
+      Match :: [term()],
+      Continuation :: continuation().
+
+match(_) ->
+    erlang:nif_error(undef).
+
+-spec match_object(Tab, Pattern) -> [Object] when
+      Tab :: tab(),
+      Pattern :: match_pattern(),
+      Object :: tuple().
+
+match_object(_, _) ->
+    erlang:nif_error(undef).
+
+-spec match_object(Tab, Pattern, Limit) -> {[Match], Continuation} |
+                                           '$end_of_table' when
+      Tab :: tab(),
+      Pattern :: match_pattern(),
+      Limit :: pos_integer(),
+      Match :: [term()],
+      Continuation :: continuation().
+
+match_object(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec match_object(Continuation) -> {[Match], Continuation} |
+                                    '$end_of_table' when
+      Match :: [term()],
+      Continuation :: continuation().
+
+match_object(_) ->
+    erlang:nif_error(undef).
+
+-spec match_spec_compile(MatchSpec) -> CompiledMatchSpec when
+      MatchSpec :: match_spec(),
+      CompiledMatchSpec :: comp_match_spec().
+
+match_spec_compile(_) ->
+    erlang:nif_error(undef).
+
+-spec match_spec_run_r(List, CompiledMatchSpec, list()) -> list() when
+      List :: [tuple()],
+      CompiledMatchSpec :: comp_match_spec().
+
+match_spec_run_r(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec member(Tab, Key) -> boolean() when
+      Tab :: tab(),
+      Key :: term().
+
+member(_, _) ->
+    erlang:nif_error(undef).
+
+-spec new(Name, Options) -> tid() | atom() when
+      Name :: atom(),
+      Options :: [Option],
+      Option :: Type | Access | named_table | {keypos,Pos}
+              | {heir, Pid :: pid(), HeirData} | {heir, none} | Tweaks,
+      Type :: type(),
+      Access :: access(),
+      Tweaks :: {write_concurrency, boolean()}
+              | {read_concurrency, boolean()}
+              | compressed,
+      Pos :: pos_integer(),
+      HeirData :: term().
+
+new(_, _) ->
+    erlang:nif_error(undef).
+
+-spec next(Tab, Key1) -> Key2 | '$end_of_table' when
+      Tab :: tab(),
+      Key1 :: term(),
+      Key2 :: term().
+
+next(_, _) ->
+    erlang:nif_error(undef).
+
+-spec prev(Tab, Key1) -> Key2 | '$end_of_table' when
+      Tab :: tab(),
+      Key1 :: term(),
+      Key2 :: term().
+
+prev(_, _) ->
+    erlang:nif_error(undef).
+
+-spec rename(Tab, Name) -> Name when
+      Tab :: tab(),
+      Name :: atom().
+
+rename(_, _) ->
+    erlang:nif_error(undef).
+
+-spec safe_fixtable(Tab, Fix) -> true when
+      Tab :: tab(),
+      Fix :: boolean().
+
+safe_fixtable(_, _) ->
+    erlang:nif_error(undef).
+
+-spec select(Tab, MatchSpec) -> [Match] when
+      Tab :: tab(),
+      MatchSpec :: match_spec(),
+      Match :: term().
+
+select(_, _) ->
+    erlang:nif_error(undef).
+
+-spec select(Tab, MatchSpec, Limit) -> {[Match],Continuation} |
+                                       '$end_of_table' when
+      Tab :: tab(),
+      MatchSpec :: match_spec(),
+      Limit :: pos_integer(),
+      Match :: term(),
+      Continuation :: continuation().
+
+select(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec select(Continuation) -> {[Match],Continuation} | '$end_of_table' when
+      Match :: term(),
+      Continuation :: continuation().
+
+select(_) ->
+    erlang:nif_error(undef).
+
+-spec select_count(Tab, MatchSpec) -> NumMatched when
+      Tab :: tab(),
+      MatchSpec :: match_spec(),
+      NumMatched :: non_neg_integer().
+
+select_count(_, _) ->
+    erlang:nif_error(undef).
+
+-spec select_delete(Tab, MatchSpec) -> NumDeleted when
+      Tab :: tab(),
+      MatchSpec :: match_spec(),
+      NumDeleted :: non_neg_integer().
+
+select_delete(_, _) ->
+    erlang:nif_error(undef).
+
+-spec select_reverse(Tab, MatchSpec) -> [Match] when
+      Tab :: tab(),
+      MatchSpec :: match_spec(),
+      Match :: term().
+
+select_reverse(_, _) ->
+    erlang:nif_error(undef).
+
+-spec select_reverse(Tab, MatchSpec, Limit) -> {[Match],Continuation} |
+                                               '$end_of_table' when
+      Tab :: tab(),
+      MatchSpec :: match_spec(),
+      Limit :: pos_integer(),
+      Match :: term(),
+      Continuation :: continuation().
+
+select_reverse(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec select_reverse(Continuation) -> {[Match],Continuation} |
+                                      '$end_of_table' when
+      Continuation :: continuation(),
+      Match :: term().
+
+select_reverse(_) ->
+    erlang:nif_error(undef).
+
+-spec setopts(Tab, Opts) -> true when
+      Tab :: tab(),
+      Opts :: Opt | [Opt],
+      Opt :: {heir, pid(), HeirData} | {heir,none},
+      HeirData :: term().
+
+setopts(_, _) ->
+    erlang:nif_error(undef).
+
+-spec slot(Tab, I) -> [Object] | '$end_of_table' when
+      Tab :: tab(),
+      I :: non_neg_integer(),
+      Object :: tuple().
+
+slot(_, _) ->
+    erlang:nif_error(undef).
+
+-spec update_counter(Tab, Key, UpdateOp) -> Result when
+      Tab :: tab(),
+      Key :: term(),
+      UpdateOp :: {Pos, Incr} | {Pos, Incr, Threshold, SetValue},
+      Pos :: integer(),
+      Incr :: integer(),
+      Threshold :: integer(),
+      SetValue :: integer(),
+      Result :: integer();
+                       (Tab, Key, [UpdateOp]) -> [Result] when
+      Tab :: tab(),
+      Key :: term(),
+      UpdateOp :: {Pos, Incr} | {Pos, Incr, Threshold, SetValue},
+      Pos :: integer(),
+      Incr :: integer(),
+      Threshold :: integer(),
+      SetValue :: integer(),
+      Result :: integer();
+                       (Tab, Key, Incr) -> Result when
+      Tab :: tab(),
+      Key :: term(),
+      Incr :: integer(),
+      Result :: integer().
+
+update_counter(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec update_element(Tab, Key, ElementSpec :: {Pos, Value}) -> boolean() when
+      Tab :: tab(),
+      Key :: term(),
+      Pos :: pos_integer(),
+      Value :: term();
+                       (Tab, Key, ElementSpec :: [{Pos, Value}]) -> boolean() when
+      Tab :: tab(),
+      Key :: term(),
+      Pos :: pos_integer(),
+      Value :: term().
+
+update_element(_, _, _) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
 
 -opaque comp_match_spec() :: any().  %% this one is REALLY opaque
 
--spec match_spec_run([tuple()], comp_match_spec()) -> [term()].
+-spec match_spec_run(List, CompiledMatchSpec) -> list() when
+      List :: [tuple()],
+      CompiledMatchSpec :: comp_match_spec().
 
 match_spec_run(List, CompiledMS) ->
     lists:reverse(ets:match_spec_run_r(List, CompiledMS, [])).
 
--type continuation() :: '$end_of_table'
-                      | {tab(),integer(),integer(),binary(),list(),integer()}
-                      | {tab(),_,_,integer(),binary(),list(),integer(),integer()}.
-
 -spec repair_continuation(Continuation, MatchSpec) -> Continuation when
       Continuation :: continuation(),
       MatchSpec :: match_spec().
diff --git a/lib/stdlib/src/lists.erl b/lib/stdlib/src/lists.erl
index e73c087753..d4f14dc8f5 100644
--- a/lib/stdlib/src/lists.erl
+++ b/lib/stdlib/src/lists.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -33,9 +33,6 @@
 	 keysort/2, keymerge/3, rkeymerge/3, rukeymerge/3, 
 	 ukeysort/2, ukeymerge/3, keymap/3]).
 
-%% Bifs: member/2, reverse/2
-%% Bifs: keymember/3, keysearch/3, keyfind/3
-
 -export([merge/3, rmerge/3, sort/2, umerge/3, rumerge/3, usort/2]).
 
 -export([all/2,any/2,map/2,flatmap/2,foldl/3,foldr/3,filter/2,
@@ -43,6 +40,55 @@
 	 mapfoldl/3,mapfoldr/3,foreach/2,takewhile/2,dropwhile/2,splitwith/2,
 	 split/2]).
 
+%%% BIFs
+-export([keyfind/3, keymember/3, keysearch/3, member/2, reverse/2]).
+
+-spec keyfind(Key, N, TupleList) -> Tuple | false when
+      Key :: term(),
+      N :: pos_integer(),
+      TupleList :: [Tuple],
+      Tuple :: tuple().
+
+keyfind(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec keymember(Key, N, TupleList) -> boolean() when
+      Key :: term(),
+      N :: pos_integer(),
+      TupleList :: [Tuple],
+      Tuple :: tuple().
+
+keymember(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec keysearch(Key, N, TupleList) -> {value, Tuple} | false when
+      Key :: term(),
+      N :: pos_integer(),
+      TupleList :: [Tuple],
+      Tuple :: tuple().
+
+keysearch(_, _, _) ->
+    erlang:nif_error(undef).
+
+-spec member(Elem, List) -> boolean() when
+      Elem :: T,
+      List :: [T],
+      T :: term().
+
+member(_, _) ->
+    erlang:nif_error(undef).
+
+-spec reverse(List1, Tail) -> List2 when
+      List1 :: [T],
+      Tail :: term(),
+      List2 :: [T],
+      T :: term().
+
+reverse(_, _) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 %% member(X, L) -> (true | false)
 %%  test if X is a member of the list L
 %%  Now a BIF!
@@ -84,7 +130,7 @@ append([]) -> [].
 
 subtract(L1, L2) -> L1 -- L2.
 
-%% reverse(L) reverse all elements in the list L. Is now a BIF!
+%% reverse(L) reverse all elements in the list L. reverse/2 is now a BIF!
 
 -spec reverse(List1) -> List2 when
       List1 :: [T],
@@ -581,6 +627,7 @@ flatlength([_|T], L) ->
 flatlength([], L) -> L.
 
 %% keymember(Key, Index, [Tuple]) Now a BIF!
+%% keyfind(Key, Index, [Tuple]) A BIF!
 %% keysearch(Key, Index, [Tuple]) Now a BIF!
 %% keydelete(Key, Index, [Tuple])
 %% keyreplace(Key, Index, [Tuple], NewTuple)
diff --git a/lib/stdlib/src/math.erl b/lib/stdlib/src/math.erl
index b2ea6195c5..c3fb684ec3 100644
--- a/lib/stdlib/src/math.erl
+++ b/lib/stdlib/src/math.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1996-2009. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -20,6 +20,116 @@
 
 -export([pi/0]).
 
+%%% BIFs
+
+-export([sin/1, cos/1, tan/1, asin/1, acos/1, atan/1, atan2/2, sinh/1,
+         cosh/1, tanh/1, asinh/1, acosh/1, atanh/1, exp/1, log/1,
+         log10/1, pow/2, sqrt/1, erf/1, erfc/1]).
+
+-spec acos(X) -> float() when
+      X :: number().
+acos(_) ->
+    erlang:nif_error(undef).
+
+-spec acosh(X) -> float() when
+      X :: number().
+acosh(_) ->
+    erlang:nif_error(undef).
+
+-spec asin(X) -> float() when
+      X :: number().
+asin(_) ->
+    erlang:nif_error(undef).
+
+-spec asinh(X) -> float() when
+      X :: number().
+asinh(_) ->
+    erlang:nif_error(undef).
+
+-spec atan(X) -> float() when
+      X :: number().
+atan(_) ->
+    erlang:nif_error(undef).
+
+-spec atan2(X, Y) -> float() when
+      X :: number(),
+      Y :: number().
+atan2(_, _) ->
+    erlang:nif_error(undef).
+
+-spec atanh(X) -> float() when
+      X :: number().
+atanh(_) ->
+    erlang:nif_error(undef).
+
+-spec cos(X) -> float() when
+      X :: number().
+cos(_) ->
+    erlang:nif_error(undef).
+
+-spec cosh(X) -> float() when
+      X :: number().
+cosh(_) ->
+    erlang:nif_error(undef).
+
+-spec erf(X) -> float() when
+      X :: number().
+erf(_) ->
+    erlang:nif_error(undef).
+
+-spec erfc(X) -> float() when
+      X :: number().
+erfc(_) ->
+    erlang:nif_error(undef).
+
+-spec exp(X) -> float() when
+      X :: number().
+exp(_) ->
+    erlang:nif_error(undef).
+
+-spec log(X) -> float() when
+      X :: number().
+log(_) ->
+    erlang:nif_error(undef).
+
+-spec log10(X) -> float() when
+      X :: number().
+log10(_) ->
+    erlang:nif_error(undef).
+
+-spec pow(X, Y) -> float() when
+      X :: number(),
+      Y :: number().
+pow(_, _) ->
+    erlang:nif_error(undef).
+
+-spec sin(X) -> float() when
+      X :: number().
+sin(_) ->
+    erlang:nif_error(undef).
+
+-spec sinh(X) -> float() when
+      X :: number().
+sinh(_) ->
+    erlang:nif_error(undef).
+
+-spec sqrt(X) -> float() when
+      X :: number().
+sqrt(_) ->
+    erlang:nif_error(undef).
+
+-spec tan(X) -> float() when
+      X :: number().
+tan(_) ->
+    erlang:nif_error(undef).
+
+-spec tanh(X) -> float() when
+      X :: number().
+tanh(_) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 -spec pi() -> float().
 
 pi() -> 3.1415926535897932.
diff --git a/lib/stdlib/src/qlc_pt.erl b/lib/stdlib/src/qlc_pt.erl
index 21504d707b..ad25fd559c 100644
--- a/lib/stdlib/src/qlc_pt.erl
+++ b/lib/stdlib/src/qlc_pt.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2004-2011. All Rights Reserved.
+%% Copyright Ericsson AB 2004-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -2186,7 +2186,7 @@ try_ms(E, P, Fltr, State) ->
             {function,L,foo,0,[{clause,L,[],[],[MS0]}]} = lists:last(X),
             MS = erl_parse:normalise(var2const(MS0)),
             XMS = ets:match_spec_compile(MS),
-            true = is_binary(XMS),
+            true = ets:is_compiled_ms(XMS),
             {ok, MS, MS0} 
         end of
         {'EXIT', _Reason} ->
diff --git a/lib/stdlib/src/re.erl b/lib/stdlib/src/re.erl
index 246d535943..359afc8c14 100644
--- a/lib/stdlib/src/re.erl
+++ b/lib/stdlib/src/re.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2008-2011. All Rights Reserved.
+%% Copyright Ericsson AB 2008-2012. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -30,11 +30,65 @@
                         | {newline, nl_spec()}| bsr_anycrlf
                         | bsr_unicode.
 
-%% Emulator builtins in this module:
-%% re:compile/1
-%% re:compile/2
-%% re:run/2
-%% re:run/3
+%%% BIFs
+
+-export([compile/1, compile/2, run/2, run/3]).
+
+-spec compile(Regexp) -> {ok, MP} | {error, ErrSpec} when
+      Regexp :: iodata(),
+      MP :: mp(),
+      ErrSpec :: {ErrString :: string(), Position :: non_neg_integer()}.
+
+compile(_) ->
+    erlang:nif_error(undef).
+
+-spec compile(Regexp, Options) -> {ok, MP} | {error, ErrSpec} when
+      Regexp :: iodata() | unicode:charlist(),
+      Options :: [Option],
+      Option :: compile_option(),
+      MP :: mp(),
+      ErrSpec :: {ErrString :: string(), Position :: non_neg_integer()}.
+
+compile(_, _) ->
+    erlang:nif_error(undef).
+
+-spec run(Subject, RE) -> {match, Captured} | nomatch when
+      Subject :: iodata() | unicode:charlist(),
+      RE :: mp() | iodata(),
+      Captured :: [CaptureData],
+      CaptureData :: {integer(), integer()}.
+
+run(_, _) ->
+    erlang:nif_error(undef).
+
+-spec run(Subject, RE, Options) -> {match, Captured} |
+                                   match |
+                                   nomatch when
+      Subject :: iodata() | unicode:charlist(),
+      RE :: mp() | iodata() | unicode:charlist(),
+      Options :: [Option],
+      Option :: anchored | global | notbol | noteol | notempty
+              | {offset, non_neg_integer()} |
+                {newline, NLSpec :: nl_spec()} |
+                bsr_anycrlf | bsr_unicode | {capture, ValueSpec} |
+                {capture, ValueSpec, Type} | CompileOpt,
+      Type :: index | list | binary,
+      ValueSpec :: all | all_but_first | first | none | ValueList,
+      ValueList :: [ValueID],
+      ValueID :: integer() | string() | atom(),
+      CompileOpt :: compile_option(),
+      Captured :: [CaptureData] | [[CaptureData]],
+      CaptureData :: {integer(), integer()}
+                   | ListConversionData
+                   | binary(),
+      ListConversionData :: string()
+                          | {error, string(), binary()}
+                          | {incomplete, string(), binary()}.
+
+run(_, _, _) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
 
 -spec split(Subject, RE) -> SplitList when
       Subject :: iodata() | unicode:charlist(),
diff --git a/lib/stdlib/src/string.erl b/lib/stdlib/src/string.erl
index 30eac4f07d..fc029a582f 100644
--- a/lib/stdlib/src/string.erl
+++ b/lib/stdlib/src/string.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1996-2011. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -29,6 +29,30 @@
 
 %%---------------------------------------------------------------------------
 
+%%% BIFs
+
+-export([to_float/1, to_integer/1]).
+
+-spec to_float(String) -> {Float, Rest} | {error, Reason} when
+      String :: string(),
+      Float :: float(),
+      Rest :: string(),
+      Reason :: no_float | not_a_list.
+
+to_float(_) ->
+    erlang:nif_error(undef).
+
+-spec to_integer(String) -> {Int, Rest} | {error, Reason} when
+      String :: string(),
+      Int :: integer(),
+      Rest :: string(),
+      Reason :: no_integer | not_a_list.
+
+to_integer(_) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 %% Robert's bit
 
 %% len(String)
diff --git a/lib/stdlib/src/unicode.erl b/lib/stdlib/src/unicode.erl
index e9b90befe6..8b9412fb1b 100644
--- a/lib/stdlib/src/unicode.erl
+++ b/lib/stdlib/src/unicode.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2008-2011. All Rights Reserved.
+%% Copyright Ericsson AB 2008-2012. All Rights Reserved.
 %% 
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -18,13 +18,6 @@
 %%
 -module(unicode).
 
-%% Implemented in the emulator:
-%% characters_to_binary/2 (will trap to characters_to_binary_int/2
-%%                         if InEncoding is not {latin1 | unicode | utf8})
-%% characters_to_list/2   (will trap to characters_to_list_int/2 if 
-%%                         InEncoding is not {latin1 | unicode | utf8})
-%%
-
 -export([characters_to_list/1, characters_to_list_int/2,
 	 characters_to_binary/1, characters_to_binary_int/2,
 	 characters_to_binary/3,
@@ -52,6 +45,45 @@
 -type latin1_charlist() :: [latin1_char() | latin1_binary()
                             | latin1_charlist()].
 
+%%% BIFs
+%%%
+%%% characters_to_binary/2 (will trap to characters_to_binary_int/2
+%%%                         if InEncoding is not {latin1 | unicode | utf8})
+%%% characters_to_list/2   (will trap to characters_to_list_int/2 if
+%%%                         InEncoding is not {latin1 | unicode | utf8})
+
+-export([bin_is_7bit/1, characters_to_binary/2, characters_to_list/2]).
+
+-spec bin_is_7bit(Binary) -> boolean() when
+      Binary :: binary().
+
+bin_is_7bit(_) ->
+    erlang:nif_error(undef).
+
+-spec characters_to_binary(Data, InEncoding) -> Result when
+      Data :: latin1_chardata() | chardata() | external_chardata(),
+      InEncoding :: encoding(),
+      Result :: binary()
+              | {error, binary(), RestData}
+              | {incomplete, binary(), binary()},
+      RestData :: latin1_chardata() | chardata() | external_chardata().
+
+characters_to_binary(_, _) ->
+    erlang:nif_error(undef).
+
+-spec characters_to_list(Data,  InEncoding) -> Result when
+      Data :: latin1_chardata() | chardata() | external_chardata(),
+      InEncoding :: encoding(),
+      Result :: list()
+              | {error, list(), RestData}
+              | {incomplete, list(), binary()},
+      RestData :: latin1_chardata() | chardata() | external_chardata().
+
+characters_to_list(_, _) ->
+    erlang:nif_error(undef).
+
+%%% End of BIFs
+
 -spec characters_to_list(Data) -> Result when
       Data :: latin1_chardata() | chardata() | external_chardata(),
       Result :: list()