Merge branch 'dev' of super:otp into dev

* 'dev' of super:otp: (166 commits)
  Corrected documentation error and added examples to Users Guide
  In TLS 1.1, failure to properly close a connection no longer requires that a session not be resumed.  This is a change from TLS 1.0 to conform with widespread implementation practice.  Erlang ssl will now in TLS 1.0 conform to the widespread implementation practice instead of the specification to avoid performance issues.
  Add escript to bootstrap/bin
  Remove unused variable warning in inet_res
  Remove unused variable in epmd_port
  Remove compiler warnings in inet_drv
  Add SASL test suite
  Allow same module name in multiple applications if explicitely excluded
  Fix bugs concerning the option report_missing_types
  Fix default encoding in SAX parser.
  re: remove gratuitous "it " in manpage
  Spelling in (backward *compatibility*) comment.
  Improve erl_docgen's support for Dialyzer specs and types
  dialyzer warning on mnesia_tm
  Add documentation text about majority checking
  add mnesia_majority_test suite
  where_to_wlock optimization + change_table_majority/2
  bug in mnesia_tm:needs_majority/2
  optimize sticky_lock maj. check
  check majority for sticky locks
  ...

1 files changed, 143 insertions, 52 deletions

diff --git a/lib/stdlib/src/io.erl b/lib/stdlib/src/io.erl
index 6aeb076a0b..9f65bbfa3a 100644
--- a/lib/stdlib/src/io.erl
+++ b/lib/stdlib/src/io.erl
@@ -41,6 +41,7 @@
 
 -type error_description() :: term(). % Whatever the io-server sends.
 -type request_error() :: {'error',error_description()}.
+
 %% XXX: Some uses of line() in this file may need to read erl_scan:location()
 -type line()   :: pos_integer().
 
@@ -66,12 +67,15 @@ o_request(Io, Request, Func) ->
     end.
 
 %% Put chars takes mixed *unicode* list from R13 onwards.
--spec put_chars(iodata()) -> 'ok'.
+-spec put_chars(CharData) -> 'ok' when
+      CharData :: unicode:chardata().
 
 put_chars(Chars) ->
     put_chars(default_output(), Chars).
 
--spec put_chars(device(), iodata()) -> 'ok'.
+-spec put_chars(IoDevice, IoData) -> 'ok' when
+      IoDevice :: device(),
+      IoData :: unicode:chardata().
 
 put_chars(Io, Chars) ->
     o_request(Io, {put_chars,unicode,Chars}, put_chars).
@@ -81,7 +85,8 @@ put_chars(Io, Chars) ->
 nl() ->
     nl(default_output()).
 
--spec nl(device()) -> 'ok'.
+-spec nl(IoDevice) -> 'ok' when
+      IoDevice :: device().
 
 nl(Io) ->
 %    o_request(Io, {put_chars,io_lib:nl()}).
@@ -92,7 +97,8 @@ nl(Io) ->
 columns() ->
     columns(default_output()).
 
--spec columns(device()) -> {'ok', pos_integer()} | {'error', 'enotsup'}.
+-spec columns(IoDevice) -> {'ok', pos_integer()} | {'error', 'enotsup'} when
+      IoDevice :: device().
 
 columns(Io) ->
     case request(Io, {get_geometry,columns}) of
@@ -107,7 +113,8 @@ columns(Io) ->
 rows() ->
     rows(default_output()).
 
--spec rows(device()) -> {'ok', pos_integer()} | {'error', 'enotsup'}.
+-spec rows(IoDevice) -> {'ok', pos_integer()} | {'error', 'enotsup'} when
+      IoDevice :: device().
 
 rows(Io) ->
     case request(Io,{get_geometry,rows}) of
@@ -117,22 +124,36 @@ rows(Io) ->
 	    {error,enotsup}
     end.    
 
--spec get_chars(prompt(), non_neg_integer()) -> iodata() | 'eof'.
+-spec get_chars(Prompt, Count) -> Data | 'eof' when
+      Prompt :: prompt(),
+      Count :: non_neg_integer(),
+      Data :: [unicode:unicode_char()] | unicode:unicode_binary().
 
 get_chars(Prompt, N) ->
     get_chars(default_input(), Prompt, N).
 
