package hxd

  1. Overview
  2. Docs
Hexdump in OCaml

Install 

dune-project
 Dependency

github.com Readme Changelog MIT License Edit opam file Versions (8)

Authors

  1. R
    Romain Calascibetta <romain.calascibetta@gmail.com>

Maintainers

  1. R
    Romain Calascibetta <romain.calascibetta@gmail.com>

Sources

hxd-0.3.5.tbz
sha256=135235f7c12b4fdfc2a6f764fd08e9ab7eb438856e02c6e668d73ba89ce77443
sha512=8b55c2f619d9df5db78990f9c52462416a6da71f36d570ea2ad1b640605132cbb4dd3df078f041d5fde721d61baa6d6efb9a0163f738efaf4a429660a3a665a6

doc/hxd.core/Hxd/index.html

Module HxdSource

HeXDump library for OCaml.

The library provides the most abstract way to serialize something to a human-readable hexdump. It allows the transmission of binary data in a `mail-safe' ASCII representation and it can handle colors if the given Format.formatter supports it.

It permits to serialize to a caml value as a simple list of strings or an array of strings.

Sourcemodule Fmt : sig ... end
Sourcetype colorscheme

The type of colorschemes.

Sourceval colorscheme_of_array : Fmt.style array -> colorscheme

colorscheme_of_array arr returns a colorscheme from an array of 256 elements. Otherwise, it returns an invalid argument.

Sourceval lowercase : colorscheme -> Fmt.style -> unit

lowercase c style sets lowercase ASCII values to the style style.

Sourceval uppercase : colorscheme -> Fmt.style -> unit

uppercase c style sets uppercase ASCII values to the style style.

Sourceval digit : colorscheme -> Fmt.style -> unit

digit c style sets digit ASCII values to the style style.

Sourceval code : colorscheme -> int -> Fmt.style -> unit

code c code style sets a specific ASCII code c to the style style.

Sourcetype cfg

The type of configurations.

Sourceval xxd : ?cols:int -> ?groupsize:int -> ?long:int -> ?uppercase:bool -> colorscheme -> cfg

xxd ?cols ?groupsize ?long ?uppercase colorscheme returns a configuration which can be used by generate then.

  • cols: octets per line (default to 16)
  • groupsize: Separate the output of every groupsize bytes by a whitespace (default to 2).
  • long: stop after reading len octets.
  • uppercase: use upper case hex letters (default is lower case).
  • colorscheme: colorscheme used if the given Format.formatter supports it.
Sourceval caml : ?with_comments:bool -> ?cols:int -> ?long:int -> ?uppercase:bool -> [ `List | `Array ] -> cfg

caml ?with_comments ?cols ?long ?uppercase k returns a configuration which can be used by generate then. It allows to produces a caml value from something.

  • cols: octets per line (default to 16)
  • with_comments: add a comment which pretty-line the group in a comment
  • long: stop after reading len octets.
  • k: if the user wants to produce a list of strings or an array of strings.
Sourceval default : cfg

A default XXD configuration.

Sourcetype ('a, 's) io
Sourcetype ('f, 'b, 's, 'e) input = 'f -> 'b -> off:int -> len:int -> ((int, 'e) result, 's) io
Sourcetype ('f, 'b, 's, 'e) output = 'f -> 'b -> off:int -> len:int -> ((int, 'e) result, 's) io
Sourcemodule Make (S : sig ... end) : sig ... end
Sourcetype 's scheduler = {
  1. bind : 'a 'b. ('a, 's) io -> ('a -> ('b, 's) io) -> ('b, 's) io;
  2. return : 'a. 'a -> ('a, 's) io;
}
Sourcetype ('f, 's, 'e) seek = {
  1. lseek : 'f -> int -> [ `SET | `CUR | `END ] -> ((int, 'e) result, 's) io;
}
Sourceval generate : cfg -> 's scheduler -> ('i, bytes, 's, 'e) input -> ('o, string, 's, 'e) output -> 'i -> 'o -> ('i, 's, 'e) seek -> [ `Absolute of int | `Relative of int ] -> Format.formatter -> ((unit, 'e) result, 's) io

generate cfg scheduler input output ic oc seek pos ppf is the most abstract way to produce an hex-dump output. According to arguments, we are able to read into ic and write into oc with respectively input and output.

seek is used to manipulate the position in ic according to the given position pos.

ppf is used to know if we support colors or not. generate writes on it too and it takes care about pretty-printing boxes.

scheduler depends on which scheduler you use. You need to create one over monads:

  module Unix_scheduler = Hxd.Make(struct type 'a t = 'a end)

  let unix_scheduler =
    let open Unix_scheduler in
    { Hxd.bind= (fun x f -> f (prj x))
    ; return= inj }

  generate cfg unix_scheduler ...

You can abstract LWT monads too:

  module Lwt_scheduler = Hxd.Make (struct type 'a t = 'a Lwt.t end)

  let lwt_scheduler =
    let open Lwt.Infix in
    let open Lwt_scheduler in
    {
      Hxd.bind= (fun f x -> inj (prj x >>= fun x -> prj (f x)))
    ; return= (fun x -> inj (Lwt.return x))
    }
      generate cfg lwt_scheduler

Such layers exist with hxd.unix and hxd.lwt.