Merge branch 'maint' into john/erts/merge-zlib-and-vector-q

4 files changed, 406 insertions, 299 deletions

diff --git a/erts/preloaded/ebin/init.beam b/erts/preloaded/ebin/init.beam
index 2acb1f1211..1c8d0e626a 100644
--- a/erts/preloaded/ebin/init.beam
+++ b/erts/preloaded/ebin/init.beam
diff --git a/erts/preloaded/ebin/zlib.beam b/erts/preloaded/ebin/zlib.beam
index a959ebaaf2..267b5cb0a8 100644
--- a/erts/preloaded/ebin/zlib.beam
+++ b/erts/preloaded/ebin/zlib.beam
diff --git a/erts/preloaded/src/init.erl b/erts/preloaded/src/init.erl
index 1ccf8d599f..34a9f6b8b9 100644
--- a/erts/preloaded/src/init.erl
+++ b/erts/preloaded/src/init.erl
@@ -200,6 +200,8 @@ boot(BootArgs) ->
     register(init, self()),
     process_flag(trap_exit, true),
 
+    %% Load the zlib nif
+    zlib:on_load(),
     %% Load the tracer nif
     erl_tracer:on_load(),
 
diff --git a/erts/preloaded/src/zlib.erl b/erts/preloaded/src/zlib.erl
index 8cd3e39fd7..dca5a42779 100644
--- a/erts/preloaded/src/zlib.erl
+++ b/erts/preloaded/src/zlib.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2003-2016. All Rights Reserved.
+%% Copyright Ericsson AB 2003-2017. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -21,19 +21,29 @@
 -module(zlib).
 
 -export([open/0,close/1,deflateInit/1,deflateInit/2,deflateInit/6,
-	 deflateSetDictionary/2,deflateReset/1,deflateParams/3,
-	 deflate/2,deflate/3,deflateEnd/1,
-	 inflateInit/1,inflateInit/2,
-	 inflateSetDictionary/2,inflateGetDictionary/1,
-	 inflateSync/1,inflateReset/1,inflate/2,inflateEnd/1,
-	 inflateChunk/1, inflateChunk/2,
-	 setBufSize/2,getBufSize/1,
-	 crc32/1,crc32/2,crc32/3,adler32/2,adler32/3,getQSize/1,
-	 crc32_combine/4,adler32_combine/4,
-	 compress/1,uncompress/1,zip/1,unzip/1,
-	 gzip/1,gunzip/1]).
-
--export_type([zstream/0, zlevel/0, zwindowbits/0, zmemlevel/0, zstrategy/0]).
+         deflateSetDictionary/2,deflateReset/1,deflateParams/3,
+         deflate/2,deflate/3,deflateEnd/1,
+         inflateInit/1,inflateInit/2,
+         inflateSetDictionary/2,inflateGetDictionary/1, inflateReset/1,
+         inflate/2,inflate/3,inflateEnd/1,
+         inflateChunk/2,inflateChunk/1,
+         safeInflate/2,
+         setBufSize/2,getBufSize/1,
+         crc32/1,crc32/2,crc32/3,adler32/2,adler32/3,
+         crc32_combine/4,adler32_combine/4,
+         compress/1,uncompress/1,zip/1,unzip/1,
+         gzip/1,gunzip/1]).
+
+-export([on_load/0]).
+
+%% These are soft-deprecated until OTP 21.
+% -deprecated([inflateChunk/1, inflateChunk/2,
+%              getBufSize/1, setBufSize/2,
+%              crc32/1,crc32/2,crc32/3,adler32/2,adler32/3,
+%              crc32_combine/4,adler32_combine/4]).
+
+-export_type([zstream/0, zflush/0, zlevel/0, zwindowbits/0, zmemlevel/0,
+              zstrategy/0]).
 
 %% flush argument encoding
 -define(Z_NO_FLUSH,      0).
@@ -56,116 +66,76 @@
 %% deflate compression method
 -define(Z_DEFLATED,  8).
 
--define(Z_NULL, 0).
-
 -define(MAX_WBITS, 15).
 
