Update integer types to include signed / unsigned ints.

Various updates to make the types accurately reflect the integer sizes
specified in the original C types. Added some basic tests for macho
binary reading and GitHub CI setup to run tests.

Author: tmcgilchrist

.github/workflows/build.yml

@@ -34,7 +34,7 @@ jobs:
 
       - name: Install dependencies
         run: |
-          opam install . --deps-only --with-test
+          opam install . --deps-only --with-test --with-dev-setup
 
       - name: Build
         run: |
@@ -43,3 +43,7 @@ jobs:
       - name: Tests
         run: |
           opam exec -- dune build @runtest
+
+      - name: Format
+        run: |
+          opam exec -- dune build @fmt

.ocamlformat

@@ -0,0 +1,4 @@
+version = 0.27.0
+profile = conventional
+
+ocaml-version = 5.2.0

dune-project

@@ -1,14 +1,20 @@
-(lang dune 3.0)
+(lang dune 3.9)
 (name object)
 (generate_opam_files true)
 
 (license MIT)
+(maintainers "Tim McGilchrist <[email protected]>")
+(authors "Tim McGilchrist <[email protected]>")
+(source (github tmcgilchrist/object))
 
 (package
   (name object)
+ (tags (elf object mach-o pe coff))
+ (synopsis "A unified interface for reading and writing object file formats")
+ (description "A unified interface for reading and writing object file formats")
   (depends
-   (ocaml (>= 4.08))
+    (ocaml (>= 4.08))
     integers
-    (cmdliner :with-test))
-  (synopsis "A unified interface for reading and writing object file formats")
-  (description "A unified interface for reading and writing object file formats"))
+    (cmdliner :with-test)
+    (alcotest :with-test)
+    (ocamlformat (and :with-dev-setup (= 0.27.0)))))

object.opam

@@ -3,12 +3,19 @@ opam-version: "2.0"
 synopsis: "A unified interface for reading and writing object file formats"
 description:
   "A unified interface for reading and writing object file formats"
+maintainer: ["Tim McGilchrist <[email protected]>"]
+authors: ["Tim McGilchrist <[email protected]>"]
 license: "MIT"
+tags: ["elf" "object" "mach-o" "pe" "coff"]
+homepage: "https://github.com/tmcgilchrist/object"
+bug-reports: "https://github.com/tmcgilchrist/object/issues"
 depends: [
-  "dune" {>= "3.0"}
+  "dune" {>= "3.9"}
   "ocaml" {>= "4.08"}
   "integers"
   "cmdliner" {with-test}
+  "alcotest" {with-test}
+  "ocamlformat" {with-dev-setup & = "0.27.0"}
   "odoc" {with-doc}
 ]
 build: [
@@ -25,3 +32,7 @@ build: [
     "@doc" {with-doc}
   ]
 ]
+dev-repo: "git+https://github.com/tmcgilchrist/object.git"
+pin-depends: [
+  ["integers.dev" "git+https://github.com/tmcgilchrist/ocaml-integers.git#small-signed-integers-fixes"]
+]

object.opam.template

@@ -0,0 +1,3 @@
+pin-depends: [
+  ["integers.dev" "git+https://github.com/tmcgilchrist/ocaml-integers.git#small-signed-integers-fixes"]
+]

src/buffer.ml

@@ -1,42 +1,32 @@
 (** Low-level buffer manipulation *)
 
