decompress 0.8 · OCaml Package

module F : sig ... end

type error = error_rfc1951_deflate

type ('i, 'o) t = {

hold : int;
bits : int;
temp : ([ Safe.read | Safe.write ], 'o) Safe.t;
o_off : int;
o_pos : int;
o_len : int;
i_off : int;
i_pos : int;
i_len : int;
level : int;
wbits : int;
write : int;
adler : Checkseum.Adler32.t;
state : ('i, 'o) state;

}

and ('i, 'o) k =
  (Safe.read, 'i) Safe.t ->
  (Safe.write, 'o) Safe.t ->
  ('i, 'o) t ->
  ('i, 'o) res

and ('i, 'o) state =

| MakeBlock of ('i, 'o) block
| WriteBlock of ('i, 'o) k
| FastBlock of (int * int) array * (int * int) array * Hunk.t Q.t * code * flush
| AlignBlock of F.t option * bool
| FixedBlock of F.t
| DynamicHeader of ('i, 'o) k
| StaticHeader of ('i, 'o) k
| AlignF of ('i, 'o) k
| Finish of int
| Exception of error

and ('i, 'o) res =

| Cont of ('i, 'o) t
| Wait of ('i, 'o) t
| Flush of ('i, 'o) t
| Ok of ('i, 'o) t
| Error of ('i, 'o) t * error

and ('i, 'o) block =

| Static of {
1. lz : 'i L.t;
2. frequencies : F.t;
3. deflate : Hunk.t Seq.t;
}
| Dynamic of {
1. lz : 'i L.t;
2. frequencies : F.t;
3. deflate : Hunk.t Seq.t;
}
| Flat of int

and flush =

| Sync of F.t
| Partial of F.t
| Full
| Final

and code =

| Length
| ExtLength
| Dist
| ExtDist

and meth =

| PARTIAL
| SYNC
| FULL

val pp_error : Format.formatter -> error_rfc1951_deflate -> unit

val pp_code : Format.formatter -> code -> unit

val pp_flush : Format.formatter -> flush -> unit

val pp_block : Format.formatter -> ('a, 'b) block -> unit

val pp_state : Format.formatter -> ('a, 'b) state -> unit

val pp : Format.formatter -> ('a, 'b) t -> unit

val await : ('a, 'b) t -> ('a, 'b) res

val error : ('a, 'b) t -> error -> ('c, 'd) res

val ok : ('a, 'b) t -> int -> ('c, 'd) res

val block_of_flush : flush -> ('a, 'b) state

val put_byte : 
  ctor:
    (('a ->
       ([< `Read | `Write Write ] as 'b, 'c) Safe.t ->
       ('d, 'e) t ->
       ('f, 'g) res) ->
      ('h, 'i) state) ->
  int ->
  ('j -> ('b, 'c) Safe.t -> ('k, 'l) t -> ('f, 'g) res) ->
  'm ->
  ('b, 'c) Safe.t ->
  ('d, 'e) t ->
  ('f, 'g) res

val put_short_lsb : 
  ctor:
    (('a ->
       ([< `Read | `Write Write ] as 'b, 'c) Safe.t ->
       ('d, 'e) t ->
       ('f, 'e) res) ->
      ('f, 'e) state) ->
  int ->
  ('a -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('f, 'e) res) ->
  'g ->
  ('b, 'c) Safe.t ->
  ('d, 'e) t ->
  ('f, 'e) res

val align : 
  ctor:
    (('a ->
       ([< `Read | `Write Write ] as 'b, 'c) Safe.t ->
       ('d, 'e) t ->
       ('f, 'g) res) ->
      ('f, 'g) state) ->
  ('h -> ('i, 'j) Safe.t -> ('k, 'l) t -> ('f, 'g) res) ->
  'm ->
  ('i, 'j) Safe.t ->
  ('d, 'e) t ->
  ('f, 'g) res

val put_bits : 
  ctor:
    (('a ->
       ([< `Read | `Write Write ] as 'b, 'c) Safe.t ->
       ('d, 'e) t ->
       ('f, 'g) res) ->
      ('f, 'g) state) ->
  (int * int) ->
  ('h -> ('b, 'c) Safe.t -> ('i, 'j) t -> ('f, 'g) res) ->
  'k ->
  ('b, 'c) Safe.t ->
  ('d, 'e) t ->
  ('f, 'g) res

val put_bit : 
  ctor:
    (('a ->
       ([< `Read | `Write Write ] as 'b, 'c) Safe.t ->
       ('d, 'e) t ->
       ('f, 'e) res) ->
      ('f, 'e) state) ->
  bool ->
  ('a -> ('b, 'c) Safe.t -> ('d, 'e) t -> ('f, 'e) res) ->
  'g ->
  ('h, 'i) Safe.t ->
  ('d, 'e) t ->
  ('f, 'e) res

module KWriteBlock : sig ... end

module KDynamicHeader : sig ... end

val get_tree_symbols : 
  int ->
  int array ->
  int ->
  int array ->
  int array * int array

val block_of_level : wbits:int -> ?frequencies:F.t -> int -> ('a, 'b) block

val zip : 'a array -> 'b array -> ('c * 'd) array

val write_block : 
  (int * int) array ->
  (int * int) array ->
  Hunk.t Q.t ->
  flush ->
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('c, 'd) t ->
  ('a, 'b) res

val static : 
  'a ->
  Hunk.t Q.t ->
  ('b -> flush) ->
  (Safe.read, 'c) Safe.t ->
  (Safe.write, 'd) Safe.t ->
  ('c, 'd) t ->
  ('c, 'd) res

val dynamic : 
  (int array * int array) ->
  Hunk.t Q.t ->
  ((int array * int array) -> flush) ->
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val align_bytes : 
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val write_flat : 
  int ->
  int ->
  int ->
  bool ->
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('c, 'd) t ->
  ('e, 'f) res

val flat : 
  int ->
  int ->
  int ->
  bool ->
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val make_block : 
  (L.Safe.read, 'a) L.Safe.t ->
  'b ->
  ('c, 'd) t ->
  ('e, 'f) block ->
  ('g, 'h) res

val fixed_block : 
  F.t ->
  bool ->
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val align_block : 
  F.t option ->
  bool ->
  (Safe.read, 'a) Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

val write_fast_block : 
  'a ->
  ([< `Read | `Write Write ], 'b) Safe.t ->
  ('c, 'd) t ->
  (int * int) array ->
  (int * int) array ->
  Hunk.t Q.t ->
  code ->
  flush ->
  ('e, 'f) res

val flush : int -> int -> ('a, 'b) t -> ('c, 'd) t

val get_frequencies : ('a, 'b) t -> F.t

val set_frequencies : 
  ?paranoid:bool ->
  (int array * int array) ->
  ('a, 'b) t ->
  ('c, 'd) t

val to_final : 'a -> flush

val to_partial : F.t -> flush

val to_sync : F.t -> flush

val to_full : 'a -> flush

val finish : ('a, 'b) t -> ('c, 'd) t

val no_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t

val partial_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t

val sync_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t

val full_flush : int -> int -> ('a, 'b) t -> ('c, 'd) t

val flush_of_meth : meth -> int -> int -> ('a, 'b) t -> ('b, 'b) t

val eval0 : 
  (L.Safe.read, 'a) L.Safe.t ->
  (Safe.write, 'b) Safe.t ->
  ('c, 'd) t ->
  ('a, 'a) res

val eval : 
  'a Decompress_impl__.Decompress_b.t ->
  'b Decompress_impl__.Decompress_b.t ->
  ('c, 'c) t ->
  [> `Await of ('d, 'e) t
  | `End of ('f, 'g) t
  | `Error of ('h, 'i) t * error
  | `Flush of ('j, 'k) t ]

val used_in : ('a, 'b) t -> int

val used_out : ('a, 'b) t -> int

val bits_remaining : ('a, 'b) t -> int

val default : proof:'a B.t -> ?wbits:int -> int -> ('b, 'c) t

include sig ... end

val to_result : 
  'a B.t ->
  'a B.t ->
  ?meth:(meth * int) ->
  ('a B.t -> int option -> int) ->
  ('a B.t -> int -> int) ->
  ('b, 'c) t ->
  (('d, 'e) t, error) result

val bytes : 
  B.Bytes.t ->
  B.Bytes.t ->
  ?meth:(meth * int) ->
  (B.Bytes.t -> int option -> int) ->
  (B.Bytes.t -> int -> int) ->
  (B.st, B.st) t ->
  ((B.st, B.st) t, error) result

val bigstring : 
  B.Bigstring.t ->
  B.Bigstring.t ->
  ?meth:(meth * int) ->
  (B.Bigstring.t -> int option -> int) ->
  (B.Bigstring.t -> int -> int) ->
  (B.bs, B.bs) t ->
  ((B.bs, B.bs) t, error) result

package decompress