package decompress

You can search for identifiers within the package.

in-package search v0.2.0

package decompress

decompress
- Library decompress
  - Decompress
    
    B
    
    Bigstring
    
    Hunk
    
    L
    
    DEFLATE
    
    F
    
    RFC1951_deflate
    
    F
    
    Zlib_deflate
    
    F
    
    Window
    
    INFLATE
    
    RFC1951_inflate
    
    Zlib_inflate
- Library decompress.impl
  - Decompress_impl
    
    B
    
    Bigstring
    
    Bytes
    
    Q
    
    Safe
    
    B
    
    Bigstring
    
    Bytes
    
    Seq
    
    Hunk
    
    L
    
    Safe
    
    B
    
    Bigstring
    
    Bytes
    
    Seq
    
    Hunk
    
    B
    
    Bigstring
    
    Bytes
    
    T
    
    Heap
    
    T
    
    Table
    
    DEFLATE
    
    F
    
    S_deflate
    
    Convenience_deflate
    
    RFC1951_deflate
    
    F
    
    KWriteBlock
    
    KDynamicHeader
    
    Zlib_deflate
    
    F
    
    KHeader
    
    KAdler32
    
    Window
    
    INFLATE
    
    S_inflate
    
    Convenience_inflate
    
    RFC1951_inflate
    
    Heap
    
    Huffman
    
    Lookup
    
    KLast
    
    KBlock
    
    KDictionary
    
    KFlat
    
    KInflate
    
    Dictionary
    
    Zlib_inflate
    
    KHeader
    
    KCrc
- Sources
  - decompress
    
    decompress.ml
  - decompress.impl
    
    decompress_b.ml
    
    decompress_bigstring.ml
    
    decompress_bytes.ml
    
    decompress_hunk.ml
    
    decompress_impl.ml
    
    decompress_impl__.ml
    
    decompress_lz77.ml
    
    decompress_q.ml
    
    decompress_safe.ml
    
    decompress_seq.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Decompress_impl.RFC1951_deflate`Source

Sourcemodule F : sig ... end

Sourcetype error = error_rfc1951_deflate

Sourcetype ('i, 'o) t = {

hold : int;
bits : int;
temp : ([ Safe.ro | Safe.wo ], '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;
wi : 'i B.t;
wo : 'o B.t;

}

Source

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

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

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

Sourceand flush =

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

Sourceand code =

| Length
| ExtLength
| Dist
| ExtDist

Sourceand meth =

| PARTIAL
| SYNC
| FULL

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

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

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

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

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

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

Sourceval await : ('i, 'o) t -> ('i, 'o) res

Sourceval error : ('i, 'o) t -> error -> ('i, 'o) res

Sourceval ok : ('i, 'o) t -> int -> ('i, 'o) res

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

Source

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

Source

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

Source

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

Source

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

Source

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

Sourcemodule KWriteBlock : sig ... end

Sourcemodule KDynamicHeader : sig ... end

Source

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

Source

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

Sourceval zip : 'a array -> 'b array -> ('a * 'b) array

Source

val write_block : 
  (int * int) array ->
  (int * int) array ->
  Hunk.t Q.t ->
  flush ->
  (Safe.ro, 'a) Safe.t ->
  (Safe.wo, 'b) Safe.t ->
  ('a, 'b) t ->
  ('a, 'b) res

Source

val static : 
  'a ->
  Hunk.t Q.t ->
  ('a -> flush) ->
  (Safe.ro, 'b) Safe.t ->
  (Safe.wo, 'c) Safe.t ->
  ('b, 'c) t ->
  ('b, 'c) res

Source

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

Source

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

Source

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

Source

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

Source

val make_block : 
  (L.Safe.ro, 'a) L.Safe.t ->
  'b ->
  ('a, 'a) t ->
  ('a, 'c) block ->
  ('a, 'a) res

Source

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

Source

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

Source

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

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

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

Source

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

Sourceval to_final : 'a -> flush

Sourceval to_partial : F.t -> flush

Sourceval to_sync : F.t -> flush

Sourceval to_full : 'a -> flush

Sourceval finish : ('a, 'a) t -> ('a, 'a) t

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

Sourceval partial_flush : int -> int -> ('a, 'a) t -> ('a, 'a) t

Sourceval sync_flush : int -> int -> ('a, 'a) t -> ('a, 'a) t

Sourceval full_flush : int -> int -> ('a, 'a) t -> ('a, 'a) t

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

Source

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

Source

val eval : 
  'a ->
  'a ->
  ('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 used_in : ('a, 'b) t -> int

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

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

Sourceval default : witness:'a Safe.B.t -> ?wbits:int -> int -> ('a, 'a) t

include sig ... end

Source

val to_result : 
  'a ->
  'a ->
  ?meth:(meth * int) ->
  ('a -> int option -> int) ->
  ('a -> int -> int) ->
  ('a, 'a) t ->
  (('a, 'a) t, error) result

Source

val bytes : 
  'a ->
  'a ->
  ?meth:(meth * int) ->
  ('a -> int option -> int) ->
  ('a -> int -> int) ->
  ('a, 'a) t ->
  (('a, 'a) t, error) result

Source

val bigstring : 
  'a ->
  'a ->
  ?meth:(meth * int) ->
  ('a -> int option -> int) ->
  ('a -> int -> int) ->
  ('a, 'a) t ->
  (('a, 'a) t, error) result

package decompress

Module Decompress_impl.RFC1951_deflateSource

Module `Decompress_impl.RFC1951_deflate`Source