--spec get_chars(device(), prompt(), non_neg_integer()) -> iodata() | 'eof'.
+-spec get_chars(IoDevice, Prompt, Count) -> Data | 'eof' | {error, Reason} when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Count :: non_neg_integer(),
+      Reason :: term(),
+      Data :: [unicode:unicode_char()] | unicode:unicode_binary().
 
 get_chars(Io, Prompt, N) when is_integer(N), N >= 0 ->
     request(Io, {get_chars,unicode,Prompt,N}).
 
--spec get_line(prompt()) -> iodata() | 'eof' | {'error', term()}.
+-spec get_line(Prompt) -> Data | 'eof' | {'error', Reason} when
+      Prompt :: prompt(),
+      Reason :: term(),
+      Data :: [unicode:unicode_char()] | unicode:unicode_binary().
 
 get_line(Prompt) ->
     get_line(default_input(), Prompt).
 
--spec get_line(device(), prompt()) -> iodata() | 'eof' | {'error', term()}.
+-spec get_line(IoDevice, Prompt) -> Data | 'eof' | {'error', term()} when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Data :: [unicode:unicode_char()] | unicode:unicode_binary().
 
 get_line(Io, Prompt) ->
     request(Io, {get_line,unicode,Prompt}).
@@ -156,46 +177,62 @@ get_password(Io) ->
 getopts() ->
     getopts(default_input()).
 
--spec getopts(device()) -> [opt_pair()].
+-spec getopts(IoDevice) -> [opt_pair()] when
+      IoDevice :: device().
 
 getopts(Io) ->
     request(Io, getopts).
 
 -type setopt() :: 'binary' | 'list' | opt_pair().
 
--spec setopts([setopt()]) -> 'ok' | {'error', term()}.
+-spec setopts(Opts) -> 'ok' | {'error', Reason} when
+      Opts :: [setopt()],
+      Reason :: term().
 
 setopts(Opts) ->
     setopts(default_input(), Opts).
 
--spec setopts(device(), [setopt()]) -> 'ok' | {'error', term()}.
+-spec setopts(IoDevice, Opts) -> 'ok' | {'error', Reason} when
+      IoDevice :: device(),
+      Opts :: [setopt()],
+      Reason :: term().
 
 setopts(Io, Opts) ->
     request(Io, {setopts, Opts}).
 
 %% Writing and reading Erlang terms.
 
--spec write(term()) -> 'ok'.
+-spec write(Term) -> 'ok' when
+      Term :: term().
 
 write(Term) ->
     write(default_output(), Term).
 
--spec write(device(), term()) -> 'ok'.
+-spec write(IoDevice, Term) -> 'ok' when
+      IoDevice :: device(),
+      Term :: term().
 
 write(Io, Term) ->
     o_request(Io, {write,Term}, write).
 
 
--spec read(prompt()) -> 
-    {'ok', term()} | 'eof' | {'error', erl_scan:error_info()}.
+-spec read(Prompt) -> Result when
+      Prompt :: prompt(),
+      Result :: {'ok', Term :: term()}
+              | 'eof'
+              | {'error', ErrorInfo :: erl_scan:error_info()}.
 
 % Read does not use get_until as erl_scan does not work with unicode
 % XXX:PaN fixme?
 read(Prompt) ->
     read(default_input(), Prompt).
 
--spec read(device(), prompt()) ->
-    {'ok', term()} | 'eof' | {'error', erl_scan:error_info()}.
+-spec read(IoDevice, Prompt) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Result :: {'ok', Term :: term()}
+              | 'eof'
+              | {'error', ErrorInfo :: erl_scan:error_info()}.
 
 read(Io, Prompt) ->
     case request(Io, {get_until,unicode,Prompt,erl_scan,tokens,[1]}) of
@@ -211,9 +248,13 @@ read(Io, Prompt) ->
 	    Other
     end.
 
--spec read(device(), prompt(), line()) ->
-    {'ok', term(), line()} | {'eof', line()} |
-    {'error', erl_scan:error_info(), line()}.
+-spec read(IoDevice, Prompt, StartLine) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      StartLine :: line(),
+      Result :: {'ok', Term :: term(), EndLine :: line()}
+              | {'eof', EndLine :: line()}
+              | {'error', ErrorInfo :: erl_scan:error_info(), ErrorLine :: line()}.
 
 read(Io, Prompt, StartLine) when is_integer(StartLine) ->
     case request(Io, {get_until,unicode,Prompt,erl_scan,tokens,[StartLine]}) of
