RFC1951_inflate (p.decompress.0.8.doc.decompress.impl.Decompress_impl.RFC1951

Sourcemodule Heap : sig ... end

Sourcemodule Huffman : sig ... end

Sourceval reverse_bits : int -> int

Sourcemodule Lookup : sig ... end

Sourcetype ('i, 'o) 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) state;
window : 'o Window.t;

}

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

Sourceand ('i, 'o) state =

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

Sourceand ('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

Sourceand code =

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

Sourceand error = error_rfc1951_inflate

Sourceval pp_error : Format.formatter -> error_rfc1951_inflate -> unit

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

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

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

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

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

Source

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

Source

val put_byte : 
  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) ->
  'a ->
  ('b, 'c) Safe.t ->
  ('d, 'e) t ->
  ('f, 'e) res

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Sourcemodule KLast : sig ... end

Sourcemodule KBlock : sig ... end

Sourcemodule KDictionary : sig ... end

Sourcemodule KFlat : sig ... end

Sourcemodule KInflate : sig ... end

Sourcemodule Dictionary : sig ... end

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

Source

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

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

Source

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

Source

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

Sourceexception End

Source

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

Source

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

Source

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

Source

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

Source

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

Sourceval default : 'a Window.t -> ('b, 'a) t

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

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

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

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

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

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

include sig ... end

Source

val to_result : 
  'a B.t ->
  'a B.t ->
  ('a B.t -> int) ->
  ('a B.t -> int -> int) ->
  ('a, 'a) t ->
  (('a, 'a) t, error) result

Source

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

Source

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