-type t =
-  (int, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
-
-type cursor = {
-    buffer: t;
-    mutable position: int;
-  }
+type t = (int, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
+type cursor = { buffer : t; mutable position : int }
 
 exception Invalid_format of string
+
 let invalid_format msg = raise (Invalid_format msg)
 
 let parse path =
-  let fd = Unix.openfile path [Unix.O_RDONLY] 0 in
+  let fd = Unix.openfile path [ Unix.O_RDONLY ] 0 in
   let len = Unix.lseek fd 0 Unix.SEEK_END in
   let t =
     Bigarray.array1_of_genarray
-      (Unix.map_file fd Bigarray.int8_unsigned
-         Bigarray.c_layout false [|len|]) in
+      (Unix.map_file fd Bigarray.int8_unsigned Bigarray.c_layout false [| len |])
+  in
   Unix.close fd;
   t
 
 let size = Bigarray.Array1.dim
-
-let cursor ?(at=0) buffer =
-  { buffer; position = at }
-
-let seek t position =
-  t.position <- position
+let cursor ?(at = 0) buffer = { buffer; position = at }
+let seek t position = t.position <- position
 
 let ensure t count msg =
   (* Ensure position does not overflow before checking for buffer overflow. *)
   let new_pos = t.position + count in
-  if (new_pos < 0) || (size t.buffer < new_pos) then
-    invalid_format msg
+  if new_pos < 0 || size t.buffer < new_pos then invalid_format msg
 
 let advance t count = t.position <- t.position + count
-
 let at_end t = size t.buffer = t.position
 
 open Types
@@ -46,28 +36,28 @@ module Read = struct
   let u8 t : u8 =
     let result = t.buffer.{t.position} in
     advance t 1;
-    result
+    Unsigned.UInt8.of_int result
 
   let s8 t : s8 =
     let result = t.buffer.{t.position} in
     advance t 1;
-    if result > 0x7F
-    then result lor ((-1) lsl 8)
-    else result
+    if result > 0x7F then Signed.Int8.of_int (result lor (-1 lsl 8))
+    else Signed.Int8.of_int result
 
   let u16 t : u16 =
-    let result = t.buffer.{t.position} lor t.buffer.{t.position + 1} lsl 8 in
+    let result = t.buffer.{t.position} lor (t.buffer.{t.position + 1} lsl 8) in
     advance t 2;
-    result
+    Unsigned.UInt16.of_int result
 
   let u32 t : u32 =
-    let result = t.buffer.{t.position}
-                 lor t.buffer.{t.position + 1} lsl 8
-                 lor t.buffer.{t.position + 2} lsl 16
-                 lor t.buffer.{t.position + 3} lsl 24
+    let result =
+      t.buffer.{t.position}
+      lor (t.buffer.{t.position + 1} lsl 8)
+      lor (t.buffer.{t.position + 2} lsl 16)
+      lor (t.buffer.{t.position + 3} lsl 24)
     in
     advance t 4;
-    result
+    Unsigned.UInt32.of_int result
 
   let u32be = u32
 
@@ -79,38 +69,32 @@ module Read = struct
       result := logor !result (shift_left n (i * 8))
     done;
     advance t 8;
-    !result
+    Unsigned.UInt64.of_int64 !result
 
   let i64 t : i64 =
     (* u64 are wrapped in an i64 and are actually signed. *)
-    u64 t
+    Unsigned.UInt64.to_int64 (u64 t)
 
   let uleb128 t : u128 =
     let rec aux t shift acc =
-      let x = u8 t in
+      let x = u8 t |> Unsigned.UInt8.to_int in
       let acc = acc lor ((x land 0x7f) lsl shift) in
-      if x land 0x80 = 0 then
-        acc
-      else
-        aux t (shift + 7) acc
+      if x land 0x80 = 0 then acc else aux t (shift + 7) acc
     in
     aux t 0 0
 
   let sleb128 t : s128 =
     let rec aux t shift acc =
-      let x = u8 t in
+      let x = u8 t |> Unsigned.UInt8.to_int in
       let acc = acc lor ((x land 0x7f) lsl shift) in
       if x land 0x80 = 0 then
-        if x land 0x40 = 0
-        then acc
-        else acc lor -(1 lsl (shift + 7))
-      else
-        aux t (shift + 7) acc
+        if x land 0x40 = 0 then acc else acc lor -(1 lsl (shift + 7))
+      else aux t (shift + 7) acc
     in
     aux t 0 0
 
   let fixed_string t length =
-    let {buffer; position} = t in
+    let { buffer; position } = t in
     let result = Bytes.create length in
     for i = 0 to length - 1 do
       Bytes.set result i (Char.unsafe_chr buffer.{position + i})
@@ -119,30 +103,27 @@ module Read = struct
     Bytes.unsafe_to_string result
 
   let rec scan_0 (b : t) ofs l i =
-    if i >= l then
-      None
-    else if b.{ofs + i} = 0 then
-      Some i
-    else
-      scan_0 b ofs l (i + 1)
+    if i >= l then None
+    else if b.{ofs + i} = 0 then Some i
+    else scan_0 b ofs l (i + 1)
 
   let zero_string t ?maxlen () =
-    let maxlen = match maxlen with
+    let maxlen =
+      match maxlen with
       | None -> size t.buffer - t.position
       | Some maxlen -> maxlen
     in
     match scan_0 t.buffer t.position maxlen 0 with
     | None -> None
     | Some length ->
-      let result = fixed_string t length in
-      advance t 1;
-      Some result
+        let result = fixed_string t length in
+        advance t 1;
+        Some result
 
   let buffer t length =
     let result = Bigarray.Array1.sub t.buffer t.position length in
     advance t length;
     result
 end
 
-let sub t length =
-  cursor (Read.buffer t length)
+let sub t length = cursor (Read.buffer t length)

src/buffer.mli

@@ -2,57 +2,56 @@ open Types
 
 (** Low-level buffer manipulation backed by [Bigarray.Array1.t]. *)
 
-type t =
-  (int, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
+type t = (int, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
 
-(** Create buffer from filename. *)
 val parse : string -> t
+(** Create buffer from filename. *)
 
 (* TODO
    Size of buffer remains int, because the size (aka dim) of
    Bigarray.Array1 is int, not int64. It should be enough in practice,
    as we will not be able to manipulate larger binaries anyway. *)
 
+val size : t -> int
 (** Size of the buffer *)
-val size     : t -> int
 
-(** Minimal support for error reporting. FIXME: Exceptions as errors are disappointing. *)
 exception Invalid_format of string
+(** Minimal support for error reporting. FIXME: Exceptions as errors are
+    disappointing. *)
+
 val invalid_format : string -> 'a
+(** Raise [Invalid_format] exception with a msg. *)
 
-type cursor = {
-  buffer: t;
-  mutable position: int;
-}
+type cursor = { buffer : t; mutable position : int }
 
-val cursor  : ?at:int -> t -> cursor
-val seek    : cursor -> int -> unit
-val ensure  : cursor -> int -> string -> unit
+val cursor : ?at:int -> t -> cursor
+val seek : cursor -> int -> unit
+val ensure : cursor -> int -> string -> unit
 val advance : cursor -> int -> unit
-val at_end  : cursor -> bool
+val at_end : cursor -> bool
 
-(** [sub t len] returns a fresh cursor pointing to the
-    beginning of a sub-buffer of size [len] starting from [t], and
-    advances [t] by [len] *)
-val sub     : cursor -> int -> cursor
+val sub : cursor -> int -> cursor
+(** [sub t len] returns a fresh cursor pointing to the beginning of a sub-buffer
+    of size [len] starting from [t], and advances [t] by [len] *)
 
 module Read : sig
-  val s8      : cursor -> s8
-  val u8      : cursor -> u8
-  val u16     : cursor -> u16
-  val u32     : cursor -> u32
-  val u32be   : cursor -> u32
-  val u64     : cursor -> u64
-  val i64     : cursor -> i64
+  val s8 : cursor -> s8
+  val u8 : cursor -> u8
+  val u16 : cursor -> u16
+  val u32 : cursor -> u32
+  val u32be : cursor -> u32
+  val u64 : cursor -> u64
+  val i64 : cursor -> i64
   val uleb128 : cursor -> u128
   val sleb128 : cursor -> s128
 
-  (** [fixed_string t len] reads a string of exactly [len] bytes from [t] *)
   val fixed_string : cursor -> int -> string
+  (** [fixed_string t len] reads a string of exactly [len] bytes from [t] *)
 
-  (** [zero_string t ?maxlen ()] reads a zero-terminated string from [t],
-      stopping at the first zero or when [maxlen] is reached, if it was provided. *)
   val zero_string : cursor -> ?maxlen:int -> unit -> string option
+  (** [zero_string t ?maxlen ()] reads a zero-terminated string from [t],
+      stopping at the first zero or when [maxlen] is reached, if it was
+      provided. *)
 
   val buffer : cursor -> int -> t
 end