decompress 0.9.1 · OCaml Package

module Heap : sig ... end

module Huffman : sig ... end

val reverse_bits : int -> int

module Lookup : sig ... end

type ('i, 'o, 'crc) t = {

last : bool;
hold : int;
bits : int;
o_off : int;
o_pos : int;
o_len : int;
i_off : int;
i_pos : int;
i_len : int;
write : int;
state : ('i, 'o, 'crc) state;
window : ('o, 'crc) Window.t;
wbits : int;
wi : 'i Buffer.t;
wo : 'o Buffer.t;

}

and ('i, 'o, 'crc) k =
  (Safe.ro, 'i) Safe.t ->
  (Safe.wo, 'o) Safe.t ->
  ('i, 'o, 'crc) t ->
  ('i, 'o, 'crc) res

and ('i, 'o, 'crc) state =

| Last
| Block
| Flat of ('i, 'o, 'crc) k
| Fixed
| Dictionary of ('i, 'o, 'crc) k
| Inffast of Lookup.t * Lookup.t * code
| Inflate of ('i, 'o, 'crc) k
| Switch
| Finish of int
| Exception of error

and ('i, 'o, 'crc) res =

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

and code =

| Length
| ExtLength of int
| Dist of int
| ExtDist of int * int
| Write of int * int

and error = error_rfc1951

val pp_error : Stdlib.Format.formatter -> error_rfc1951 -> unit

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

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

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

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

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

val get_byte : 
  ctor:
    ((([< `Rd | `Wr Rd ] as 'a, 'b) Safe.t ->
       'c ->
       ('b, 'd, 'e) t ->
       ('b, 'd, 'e) res) ->
      ('b, 'd, 'e) state) ->
  (int -> ('a, 'b) Safe.t -> 'c -> ('b, 'd, 'e) t -> ('b, 'd, 'e) res) ->
  ('a, 'b) Safe.t ->
  'c ->
  ('b, 'd, 'e) t ->
  ('b, 'd, 'e) res

val put_byte : 
  ctor:
    (('a ->
       ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t ->
       ('d, 'c, 'e) t ->
       ('d, 'c, 'e) res) ->
      ('d, 'c, 'e) state) ->
  int ->
  ('a -> ('b, 'c) Safe.t -> ('d, 'c, 'e) t -> ('d, 'c, 'e) res) ->
  'a ->
  ('b, 'c) Safe.t ->
  ('d, 'c, 'e) t ->
  ('d, 'c, 'e) res

val fill_byte : 
  ctor:
    (('a ->
       ([< `Rd | `Wr Wr ] as 'b, 'c) Safe.t ->
       ('d, 'c, 'e) t ->
       ('d, 'c, 'e) res) ->
      ('d, 'c, 'e) state) ->
  int ->
  int ->
  ('a -> ('b, 'c) Safe.t -> ('d, 'c, 'e) t -> ('d, 'c, 'e) res) ->
  'a ->
  ('b, 'c) Safe.t ->
  ('d, 'c, 'e) t ->
  ('d, 'c, 'e) res

val peek_bits : 
  ctor:
    ((([< `Rd | `Wr Rd ] as 'a, 'b) Safe.t ->
       'c ->
       ('b, 'd, 'e) t ->
       ('b, 'd, 'e) res) ->
      ('b, 'd, 'e) state) ->
  int ->
  (('a, 'b) Safe.t -> 'c -> ('b, 'd, 'e) t -> ('b, 'd, 'e) res) ->
  ('a, 'b) Safe.t ->
  'c ->
  ('b, 'd, 'e) t ->
  ('b, 'd, 'e) res

val drop_bits : 
  ctor:
    ((([< `Rd | `Wr Rd ] as 'a, 'b) Safe.t ->
       'c ->
       ('b, 'd, 'e) t ->
       ('b, 'd, 'e) res) ->
      ('b, 'd, 'e) state) ->
  int ->
  (('a, 'b) Safe.t -> 'c -> ('b, 'd, 'e) t -> ('b, 'd, 'e) res) ->
  ('a, 'b) Safe.t ->
  'c ->
  ('b, 'd, 'e) t ->
  ('b, 'd, 'e) res

val get_bits : 
  ctor:
    ((([< `Rd | `Wr Rd ] as 'a, 'b) Safe.t ->
       'c ->
       ('b, 'd, 'e) t ->
       ('b, 'd, 'e) res) ->
      ('b, 'd, 'e) state) ->
  int ->
  (int -> ('a, 'b) Safe.t -> 'c -> ('b, 'd, 'e) t -> ('b, 'd, 'e) res) ->
  ('a, 'b) Safe.t ->
  'c ->
  ('b, 'd, 'e) t ->
  ('b, 'd, 'e) res

val get_with_holding : 
  ctor:
    ((([< `Rd | `Wr Rd ] as 'a, 'b) Safe.t ->
       'c ->
       ('b, 'd, 'e) t ->
       ('b, 'd, 'e) res) ->
      ('b, 'd, 'e) state) ->
  (int -> ('a, 'b) Safe.t -> 'c -> ('b, 'd, 'e) t -> ('b, 'd, 'e) res) ->
  ('a, 'b) Safe.t ->
  'c ->
  ('b, 'd, 'e) t ->
  ('b, 'd, 'e) res

val get_int16 : 
  ctor:
    ((([< `Rd | `Wr Rd ] as 'a, 'b) Safe.t ->
       'c ->
       ('b, 'd, 'e) t ->
       ('b, 'd, 'e) res) ->
      ('b, 'd, 'e) state) ->
  (int -> ('a, 'b) Safe.t -> 'c -> ('b, 'd, 'e) t -> ('b, 'd, 'e) res) ->
  ('a, 'b) Safe.t ->
  'c ->
  ('b, 'd, 'e) t ->
  ('b, 'd, 'e) res

module KLast : sig ... end

module KBlock : sig ... end

module KDictionary : sig ... end

module KFlat : sig ... end

module KInflate : sig ... end

module Dictionary : sig ... end

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

val dictionary : 
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'b) Safe.t ->
  ('a, 'b, 'c) t ->
  ('a, 'b, 'c) res

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

val flat : 
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'a) Safe.t ->
  ('a, 'a, 'b) t ->
  ('a, 'a, 'b) res

val inflate : 
  Lookup.t ->
  Lookup.t ->
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'b) Safe.t ->
  ('a, 'b, 'c) t ->
  ('a, 'b, 'c) res

exception End

exception Exn_invalid_distance of int * int

val inffast : 
  ([< `Rd | `Wr Rd ], 'a) Safe.t ->
  ([< `Rd | `Wr Wr ], 'b) Safe.t ->
  ('a, 'b, 'c) t ->
  Lookup.t ->
  Lookup.t ->
  code ->
  ('a, 'b, 'c) res

val block : 
  ([< `Rd | `Wr Rd ], 'a) Safe.t ->
  'b ->
  ('a, 'a, 'c) t ->
  ('a, 'a, 'c) res

val last : 
  ([< `Rd | `Wr Rd ], 'a) Safe.t ->
  'b ->
  ('a, 'c, 'd) t ->
  ('a, 'c, 'd) res

val eval0 : 
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'a) Safe.t ->
  ('a, 'a, 'b) t ->
  ('a, 'a, 'b) res

val eval : 
  'a ->
  'a ->
  ('a, 'a, 'b) t ->
  [> `Await of ('a, 'a, 'b) t
  | `End of ('a, 'a, 'b) t
  | `Error of ('a, 'a, 'b) t * error
  | `Flush of ('a, 'a, 'b) t ]

val default : 
  witness:'a Buffer.t ->
  ?wbits:int ->
  ('a, 'b) Window.t ->
  ('a, 'a, 'b) t

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

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

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

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

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

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

include sig ... end

val to_result : 
  'a ->
  'a ->
  ('a -> int) ->
  ('a -> int -> int) ->
  ('a, 'a, Window.none) t ->
  (('a, 'a, Window.none) t, error) Stdlib.result

val bytes : 
  'a ->
  'a ->
  ('a -> int) ->
  ('a -> int -> int) ->
  ('a, 'a, Window.none) t ->
  (('a, 'a, Window.none) t, error) Stdlib.result

val bigstring : 
  'a ->
  'a ->
  ('a -> int) ->
  ('a -> int -> int) ->
  ('a, 'a, Window.none) t ->
  (('a, 'a, Window.none) t, error) Stdlib.result

package decompress