-%% gzip defs (rfc 1952)
-
--define(ID1, 16#1f).
--define(ID2, 16#8b).
-
--define(FTEXT,     16#01).
--define(FHCRC,     16#02).
--define(FEXTRA,    16#04).
--define(FNAME,     16#08).
--define(FCOMMENT,  16#10).
--define(RESERVED,  16#E0).
-
--define(OS_MDDOS,   0).
--define(OS_AMIGA,   1).
--define(OS_OPENVMS, 2).
--define(OS_UNIX,    3).
--define(OS_VMCMS,   4).
--define(OS_ATARI,   5).
--define(OS_OS2,     6).
--define(OS_MAC,     7).
--define(OS_ZSYS,    8).
--define(OS_CPM,     9).
--define(OS_TOP20,  10).
--define(OS_NTFS,   11).
--define(OS_QDOS,   12).
--define(OS_ACORN,  13).
--define(OS_UNKNOWN,255).
-
--define(DEFLATE_INIT,    1).
--define(DEFLATE_INIT2,   2).
--define(DEFLATE_SETDICT, 3).
--define(DEFLATE_RESET,   4).
--define(DEFLATE_END,     5).
--define(DEFLATE_PARAMS,  6).
--define(DEFLATE,         7).
-
--define(INFLATE_INIT,    8).
--define(INFLATE_INIT2,   9).
--define(INFLATE_SETDICT, 10).
--define(INFLATE_GETDICT, 11).
--define(INFLATE_SYNC,    12).
--define(INFLATE_RESET,   13).
--define(INFLATE_END,     14).
--define(INFLATE,         15).
--define(INFLATE_CHUNK,   26).
-
--define(CRC32_0,         16).
--define(CRC32_1,         17).
--define(CRC32_2,         18).
-
--define(SET_BUFSZ,       19).
--define(GET_BUFSZ,       20).
--define(GET_QSIZE,       21).
-
--define(ADLER32_1,       22).
--define(ADLER32_2,       23).
-
--define(CRC32_COMBINE,   24).
--define(ADLER32_COMBINE, 25).
+%% Chunk sizes are hardcoded on account of them screwing with the
+%% predictability of the system. zlib is incapable of trapping so we need to
+%% ensure that it never operates on any significant amount of data.
+-define(DEFLATE_IN_CHUNKSIZE, 8 bsl 10).
+-define(DEFLATE_OUT_CHUNKSIZE, 8 bsl 10).
+-define(INFLATE_IN_CHUNKSIZE, 8 bsl 10).
+-define(INFLATE_OUT_CHUNKSIZE, 16 bsl 10).
 
 %%------------------------------------------------------------------------
 
-%% Main data types of the file
--type zstream()     :: port().
+%% Public data types.
+-type zstream() :: term().
+-type zflush() :: 'none' | 'sync' | 'full' | 'finish'.
 
-%% Auxiliary data types of the file
--type zlevel()      :: 'none' | 'default' | 'best_compression' | 'best_speed' 
-                     | 0..9.
--type zmethod()     :: 'deflated'.
+-type zlevel() ::
+    'none' | 'default' | 'best_compression' | 'best_speed' | 0..9.
+-type zstrategy() :: 'default' | 'filtered' | 'huffman_only' | 'rle'.
+
+-type zmemlevel() :: 1..9.
 -type zwindowbits() :: -15..-8 | 8..47.
--type zmemlevel()   :: 1..9.
--type zstrategy()   :: 'default' | 'filtered' | 'huffman_only' | 'rle'.
+
+%% Private data types.
+
+-type zmethod()     :: 'deflated'.
+
+-record(zlib_opts, {
+        stream :: zstream(),
+        method :: term(),
+        input_chunk_size :: integer(),
+        output_chunk_size :: integer(),
+        flush :: integer()
+    }).
 
 %%------------------------------------------------------------------------
 
-%% open a z_stream
+on_load() ->
+    case erlang:load_nif(atom_to_list(?MODULE), 0) of
+        ok -> ok
+    end.
+
 -spec open() -> zstream().
 open() ->
-    open_port({spawn, "zlib_drv"}, [binary]).
+    open_nif().
+open_nif() ->
+    erlang:nif_error(undef).
 
-%% close and release z_stream
 -spec close(Z) -> 'ok' when
       Z :: zstream().
 close(Z) ->
-    try
-	true = port_close(Z),
-	receive	      %In case the caller is the owner and traps exits
-	    {'EXIT',Z,_} -> ok
-	after 0 -> ok
-	end
-    catch _:_ -> erlang:error(badarg)
-    end.
+    close_nif(Z).
+close_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec deflateInit(Z) -> 'ok' when
       Z :: zstream().
 deflateInit(Z) ->
-    call(Z, ?DEFLATE_INIT, <<?Z_DEFAULT_COMPRESSION:32>>).
+    deflateInit(Z, default).
 
 -spec deflateInit(Z, Level) -> 'ok' when
       Z :: zstream(),
       Level :: zlevel().
 deflateInit(Z, Level) ->
-    call(Z, ?DEFLATE_INIT, <<(arg_level(Level)):32>>).
+    deflateInit_nif(Z, arg_level(Level)).
+
+deflateInit_nif(_Z, _Level) ->
+    erlang:nif_error(undef).
 
--spec deflateInit(Z, Level, Method,
-		  WindowBits, MemLevel, Strategy) -> 'ok' when
+-spec deflateInit(Z, Level, Method, WindowBits, MemLevel, Strategy) -> 'ok' when
       Z :: zstream(),
       Level :: zlevel(),
       Method :: zmethod(),
@@ -173,31 +143,49 @@ deflateInit(Z, Level) ->
       MemLevel :: zmemlevel(),
       Strategy :: zstrategy().
 deflateInit(Z, Level, Method, WindowBits, MemLevel, Strategy) ->
-    call(Z, ?DEFLATE_INIT2, <<(arg_level(Level)):32, 
-			     (arg_method(Method)):32,
-			     (arg_bitsz(WindowBits)):32, 
-			     (arg_mem(MemLevel)):32,
-			     (arg_strategy(Strategy)):32>>).
+    deflateInit_nif(Z,
+                    arg_level(Level),
+                    arg_method(Method),
+                    arg_bitsz(WindowBits),
+                    arg_mem(MemLevel),
+                    arg_strategy(Strategy)).
+deflateInit_nif(_Z, _Level, _Method, _WindowBits, _MemLevel, _Strategy) ->
+    erlang:nif_error(undef).
 
 -spec deflateSetDictionary(Z, Dictionary) -> Adler32 when
       Z :: zstream(),
       Dictionary :: iodata(),
       Adler32 :: integer().
 deflateSetDictionary(Z, Dictionary) ->
-    call(Z, ?DEFLATE_SETDICT, Dictionary).
+    deflateSetDictionary_nif(Z, Dictionary).
+deflateSetDictionary_nif(_Z, _Dictionary) ->
+    erlang:nif_error(undef).
 
 -spec deflateReset(Z) -> 'ok' when
       Z :: zstream().
 deflateReset(Z) ->
-    call(Z, ?DEFLATE_RESET, []).
+    deflateReset_nif(Z).
+deflateReset_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec deflateParams(Z, Level, Strategy) -> ok when
       Z :: zstream(),
       Level :: zlevel(),
       Strategy :: zstrategy().
-deflateParams(Z, Level, Strategy) ->
-    call(Z, ?DEFLATE_PARAMS, <<(arg_level(Level)):32, 
-			      (arg_strategy(Strategy)):32>>).
+deflateParams(Z, Level0, Strategy0) ->
+    Level = arg_level(Level0),
+    Strategy = arg_strategy(Strategy0),
+    case deflateParams_nif(Z, Level, Strategy) of
+        buf_error ->
+            %% We had data left in the pipe; flush everything and stash it away
+            %% for the next deflate call before trying again.
+            Output = deflate(Z, <<>>, full),
+            save_progress(Z, deflate, Output),
+            deflateParams_nif(Z, Level, Strategy);
+        Any -> Any
+    end.
+deflateParams_nif(_Z, _Level, _Strategy) ->
+    erlang:nif_error(undef).
 
 -spec deflate(Z, Data) -> Compressed when
       Z :: zstream(),
@@ -209,170 +197,234 @@ deflate(Z, Data) ->
 -spec deflate(Z, Data, Flush) -> Compressed when
       Z :: zstream(),
       Data :: iodata(),
-      Flush :: none | sync | full | finish,
+      Flush :: zflush(),
       Compressed :: iolist().
 deflate(Z, Data, Flush) ->
-    try port_command(Z, Data) of
-	true ->
-	    _ = call(Z, ?DEFLATE, <<(arg_flush(Flush)):32>>),
-	    collect(Z)
-    catch 
-	error:_Err ->
-	    flush(Z),
-	    erlang:error(badarg) 
-    end.
+    Progress = restore_progress(Z, deflate),
+    enqueue_input(Z, Data),
+    append_iolist(Progress, dequeue_all_chunks(Z, deflate_opts(Flush))).
+
+deflate_opts(Flush) ->
+    #zlib_opts{
+        method = fun deflate_nif/4,
+        input_chunk_size = ?DEFLATE_IN_CHUNKSIZE,
+        output_chunk_size = ?DEFLATE_OUT_CHUNKSIZE,
+        flush = arg_flush(Flush)
+    }.
+
+deflate_nif(_Z, _InputChSize, _OutputChSize, _Flush) ->
+    erlang:nif_error(undef).
 
 -spec deflateEnd(Z) -> 'ok' when
       Z :: zstream().
 deflateEnd(Z) ->
-    call(Z, ?DEFLATE_END, []).    
+    deflateEnd_nif(Z).
+deflateEnd_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflateInit(Z) -> 'ok' when
       Z :: zstream().
 inflateInit(Z) ->
-    call(Z, ?INFLATE_INIT, []).
+    inflateInit_nif(Z).
+inflateInit_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflateInit(Z, WindowBits) -> 'ok' when
       Z :: zstream(),
       WindowBits :: zwindowbits().
-inflateInit(Z, WindowBits) -> 
-    call(Z, ?INFLATE_INIT2, <<(arg_bitsz(WindowBits)):32>>).
+inflateInit(Z, WindowBits) ->
+    inflateInit_nif(Z, WindowBits).
+inflateInit_nif(_Z, _WindowBits) ->
+    erlang:nif_error(undef).
 
 -spec inflateSetDictionary(Z, Dictionary) -> 'ok' when
       Z :: zstream(),
       Dictionary :: iodata().
-inflateSetDictionary(Z, Dictionary) -> 
-    call(Z, ?INFLATE_SETDICT, Dictionary).
+inflateSetDictionary(Z, Dictionary) ->
+    inflateSetDictionary_nif(Z, Dictionary).
+inflateSetDictionary_nif(_Z, _Dictionary) ->
+    erlang:nif_error(undef).
 
 -spec inflateGetDictionary(Z) -> Dictionary when
       Z :: zstream(),
-      Dictionary :: iolist().
+      Dictionary :: binary().
 inflateGetDictionary(Z) ->
-    _ = call(Z, ?INFLATE_GETDICT, []),
-    collect(Z).
-
--spec inflateSync(zstream()) -> 'ok'.
-inflateSync(Z) -> 
-    call(Z, ?INFLATE_SYNC, []).
+    case inflateGetDictionary_nif(Z) of
+        Dictionary when is_binary(Dictionary) ->
+            Dictionary;
+        not_supported ->
+            erlang:error(enotsup)
+    end.
+inflateGetDictionary_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflateReset(Z) -> 'ok' when
       Z :: zstream().
-inflateReset(Z) -> 
-    call(Z, ?INFLATE_RESET, []).
+inflateReset(Z) ->
+    inflateReset_nif(Z).
+inflateReset_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec inflate(Z, Data) -> Decompressed when
       Z :: zstream(),
       Data :: iodata(),
       Decompressed :: iolist().
 inflate(Z, Data) ->
-    try port_command(Z, Data) of
-	true -> 
-	    _ = call(Z, ?INFLATE, <<?Z_NO_FLUSH:32>>),
-	    collect(Z)
-    catch 
-	error:_Err ->
-	    flush(Z),
-	    erlang:error(badarg) 
+    inflate(Z, Data, []).
+
+-spec inflate(Z, Data, Options) -> Decompressed when
+      Z :: zstream(),
+      Data :: iodata(),
+      Options :: list({exception_on_need_dict, boolean()}),
+      Decompressed :: iolist() |
+                      {need_dictionary,
+                       Adler32 :: integer(),
+                       Output :: iolist()}.
+inflate(Z, Data, Options) ->
+    enqueue_input(Z, Data),
+    Result = dequeue_all_chunks(Z, inflate_opts()),
+    case proplist_get_value(Options, exception_on_need_dict, true) of
+        true -> exception_on_need_dict(Z, Result);
+        false -> Result
     end.
 
+inflate_nif(_Z, _InputChSize, _OutputChSize, _Flush) ->
+    erlang:nif_error(undef).
+
+inflate_opts() ->
+    #zlib_opts{
+        method = fun inflate_nif/4,
+        input_chunk_size = ?INFLATE_IN_CHUNKSIZE,
+        output_chunk_size = ?INFLATE_OUT_CHUNKSIZE,
+        flush = arg_flush(none)
+    }.
+
 -spec inflateChunk(Z, Data) -> Decompressed | {more, Decompressed} when
       Z :: zstream(),
       Data :: iodata(),
       Decompressed :: iolist().
 inflateChunk(Z, Data) ->
-    try port_command(Z, Data) of
-	true ->
-        inflateChunk(Z)
-    catch
-	error:_Err ->
-	    flush(Z),
-	    erlang:error(badarg)
-    end.
+    enqueue_input(Z, Data),
+    inflateChunk(Z).
 
 -spec inflateChunk(Z) -> Decompressed | {more, Decompressed} when
       Z :: zstream(),
       Decompressed :: iolist().
 inflateChunk(Z) ->
-    Status = call(Z, ?INFLATE_CHUNK, []),
-    Data = receive
-	{Z, {data, Bin}} ->
-	    Bin
-    after 0 ->
-	    []
-    end,
-
-    case Status of
-        Good when (Good == ok) orelse (Good == stream_end) ->
-            Data;
-        inflate_has_more ->
-            {more, Data}
-    end.
+    Opts0 = inflate_opts(),
+    Opts = Opts0#zlib_opts { output_chunk_size = getBufSize(Z) },
+
+    Result0 = dequeue_next_chunk(Z, Opts),
+    Result1 = exception_on_need_dict(Z, Result0),
+    yield_inflateChunk(Z, Result1).
+
+yield_inflateChunk(_Z, {continue, Output}) ->
+    {more, lists:flatten(Output)};
+yield_inflateChunk(_Z, {finished, Output}) ->
+    lists:flatten(Output).
+
+exception_on_need_dict(Z, {need_dictionary, Adler, Output}) ->
+    Progress = restore_progress(Z, inflate),
+    save_progress(Z, inflate, append_iolist(Progress, Output)),
+    erlang:error({need_dictionary, Adler});
+exception_on_need_dict(Z, {Mark, Output}) ->
+    Progress = restore_progress(Z, inflate),
+    {Mark, append_iolist(Progress, Output)};
+exception_on_need_dict(Z, Output) when is_list(Output); is_binary(Output) ->
+    Progress = restore_progress(Z, inflate),
+    append_iolist(Progress, Output).
+
+-spec safeInflate(Z, Data) -> Result when
+      Z :: zstream(),
+      Data :: iodata(),
+      Result :: {continue, Output :: iolist()} |
+                {finished, Output :: iolist()} |
+                {need_dictionary,
+                 Adler32 :: integer(),
+                 Output :: iolist()}.
+safeInflate(Z, Data) ->
+    enqueue_input(Z, Data),
+    dequeue_next_chunk(Z, inflate_opts()).
 
 -spec inflateEnd(Z) -> 'ok' when
       Z :: zstream().
 inflateEnd(Z) ->
-    call(Z, ?INFLATE_END, []).
+    inflateEnd_nif(Z).
+inflateEnd_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec setBufSize(Z, Size) -> 'ok' when
       Z :: zstream(),
       Size :: non_neg_integer().
-setBufSize(Z, Size) ->
-    call(Z, ?SET_BUFSZ, <<Size:32>>).
+setBufSize(Z, Size) when is_integer(Size), Size > 16, Size < (1 bsl 24) ->
+    setBufSize_nif(Z, Size);
+setBufSize(_Z, _Size) ->
+    erlang:error(badarg).
+setBufSize_nif(_Z, _Size) ->
+    erlang:nif_error(undef).
 
--spec getBufSize(Z) -> Size when
-      Z :: zstream(),
-      Size :: non_neg_integer().
+-spec getBufSize(Z) -> non_neg_integer() when
+      Z :: zstream().
 getBufSize(Z) ->
-    call(Z, ?GET_BUFSZ, []).
+    getBufSize_nif(Z).
+getBufSize_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec crc32(Z) -> CRC when
       Z :: zstream(),
       CRC :: integer().
 crc32(Z) ->
-    call(Z, ?CRC32_0, []).
+    crc32_nif(Z).
+crc32_nif(_Z) ->
+    erlang:nif_error(undef).
 
 -spec crc32(Z, Data) -> CRC when
       Z :: zstream(),
       Data :: iodata(),
       CRC :: integer().
-crc32(Z, Data) ->
-    call(Z, ?CRC32_1, Data).
+crc32(Z, Data) when is_reference(Z) ->
+    erlang:crc32(Data);
+crc32(_Z, _Data) ->
+    erlang:error(badarg).
 
 -spec crc32(Z, PrevCRC, Data) -> CRC when
       Z :: zstream(),
       PrevCRC :: integer(),
       Data :: iodata(),
       CRC :: integer().
-crc32(Z, CRC, Data) ->
-    call(Z, ?CRC32_2, [<<CRC:32>>, Data]).
+crc32(Z, CRC, Data) when is_reference(Z) ->
+    erlang:crc32(CRC, Data);
+crc32(_Z, _CRC, _Data) ->
+    erlang:error(badarg).
+
+-spec crc32_combine(Z, CRC1, CRC2, Size2) -> CRC when
+      Z :: zstream(),
+      CRC :: integer(),
+      CRC1 :: integer(),
+      CRC2 :: integer(),
+      Size2 :: integer().
+crc32_combine(Z, CRC1, CRC2, Size2) when is_reference(Z) ->
+    erlang:crc32_combine(CRC1, CRC2, Size2);
+crc32_combine(_Z, _CRC1, _CRC2, _Size2) ->
+    erlang:error(badarg).
 
 -spec adler32(Z, Data) -> CheckSum when
       Z :: zstream(),
       Data :: iodata(),
       CheckSum :: integer().
-adler32(Z, Data) ->
-    call(Z, ?ADLER32_1, Data).
+adler32(Z, Data) when is_reference(Z) ->
+    erlang:adler32(Data);
+adler32(_Z, _Data) ->
+    erlang:error(badarg).
 
 -spec adler32(Z, PrevAdler, Data) -> CheckSum when
       Z :: zstream(),
       PrevAdler :: integer(),
       Data :: iodata(),
       CheckSum :: integer().
-adler32(Z, Adler, Data) when is_integer(Adler) ->
-    call(Z, ?ADLER32_2, [<<Adler:32>>, Data]);
-adler32(_Z, _Adler, _Data)  ->
-    erlang:error(badarg).
-
--spec crc32_combine(Z, CRC1, CRC2, Size2) -> CRC when
-      Z :: zstream(),
-      CRC :: integer(),
-      CRC1 :: integer(),
-      CRC2 :: integer(),
-      Size2 :: integer().
-crc32_combine(Z, CRC1, CRC2, Len2) 
-  when is_integer(CRC1), is_integer(CRC2), is_integer(Len2) ->
-    call(Z, ?CRC32_COMBINE, <<CRC1:32, CRC2:32, Len2:32>>);
-crc32_combine(_Z, _CRC1, _CRC2, _Len2) ->
+adler32(Z, Adler, Data) when is_reference(Z) ->
+    erlang:adler32(Adler, Data);
+adler32(_Z, _Adler, _Data) ->
     erlang:error(badarg).
 
 -spec adler32_combine(Z, Adler1, Adler2, Size2) -> Adler when
@@ -381,16 +433,11 @@ crc32_combine(_Z, _CRC1, _CRC2, _Len2) ->
       Adler1 :: integer(),
       Adler2 :: integer(),
       Size2 :: integer().
-adler32_combine(Z, Adler1, Adler2, Len2) 
-  when is_integer(Adler1), is_integer(Adler2), is_integer(Len2) ->
-    call(Z, ?ADLER32_COMBINE, <<Adler1:32, Adler2:32, Len2:32>>);
-adler32_combine(_Z, _Adler1, _Adler2, _Len2) ->
+adler32_combine(Z, Adler1, Adler2, Size2) when is_reference(Z) ->
+    erlang:adler32_combine(Adler1, Adler2, Size2);
+adler32_combine(_Z, _Adler1, _Adler2, _Size2) ->
     erlang:error(badarg).
 
--spec getQSize(zstream()) -> non_neg_integer().
-getQSize(Z) ->
-    call(Z, ?GET_QSIZE, []).
-
 %% compress/uncompress zlib with header
 -spec compress(Data) -> Compressed when
       Data :: iodata(),
@@ -398,13 +445,13 @@ getQSize(Z) ->
 compress(Data) ->
     Z = open(),
     Bs = try
-	     deflateInit(Z, default),
-	     B = deflate(Z, Data, finish),
-	     deflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             deflateInit(Z, default),
+             B = deflate(Z, Data, finish),
+             deflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
 -spec uncompress(Data) -> Decompressed when
@@ -416,14 +463,14 @@ uncompress(Data) ->
             if
                 Size >= 8 ->
                     Z = open(),
-		    Bs = try
-			     inflateInit(Z),
-			     B = inflate(Z, Data),
-			     inflateEnd(Z),
-			     B
-			 after
-			     close(Z)
-			 end,
+                    Bs = try
+                             inflateInit(Z),
+                             B = inflate(Z, Data),
+                             inflateEnd(Z),
+                             B
+                         after
+                             close(Z)
+                         end,
                     iolist_to_binary(Bs);
                 true ->
                     erlang:error(data_error)
@@ -440,13 +487,13 @@ uncompress(Data) ->
 zip(Data) ->
     Z = open(),
     Bs = try
-	     deflateInit(Z, default, deflated, -?MAX_WBITS, 8, default),
-	     B = deflate(Z, Data, finish),
-	     deflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             deflateInit(Z, default, deflated, -?MAX_WBITS, 8, default),
+             B = deflate(Z, Data, finish),
+             deflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
 -spec unzip(Data) -> Decompressed when
@@ -455,28 +502,28 @@ zip(Data) ->
 unzip(Data) ->
     Z = open(),
     Bs = try
-	     inflateInit(Z, -?MAX_WBITS),
-	     B = inflate(Z, Data),
-	     inflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             inflateInit(Z, -?MAX_WBITS),
+             B = inflate(Z, Data),
+             inflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
-    
+
 -spec gzip(Data) -> Compressed when
       Data :: iodata(),
       Compressed :: binary().
 gzip(Data) ->
     Z = open(),
     Bs = try
-	     deflateInit(Z, default, deflated, 16+?MAX_WBITS, 8, default),
-	     B = deflate(Z, Data, finish),
-	     deflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             deflateInit(Z, default, deflated, 16+?MAX_WBITS, 8, default),
+             B = deflate(Z, Data, finish),
+             deflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
 -spec gunzip(Data) -> Decompressed when
@@ -485,92 +532,150 @@ gzip(Data) ->
 gunzip(Data) ->
     Z = open(),
     Bs = try
-	     inflateInit(Z, 16+?MAX_WBITS),
-	     B = inflate(Z, Data),
-	     inflateEnd(Z),
-	     B
-	 after
-	     close(Z)
-	 end,
+             inflateInit(Z, 16+?MAX_WBITS),
+             B = inflate(Z, Data),
+             inflateEnd(Z),
+             B
+         after
+             close(Z)
+         end,
     iolist_to_binary(Bs).
 
--spec collect(zstream()) -> iolist().
-collect(Z) -> 
-    collect(Z, []).
-
--spec collect(zstream(), iolist()) -> iolist().
-collect(Z, Acc) ->
-    receive 
-	{Z, {data, Bin}} ->
-	    collect(Z, [Bin|Acc])
-    after 0 ->
-	    reverse(Acc)
+-spec dequeue_all_chunks(Z, Opts) -> Result when
+    Z :: zstream(),
+    Opts :: #zlib_opts{},
+    Result :: {need_dictionary, integer(), iolist()} |
+              iolist().
+dequeue_all_chunks(Z, Opts) ->
+    dequeue_all_chunks_1(Z, Opts, []).
+dequeue_all_chunks_1(Z, Opts, Output) ->
+    case dequeue_next_chunk(Z, Opts) of
+        {need_dictionary, _, _} = NeedDict ->
+            NeedDict;
+        {continue, Chunk} ->
+            dequeue_all_chunks_1(Z, Opts, append_iolist(Output, Chunk));
+        {finished, Chunk} ->
+            append_iolist(Output, Chunk)
     end.
 
--spec flush(zstream()) -> 'ok'.
-flush(Z) ->
-    receive
-	{Z, {data,_}} ->
-	    flush(Z)
-    after 0 ->
-	    ok
+-spec dequeue_next_chunk(Z, Opts) -> Result when
+    Z :: zstream(),
+    Opts :: #zlib_opts{},
+    Result :: {need_dictionary, integer(), iolist()} |
+              {continue, iolist()} |
+              {finished, iolist()}.
+dequeue_next_chunk(Z, Opts) ->
+    Method = Opts#zlib_opts.method,
+    IChSz = Opts#zlib_opts.input_chunk_size,
+    OChSz = Opts#zlib_opts.output_chunk_size,
+    Flush = Opts#zlib_opts.flush,
+    Method(Z, IChSz, OChSz, Flush).
+
+-spec append_iolist(IO, D) -> iolist() when
+    IO :: iodata(),
+    D :: iodata().
+append_iolist([], D) when is_list(D) -> D;
+append_iolist([], D) -> [D];
+append_iolist(IO, []) -> IO;
+append_iolist(IO, [D]) -> [IO, D];
+append_iolist(IO, D) -> [IO, D].
+
+%% inflate/2 and friends are documented as throwing an error on Z_NEED_DICT
+%% rather than simply returning something to that effect, and deflateParams/3
+%% may flush behind the scenes. This requires us to stow away our current
+%% progress in the handle and resume from that point on our next call.
+%%
+%% Generally speaking this is either a refc binary or nothing at all, so it's
+%% pretty cheap.
+
+-spec save_progress(Z, Kind, Output) -> ok when
+      Z :: zstream(),
+      Kind :: inflate | deflate,
+      Output :: iolist().
+save_progress(Z, Kind, Output) ->
+    ok = setStash_nif(Z, {Kind, Output}).
+
+-spec restore_progress(Z, Kind) -> iolist() when
+    Z :: zstream(),
+    Kind :: inflate | deflate.
+restore_progress(Z, Kind) ->
+    case getStash_nif(Z) of
+        {ok, {Kind, Output}} ->
+            ok = clearStash_nif(Z),
+            Output;
+        empty ->
+            []
     end.
-    
-arg_flush(none)    -> ?Z_NO_FLUSH;
+
+-spec clearStash_nif(Z) -> ok when
+      Z :: zstream().
+clearStash_nif(_Z) ->
+    erlang:nif_error(undef).
+
+-spec setStash_nif(Z, Term) -> ok when
+      Z :: zstream(),
+      Term :: term().
+setStash_nif(_Z, _Term) ->
+    erlang:nif_error(undef).
+
+-spec getStash_nif(Z) -> {ok, term()} | empty when
+      Z :: zstream().
+getStash_nif(_Z) ->
+    erlang:nif_error(undef).
+
+%% The 'proplists' module isn't preloaded so we can't rely on its existence.
+proplist_get_value([], _Name, DefVal) -> DefVal;
+proplist_get_value([{Name, Value} | _Opts], Name, _DefVal) -> Value;
+proplist_get_value([_Head | Opts], Name, DefVal) ->
+    proplist_get_value(Opts, Name, DefVal).
+
+arg_flush(none)   -> ?Z_NO_FLUSH;
 %% ?Z_PARTIAL_FLUSH is deprecated in zlib -- deliberately not included.
-arg_flush(sync)    -> ?Z_SYNC_FLUSH;
-arg_flush(full)    -> ?Z_FULL_FLUSH;
-arg_flush(finish)  -> ?Z_FINISH;
-arg_flush(_) -> erlang:error(badarg).
+arg_flush(sync)   -> ?Z_SYNC_FLUSH;
+arg_flush(full)   -> ?Z_FULL_FLUSH;
+arg_flush(finish) -> ?Z_FINISH;
+arg_flush(_) -> erlang:error(bad_flush_mode).
 
 arg_level(none)             -> ?Z_NO_COMPRESSION;
 arg_level(best_speed)       -> ?Z_BEST_SPEED;
 arg_level(best_compression) -> ?Z_BEST_COMPRESSION;
 arg_level(default)          -> ?Z_DEFAULT_COMPRESSION;
 arg_level(Level) when is_integer(Level), Level >= 0, Level =< 9 -> Level;
-arg_level(_) -> erlang:error(badarg).
-     
+arg_level(_) -> erlang:error(bad_compression_level).
+
 arg_strategy(filtered) ->     ?Z_FILTERED;
 arg_strategy(huffman_only) -> ?Z_HUFFMAN_ONLY;
 arg_strategy(rle) -> ?Z_RLE;
 arg_strategy(default) ->      ?Z_DEFAULT_STRATEGY;
-arg_strategy(_) -> erlang:error(badarg).
+arg_strategy(_) -> erlang:error(bad_compression_strategy).
 
 arg_method(deflated) -> ?Z_DEFLATED;
-arg_method(_) -> erlang:error(badarg).
+arg_method(_) -> erlang:error(bad_compression_method).
 
 -spec arg_bitsz(zwindowbits()) -> zwindowbits().
 arg_bitsz(Bits) when is_integer(Bits) andalso
-		     ((8 =< Bits andalso Bits < 48) orelse
-		      (-15 =< Bits andalso Bits =< -8)) ->
+                     ((8 =< Bits andalso Bits < 48) orelse
+                      (-15 =< Bits andalso Bits =< -8)) ->
     Bits;
-arg_bitsz(_) -> erlang:error(badarg).
+arg_bitsz(_) -> erlang:error(bad_windowbits).
 
 -spec arg_mem(zmemlevel()) -> zmemlevel().
 arg_mem(Level) when is_integer(Level), 1 =< Level, Level =< 9 -> Level;
-arg_mem(_) -> erlang:error(badarg).
-
-call(Z, Cmd, Arg) ->
-    try port_control(Z, Cmd, Arg) of
-	[0|Res] -> list_to_atom(Res);
-	[1|Res] ->
-	    flush(Z),
-	    erlang:error(list_to_atom(Res));
-	[2,A,B,C,D] ->
-	    (A bsl 24)+(B bsl 16)+(C bsl 8)+D;
-	[3,A,B,C,D] ->
-	    erlang:error({need_dictionary,(A bsl 24)+(B bsl 16)+(C bsl 8)+D});
-	[4, _, _, _, _] ->
-	    inflate_has_more
-    catch 
-	error:badarg -> %% Rethrow loses port_control from stacktrace.
-	    erlang:error(badarg)
-    end.
+arg_mem(_) -> erlang:error(bad_memlevel).
 
-reverse(X) ->
-    reverse(X, []).
+-spec enqueue_input(Z, IOData) -> ok when
+      Z :: zstream(),
+      IOData :: iodata().
+enqueue_input(Z, IOData) ->
+    enqueue_input_1(Z, erlang:iolist_to_iovec(IOData)).
+
+enqueue_input_1(_Z, []) ->
+    ok;
+enqueue_input_1(Z, IOVec) ->
+    case enqueue_nif(Z, IOVec) of
+        {continue, Remainder} -> enqueue_input_1(Z, Remainder);
+        ok -> ok
+    end.
 
-reverse([H|T], Y) ->
-    reverse(T, [H|Y]);
-reverse([], X) -> 
-    X.
+enqueue_nif(_Z, _IOVec) ->
+    erlang:nif_error(undef).
\ No newline at end of file