@@ -239,28 +280,40 @@ conv_reason(_, _Reason) -> badarg.
 
 -type format() :: atom() | string() | binary().
 
--spec fwrite(format()) -> 'ok'.
+-spec fwrite(Format) -> 'ok' when
+      Format :: format().
 
 fwrite(Format) ->
     format(Format).
 
--spec fwrite(format(), [term()]) -> 'ok'.
+-spec fwrite(Format, Data) -> 'ok' when
+      Format :: format(),
+      Data :: [term()].
 
 fwrite(Format, Args) ->
     format(Format, Args).
 
--spec fwrite(device(), format(), [term()]) -> 'ok'.
+-spec fwrite(IoDevice, Format, Data) -> 'ok' when
+      IoDevice :: device(),
+      Format :: format(),
+      Data :: [term()].
 
 fwrite(Io, Format, Args) ->
     format(Io, Format, Args).
 
--spec fread(prompt(), format()) -> {'ok', [term()]} | 'eof' | {'error',term()}.
+-spec fread(Prompt, Format) -> Result when
+      Prompt :: prompt(),
+      Format :: format(),
+      Result :: {'ok', Terms :: [term()]} | 'eof' | {'error', What :: term()}.
 
 fread(Prompt, Format) ->
     fread(default_input(), Prompt, Format).
 
--spec fread(device(), prompt(), format()) -> 
-    {'ok', [term()]} | 'eof' | {'error',term()}.
+-spec fread(IoDevice, Prompt, Format) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Format :: format(),
+      Result :: {'ok', Terms :: [term()]} | 'eof' | {'error', What :: term()}.
 
 fread(Io, Prompt, Format) ->
     case request(Io, {fread,Prompt,Format}) of
@@ -270,73 +323,104 @@ fread(Io, Prompt, Format) ->
 	    Other
     end.
 
--spec format(format()) -> 'ok'.
+-spec format(Format) -> 'ok' when
+      Format :: format().
 
 format(Format) ->
     format(Format, []).
 
--spec format(format(), [term()]) -> 'ok'.
+-spec format(Format, Data) -> 'ok' when
+      Format :: format(),
+      Data :: [term()].
 
 format(Format, Args) ->
     format(default_output(), Format, Args).
 
--spec format(device(), format(), [term()]) -> 'ok'.
+-spec format(IoDevice, Format, Data) -> 'ok' when
+      IoDevice :: device(),
+      Format :: format(),
+      Data :: [term()].
 
 format(Io, Format, Args) ->
     o_request(Io, {format,Format,Args}, format).
 
 %% Scanning Erlang code.
 
--spec scan_erl_exprs(prompt()) -> erl_scan:tokens_result() | request_error().
+-spec scan_erl_exprs(Prompt) -> Result when
+      Prompt :: prompt(),
+      Result :: erl_scan:tokens_result() | request_error().
  
 scan_erl_exprs(Prompt) ->
     scan_erl_exprs(default_input(), Prompt, 1).
 
--spec scan_erl_exprs(device(), prompt()) -> erl_scan:tokens_result() | request_error().
+-spec scan_erl_exprs(Device, Prompt) -> Result when
+      Device :: device(),
+      Prompt :: prompt(),
+      Result :: erl_scan:tokens_result() | request_error().
 
 scan_erl_exprs(Io, Prompt) ->
     scan_erl_exprs(Io, Prompt, 1).
 
--spec scan_erl_exprs(device(), prompt(), line()) -> erl_scan:tokens_result() | request_error().
+-spec scan_erl_exprs(Device, Prompt, StartLine) -> Result when
+      Device :: device(),
+      Prompt :: prompt(),
+      StartLine :: line(),
+      Result :: erl_scan:tokens_result() | request_error().
 
 scan_erl_exprs(Io, Prompt, Pos0) ->
     request(Io, {get_until,unicode,Prompt,erl_scan,tokens,[Pos0]}).
 
--spec scan_erl_form(prompt()) -> erl_scan:tokens_result() | request_error().
+-spec scan_erl_form(Prompt) -> Result when
+      Prompt :: prompt(),
+      Result :: erl_scan:tokens_result() | request_error().
 
 scan_erl_form(Prompt) ->
     scan_erl_form(default_input(), Prompt, 1).
 
--spec scan_erl_form(device(), prompt()) -> erl_scan:tokens_result() | request_error().
+-spec scan_erl_form(IoDevice, Prompt) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Result :: erl_scan:tokens_result() | request_error().
 
 scan_erl_form(Io, Prompt) ->
     scan_erl_form(Io, Prompt, 1).
 
--spec scan_erl_form(device(), prompt(), line()) -> erl_scan:tokens_result() | request_error().
+-spec scan_erl_form(IoDevice, Prompt, StartLine) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      StartLine :: line(),
+      Result :: erl_scan:tokens_result() | request_error().
 
 scan_erl_form(Io, Prompt, Pos0) ->
     request(Io, {get_until,unicode,Prompt,erl_scan,tokens,[Pos0]}).
 
 %% Parsing Erlang code.
 
--type erl_parse_expr_list() :: [_]. %% XXX: should be imported from erl_parse
-
--type parse_ret() :: {'ok', erl_parse_expr_list(), line()}
-                   | {'eof', line()}
-                   | {'error', erl_scan:error_info(), line()}
+-type parse_ret() :: {'ok', ExprList :: erl_parse:abstract_expr(), EndLine :: line()}
+                   | {'eof', EndLine :: line()}
+                   | {'error', ErrorInfo :: erl_scan:error_info(), ErrorLine :: line()}
                    | request_error().
 
--spec parse_erl_exprs(prompt()) -> parse_ret().
+-spec parse_erl_exprs(Prompt) -> Result when
+      Prompt :: prompt(),
+      Result :: parse_ret().
 
 parse_erl_exprs(Prompt) ->
     parse_erl_exprs(default_input(), Prompt, 1).
 
--spec parse_erl_exprs(device(), prompt()) -> parse_ret().
+-spec parse_erl_exprs(IoDevice, Prompt) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Result :: parse_ret().
 
 parse_erl_exprs(Io, Prompt) ->
     parse_erl_exprs(Io, Prompt, 1).
 
--spec parse_erl_exprs(device(), prompt(), line()) -> parse_ret().
+-spec parse_erl_exprs(IoDevice, Prompt, StartLine) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      StartLine :: line(),
+      Result :: parse_ret().
 
 parse_erl_exprs(Io, Prompt, Pos0) ->
     case request(Io, {get_until,unicode,Prompt,erl_scan,tokens,[Pos0]}) of
@@ -349,24 +433,31 @@ parse_erl_exprs(Io, Prompt, Pos0) ->
 	    Other
     end.
 
--type erl_parse_absform() :: _. %% XXX: should be imported from erl_parse
-
--type parse_form_ret() :: {'ok', erl_parse_absform(), line()}
-                        | {'eof', line()}
-                        | {'error', erl_scan:error_info(), line()}
+-type parse_form_ret() :: {'ok', AbsForm :: erl_parse:abstract_form(), EndLine :: line()}
+                        | {'eof', EndLine :: line()}
+                        | {'error', ErrorInfo :: erl_scan:error_info(), ErrorLine :: line()}
                         | request_error().
 
--spec parse_erl_form(prompt()) -> parse_form_ret().
+-spec parse_erl_form(Prompt) -> Result when
+      Prompt :: prompt(),
+      Result :: parse_form_ret().
 
 parse_erl_form(Prompt) ->
     parse_erl_form(default_input(), Prompt, 1).
 
--spec parse_erl_form(device(), prompt()) -> parse_form_ret().
+-spec parse_erl_form(IoDevice, Prompt) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      Result :: parse_form_ret().
 
 parse_erl_form(Io, Prompt) ->
     parse_erl_form(Io, Prompt, 1).
 
--spec parse_erl_form(device(), prompt(), line()) -> parse_form_ret().
+-spec parse_erl_form(IoDevice, Prompt, StartLine) -> Result when
+      IoDevice :: device(),
+      Prompt :: prompt(),
+      StartLine :: line(),
+      Result :: parse_form_ret().
 
 parse_erl_form(Io, Prompt, Pos0) ->
     case request(Io, {get_until,unicode,Prompt,erl_scan,tokens,[Pos0]}) of