├── .gitignore ├── LICENSE ├── README.md ├── dune-project ├── lib ├── dune ├── uint.ml ├── uint.mli ├── uint128.ml ├── uint128.mli ├── uint16.ml ├── uint16.mli ├── uint32.ml ├── uint32.mli ├── uint64.ml ├── uint64.mli ├── uint8.ml └── uint8.mli ├── spec ├── dune └── test.ml └── uint.opam /.gitignore: -------------------------------------------------------------------------------- 1 | .gitignore 2 | _build/ 3 | *.native 4 | *.install 5 | *.merlin 6 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2010 Andre Nathan 2 | Jeff Shaw 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy 5 | of this software and associated documentation files (the "Software"), to deal 6 | in the Software without restriction, including without limitation the rights 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 | copies of the Software, and to permit persons to whom the Software is 9 | furnished to do so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in 12 | all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 20 | THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ocaml-uint 2 | 3 | This project has been superseded by 4 | [ocaml-stdint](https://github.com/andrenth/ocaml-stdint). 5 | 6 | Bug fixes will still be applied here but new development will only happen in 7 | the new repository. 8 | -------------------------------------------------------------------------------- /dune-project: -------------------------------------------------------------------------------- 1 | (lang dune 1.11) 2 | (name uint) 3 | -------------------------------------------------------------------------------- /lib/dune: -------------------------------------------------------------------------------- 1 | (library 2 | (name uint) 3 | (public_name uint) 4 | (wrapped false) 5 | (modules uint uint8 uint16 uint32 uint64 uint128) 6 | (libraries stdint) 7 | ) 8 | -------------------------------------------------------------------------------- /lib/uint.ml: -------------------------------------------------------------------------------- 1 | module type Str_conv_sig = sig 2 | module type UintSig = sig 3 | type t 4 | val name : string 5 | val fmt : string 6 | val zero : t 7 | val max_int : t 8 | val bits : int 9 | val of_int : int -> t 10 | val to_int : t -> int 11 | val add : t -> t -> t 12 | val mul : t -> t -> t 13 | val divmod : t -> t -> t * t 14 | end 15 | 16 | module type S = sig 17 | type t 18 | val of_string : string -> t 19 | val to_string : t -> string 20 | val to_string_bin : t -> string 21 | val to_string_oct : t -> string 22 | val to_string_hex : t -> string 23 | val printer : Format.formatter -> t -> unit 24 | val printer_bin : Format.formatter -> t -> unit 25 | val printer_oct : Format.formatter -> t -> unit 26 | val printer_hex : Format.formatter -> t -> unit 27 | end 28 | 29 | module Make (U : UintSig) : S with type t = U.t 30 | end 31 | 32 | module Str_conv : Str_conv_sig = struct 33 | module type UintSig = sig 34 | type t 35 | val name : string 36 | val fmt : string 37 | val zero : t 38 | val max_int : t 39 | val bits : int 40 | val of_int : int -> t 41 | val to_int : t -> int 42 | val add : t -> t -> t 43 | val mul : t -> t -> t 44 | val divmod : t -> t -> t * t 45 | end 46 | 47 | module type S = sig 48 | type t 49 | val of_string : string -> t 50 | val to_string : t -> string 51 | val to_string_bin : t -> string 52 | val to_string_oct : t -> string 53 | val to_string_hex : t -> string 54 | val printer : Format.formatter -> t -> unit 55 | val printer_bin : Format.formatter -> t -> unit 56 | val printer_oct : Format.formatter -> t -> unit 57 | val printer_hex : Format.formatter -> t -> unit 58 | end 59 | 60 | module Make (U : UintSig) : S with type t = U.t = struct 61 | type t = U.t 62 | 63 | let digit_of_char c = 64 | let disp = 65 | if c >= '0' && c <= '9' then 48 66 | else if c >= 'A' && c <= 'F' then 55 67 | else if c >= 'a' && c <= 'f' then 87 68 | else failwith (U.name ^ ".of_string") in 69 | int_of_char c - disp 70 | 71 | let of_string' s base = 72 | let base = U.of_int base in 73 | let res = ref U.zero in 74 | let thresh = fst (U.divmod U.max_int base) in 75 | for i = 0 to String.length s - 1 do 76 | let c = s.[i] in 77 | if !res > thresh then failwith (U.name ^ ".of_string"); 78 | if c <> '_' then begin 79 | let d = U.of_int (digit_of_char c) in 80 | res := U.add (U.mul !res base) d; 81 | if !res < d then failwith (U.name ^ ".of_string"); 82 | end 83 | done; 84 | !res 85 | 86 | let of_string s = 87 | let fail = U.name ^ ".of_string" in 88 | let len = String.length s in 89 | match len with 90 | | 0 -> invalid_arg fail 91 | | 1 | 2 -> of_string' s 10 92 | | _ -> 93 | if s.[0] = '0' && (s.[1] < '0' || s.[1] > '9') then 94 | let base = 95 | match s.[1] with 96 | | 'b' | 'B' -> 2 97 | | 'o' | 'O' -> 8 98 | | 'x' | 'X' -> 16 99 | | _ -> invalid_arg fail in 100 | of_string' (String.sub s 2 (len - 2)) base 101 | else 102 | of_string' s 10 103 | 104 | let to_string_base base prefix x = 105 | let y = ref x in 106 | if !y = U.zero then 107 | "0" 108 | else begin 109 | let buffer = Bytes.create U.bits in 110 | let conv = "0123456789abcdef" in 111 | let base = U.of_int base in 112 | let i = ref (Bytes.length buffer) in 113 | while !y <> U.zero do 114 | let x', digit = U.divmod !y base in 115 | y := x'; 116 | decr i; 117 | Bytes.set buffer !i conv.[U.to_int digit] 118 | done; 119 | prefix ^ Bytes.sub_string buffer !i (Bytes.length buffer - !i) 120 | end 121 | 122 | let to_string = to_string_base 10 "" 123 | let to_string_bin = to_string_base 2 "0b" 124 | let to_string_oct = to_string_base 8 "0o" 125 | let to_string_hex = to_string_base 16 "0x" 126 | 127 | let print_with f fmt x = 128 | Format.fprintf fmt "@[%s@]" (f x ^ U.fmt) 129 | 130 | let printer = print_with to_string 131 | let printer_bin = print_with to_string_bin 132 | let printer_oct = print_with to_string_oct 133 | let printer_hex = print_with to_string_hex 134 | end 135 | end 136 | -------------------------------------------------------------------------------- /lib/uint.mli: -------------------------------------------------------------------------------- 1 | module type Str_conv_sig = sig 2 | module type UintSig = sig 3 | type t 4 | val name : string 5 | val fmt : string 6 | val zero : t 7 | val max_int : t 8 | val bits : int 9 | val of_int : int -> t 10 | val to_int : t -> int 11 | val add : t -> t -> t 12 | val mul : t -> t -> t 13 | val divmod : t -> t -> t * t 14 | end 15 | 16 | module type S = sig 17 | type t 18 | val of_string : string -> t 19 | val to_string : t -> string 20 | val to_string_bin : t -> string 21 | val to_string_oct : t -> string 22 | val to_string_hex : t -> string 23 | val printer : Format.formatter -> t -> unit 24 | val printer_bin : Format.formatter -> t -> unit 25 | val printer_oct : Format.formatter -> t -> unit 26 | val printer_hex : Format.formatter -> t -> unit 27 | end 28 | 29 | module Make (U : UintSig) : S with type t = U.t 30 | end 31 | 32 | module Str_conv : Str_conv_sig 33 | -------------------------------------------------------------------------------- /lib/uint128.ml: -------------------------------------------------------------------------------- 1 | open Stdint 2 | 3 | type t = Uint128.t 4 | type uint128 = t 5 | 6 | let zero = Uint128.zero 7 | let one = Uint128.one 8 | let add = Uint128.add 9 | let sub = Uint128.sub 10 | let mul = Uint128.mul 11 | let div = Uint128.div 12 | let rem = Uint128.rem 13 | let succ = Uint128.succ 14 | let pred = Uint128.pred 15 | let max_int = Uint128.max_int 16 | let min_int = Uint128.min_int 17 | let logand = Uint128.logand 18 | let logor = Uint128.logor 19 | let logxor = Uint128.logxor 20 | let lognot = Uint128.lognot 21 | let shift_left = Uint128.shift_left 22 | let shift_right = Uint128.shift_right 23 | let shift_right_logical = Uint128.shift_right_logical 24 | let of_int = Uint128.of_int 25 | let to_int = Uint128.to_int 26 | let of_float = Uint128.of_float 27 | let to_float = Uint128.to_float 28 | let of_int32 = Uint128.of_int32 29 | let to_int32 = Uint128.to_int32 30 | let of_int64 = Uint128.of_int64 31 | let to_int64 = Uint128.to_int64 32 | let of_nativeint = Uint128.of_nativeint 33 | let to_nativeint = Uint128.to_nativeint 34 | let of_string = Uint128.of_string 35 | let to_string = Uint128.to_string 36 | let to_string_bin = Uint128.to_string_bin 37 | let to_string_oct = Uint128.to_string_oct 38 | let to_string_hex = Uint128.to_string_hex 39 | let compare = Uint128.compare 40 | let printer = Uint128.printer 41 | let printer_bin = Uint128.printer_bin 42 | let printer_oct = Uint128.printer_oct 43 | let printer_hex = Uint128.printer_hex 44 | -------------------------------------------------------------------------------- /lib/uint128.mli: -------------------------------------------------------------------------------- 1 | type t = Stdint.Uint128.t 2 | type uint128 = t 3 | val zero : uint128 4 | val one : uint128 5 | val add : uint128 -> uint128 -> uint128 6 | val sub : uint128 -> uint128 -> uint128 7 | val mul : uint128 -> uint128 -> uint128 8 | val div : uint128 -> uint128 -> uint128 9 | val rem : uint128 -> uint128 -> uint128 10 | val succ : uint128 -> uint128 11 | val pred : uint128 -> uint128 12 | val max_int : uint128 13 | val min_int : uint128 14 | val logand : uint128 -> uint128 -> uint128 15 | val logor : uint128 -> uint128 -> uint128 16 | val logxor : uint128 -> uint128 -> uint128 17 | val lognot : uint128 -> uint128 18 | val shift_left : uint128 -> int -> uint128 19 | val shift_right : uint128 -> int -> uint128 20 | val shift_right_logical : uint128 -> int -> uint128 21 | val of_int : int -> uint128 22 | val to_int : uint128 -> int 23 | val of_float : float -> uint128 24 | val to_float : uint128 -> float 25 | val of_int32 : int32 -> uint128 26 | val to_int32 : uint128 -> int32 27 | val of_int64 : int64 -> uint128 28 | val to_int64 : uint128 -> int64 29 | val of_nativeint : nativeint -> uint128 30 | val to_nativeint : uint128 -> nativeint 31 | val of_string : string -> uint128 32 | val to_string : uint128 -> string 33 | val to_string_bin : uint128 -> string 34 | val to_string_oct : uint128 -> string 35 | val to_string_hex : uint128 -> string 36 | val compare : t -> t -> int 37 | val printer : Format.formatter -> uint128 -> unit 38 | val printer_bin : Format.formatter -> uint128 -> unit 39 | val printer_oct : Format.formatter -> uint128 -> unit 40 | val printer_hex : Format.formatter -> uint128 -> unit 41 | -------------------------------------------------------------------------------- /lib/uint16.ml: -------------------------------------------------------------------------------- 1 | open Stdint 2 | 3 | type uint16 = Uint16.t 4 | type t = uint16 5 | 6 | let add = Uint16.add 7 | let sub = Uint16.sub 8 | let mul = Uint16.mul 9 | let div = Uint16.div 10 | let rem = Uint16.rem 11 | let logand = Uint16.logand 12 | let logor = Uint16.logor 13 | let logxor = Uint16.logxor 14 | let lognot = Uint16.lognot 15 | let shift_left = Uint16.shift_left 16 | let shift_right = Uint16.shift_right 17 | let of_int = Uint16.of_int 18 | let to_int = Uint16.to_int 19 | let of_float = Uint16.of_float 20 | let to_float = Uint16.to_float 21 | let of_int32 = Uint16.of_int32 22 | let to_int32 = Uint16.to_int32 23 | let bits_of_float = Uint16.of_float (* This may cause issues *) 24 | let float_of_bits = Uint16.to_float (* This may cause issues *) 25 | 26 | let zero = Uint16.zero 27 | let one = Uint16.one 28 | let succ = Uint16.succ 29 | let pred = Uint16.pred 30 | let max_int = Uint16.max_int 31 | let min_int = Uint16.min_int 32 | 33 | module Conv = Uint.Str_conv.Make(struct 34 | type t = uint16 35 | let fmt = "Ul" 36 | let name = "Uint16" 37 | let zero = zero 38 | let max_int = max_int 39 | let bits = 16 40 | let of_int = of_int 41 | let to_int = to_int 42 | let add = add 43 | let mul = mul 44 | let divmod = (fun x y -> div x y, rem x y) 45 | end) 46 | 47 | let of_string = Conv.of_string 48 | let to_string = Conv.to_string 49 | let to_string_bin = Conv.to_string_bin 50 | let to_string_oct = Conv.to_string_oct 51 | let to_string_hex = Conv.to_string_hex 52 | let printer = Conv.printer 53 | let printer_bin = Conv.printer_bin 54 | let printer_oct = Conv.printer_oct 55 | let printer_hex = Conv.printer_hex 56 | 57 | let compare = Stdlib.compare 58 | -------------------------------------------------------------------------------- /lib/uint16.mli: -------------------------------------------------------------------------------- 1 | type t = Stdint.Uint16.t 2 | type uint16 = t 3 | val zero : uint16 4 | val one : uint16 5 | val add : uint16 -> uint16 -> uint16 6 | val sub : uint16 -> uint16 -> uint16 7 | val mul : uint16 -> uint16 -> uint16 8 | val div : uint16 -> uint16 -> uint16 9 | val rem : uint16 -> uint16 -> uint16 10 | val succ : uint16 -> uint16 11 | val pred : uint16 -> uint16 12 | val max_int : uint16 13 | val min_int : uint16 14 | val logand : uint16 -> uint16 -> uint16 15 | val logor : uint16 -> uint16 -> uint16 16 | val logxor : uint16 -> uint16 -> uint16 17 | val lognot : uint16 -> uint16 18 | val shift_left : uint16 -> int -> uint16 19 | val shift_right : uint16 -> int -> uint16 20 | val of_int : int -> uint16 21 | val to_int : uint16 -> int 22 | val of_float : float -> uint16 23 | val to_float : uint16 -> float 24 | val of_int32 : int32 -> uint16 25 | val to_int32 : uint16 -> int32 26 | val of_string : string -> uint16 27 | val to_string : uint16 -> string 28 | val to_string_bin : uint16 -> string 29 | val to_string_oct : uint16 -> string 30 | val to_string_hex : uint16 -> string 31 | val bits_of_float : float -> uint16 32 | [@@ocaml.alert deprecated] 33 | val float_of_bits : uint16 -> float 34 | [@@ocaml.alert deprecated] 35 | val compare : t -> t -> int 36 | val printer : Format.formatter -> uint16 -> unit 37 | val printer_bin : Format.formatter -> uint16 -> unit 38 | val printer_oct : Format.formatter -> uint16 -> unit 39 | val printer_hex : Format.formatter -> uint16 -> unit 40 | -------------------------------------------------------------------------------- /lib/uint32.ml: -------------------------------------------------------------------------------- 1 | open Stdint 2 | 3 | type uint32 = Uint32.t 4 | type t = uint32 5 | 6 | let add = Uint32.add 7 | let sub = Uint32.sub 8 | let mul = Uint32.mul 9 | let div = Uint32.div 10 | let rem = Uint32.rem 11 | let logand = Uint32.logand 12 | let logor = Uint32.logor 13 | let logxor = Uint32.logxor 14 | let shift_left = Uint32.shift_left 15 | let shift_right = Uint32.shift_right 16 | let of_int = Uint32.of_int 17 | let to_int = Uint32.to_int 18 | let of_float = Uint32.of_float 19 | let to_float = Uint32.to_float 20 | let of_int32 = Uint32.of_int32 21 | let to_int32 = Uint32.to_int32 22 | let bits_of_float = Uint32.of_float 23 | let float_of_bits = Uint32.to_float 24 | 25 | let zero = Uint32.zero 26 | let one = Uint32.one 27 | let succ = Uint32.succ 28 | let pred = Uint32.pred 29 | let max_int = Uint32.max_int 30 | let min_int = Uint32.min_int 31 | let lognot = Uint32.lognot 32 | 33 | module Conv = Uint.Str_conv.Make(struct 34 | type t = uint32 35 | let fmt = "Ul" 36 | let name = "Uint32" 37 | let zero = zero 38 | let max_int = max_int 39 | let bits = 32 40 | let of_int = of_int 41 | let to_int = to_int 42 | let add = add 43 | let mul = mul 44 | let divmod = (fun x y -> div x y, rem x y) 45 | end) 46 | 47 | let of_string = Conv.of_string 48 | let to_string = Conv.to_string 49 | let to_string_bin = Conv.to_string_bin 50 | let to_string_oct = Conv.to_string_oct 51 | let to_string_hex = Conv.to_string_hex 52 | let printer = Conv.printer 53 | let printer_bin = Conv.printer_bin 54 | let printer_oct = Conv.printer_oct 55 | let printer_hex = Conv.printer_hex 56 | 57 | let compare = Stdlib.compare 58 | -------------------------------------------------------------------------------- /lib/uint32.mli: -------------------------------------------------------------------------------- 1 | type t = Stdint.Uint32.t 2 | type uint32 = t 3 | val zero : uint32 4 | val one : uint32 5 | val add : uint32 -> uint32 -> uint32 6 | val sub : uint32 -> uint32 -> uint32 7 | val mul : uint32 -> uint32 -> uint32 8 | val div : uint32 -> uint32 -> uint32 9 | val rem : uint32 -> uint32 -> uint32 10 | val succ : uint32 -> uint32 11 | val pred : uint32 -> uint32 12 | val max_int : uint32 13 | val min_int : uint32 14 | val logand : uint32 -> uint32 -> uint32 15 | val logor : uint32 -> uint32 -> uint32 16 | val logxor : uint32 -> uint32 -> uint32 17 | val lognot : uint32 -> uint32 18 | val shift_left : uint32 -> int -> uint32 19 | val shift_right : uint32 -> int -> uint32 20 | val of_int : int -> uint32 21 | val to_int : uint32 -> int 22 | val of_float : float -> uint32 23 | val to_float : uint32 -> float 24 | val of_int32 : int32 -> uint32 25 | val to_int32 : uint32 -> int32 26 | val of_string : string -> uint32 27 | val to_string : uint32 -> string 28 | val to_string_bin : uint32 -> string 29 | val to_string_oct : uint32 -> string 30 | val to_string_hex : uint32 -> string 31 | val bits_of_float : float -> uint32 32 | [@@ocaml.alert deprecated] 33 | val float_of_bits : uint32 -> float 34 | [@@ocaml.alert deprecated] 35 | val compare : t -> t -> int 36 | val printer : Format.formatter -> uint32 -> unit 37 | val printer_bin : Format.formatter -> uint32 -> unit 38 | val printer_oct : Format.formatter -> uint32 -> unit 39 | val printer_hex : Format.formatter -> uint32 -> unit 40 | -------------------------------------------------------------------------------- /lib/uint64.ml: -------------------------------------------------------------------------------- 1 | open Stdint 2 | 3 | type uint64 = Uint64.t 4 | type t = uint64 5 | 6 | let add = Uint64.add 7 | let sub = Uint64.sub 8 | let mul = Uint64.mul 9 | let div = Uint64.div 10 | let rem = Uint64.rem 11 | let logand = Uint64.logand 12 | let logor = Uint64.logor 13 | let logxor = Uint64.logxor 14 | let lognot = Uint64.lognot 15 | let shift_left = Uint64.shift_left 16 | let shift_right = Uint64.shift_right 17 | let of_int = Uint64.of_int 18 | let to_int = Uint64.to_int 19 | let of_int32 = Uint64.of_int32 20 | let to_int32 = Uint64.to_int32 21 | let of_int64 = Uint64.of_int64 22 | let to_int64 = Uint64.to_int64 23 | let of_nativeint = Uint64.of_nativeint 24 | let to_nativeint = Uint64.to_nativeint 25 | let of_float = Uint64.of_float 26 | let to_float = Uint64.to_float 27 | let bits_of_float = Uint64.of_float (* This may cause issues *) 28 | let float_of_bits = Uint64.to_float (* This may cause issues *) 29 | 30 | let zero = Uint64.zero 31 | let one = Uint64.one 32 | let succ = Uint64.succ 33 | let pred = Uint64.pred 34 | let max_int = Uint64.max_int 35 | let min_int = Uint64.min_int 36 | 37 | module Conv = Uint.Str_conv.Make(struct 38 | type t = uint64 39 | let name = "Uint64" 40 | let fmt = "UL" 41 | let zero = zero 42 | let max_int = max_int 43 | let bits = 64 44 | let of_int = of_int 45 | let to_int = to_int 46 | let add = add 47 | let mul = mul 48 | let divmod = (fun x y -> div x y, rem x y) 49 | end) 50 | 51 | let of_string = Conv.of_string 52 | let to_string = Conv.to_string 53 | let to_string_bin = Conv.to_string_bin 54 | let to_string_oct = Conv.to_string_oct 55 | let to_string_hex = Conv.to_string_hex 56 | let printer = Conv.printer 57 | let printer_bin = Conv.printer_bin 58 | let printer_oct = Conv.printer_oct 59 | let printer_hex = Conv.printer_hex 60 | 61 | let compare = Stdlib.compare 62 | -------------------------------------------------------------------------------- /lib/uint64.mli: -------------------------------------------------------------------------------- 1 | type t = Stdint.Uint64.t 2 | type uint64 = t 3 | val zero : uint64 4 | val one : uint64 5 | val add : uint64 -> uint64 -> uint64 6 | val sub : uint64 -> uint64 -> uint64 7 | val mul : uint64 -> uint64 -> uint64 8 | val div : uint64 -> uint64 -> uint64 9 | val rem : uint64 -> uint64 -> uint64 10 | val succ : uint64 -> uint64 11 | val pred : uint64 -> uint64 12 | val max_int : uint64 13 | val min_int : uint64 14 | val logand : uint64 -> uint64 -> uint64 15 | val logor : uint64 -> uint64 -> uint64 16 | val logxor : uint64 -> uint64 -> uint64 17 | val lognot : uint64 -> uint64 18 | val shift_left : uint64 -> int -> uint64 19 | val shift_right : uint64 -> int -> uint64 20 | val of_int : int -> uint64 21 | val to_int : uint64 -> int 22 | val of_float : float -> uint64 23 | val to_float : uint64 -> float 24 | val of_int32 : int32 -> uint64 25 | val to_int32 : uint64 -> int32 26 | val of_nativeint : nativeint -> uint64 27 | val to_nativeint : uint64 -> nativeint 28 | val of_int64 : int64 -> uint64 29 | val to_int64 : uint64 -> int64 30 | val of_string : string -> uint64 31 | val to_string : uint64 -> string 32 | val to_string_bin : uint64 -> string 33 | val to_string_oct : uint64 -> string 34 | val to_string_hex : uint64 -> string 35 | val bits_of_float : float -> uint64 36 | [@@ocaml.alert deprecated] 37 | val float_of_bits : uint64 -> float 38 | [@@ocaml.alert deprecated] 39 | val compare : t -> t -> int 40 | val printer : Format.formatter -> uint64 -> unit 41 | val printer_bin : Format.formatter -> uint64 -> unit 42 | val printer_oct : Format.formatter -> uint64 -> unit 43 | val printer_hex : Format.formatter -> uint64 -> unit 44 | -------------------------------------------------------------------------------- /lib/uint8.ml: -------------------------------------------------------------------------------- 1 | open Stdint 2 | 3 | type uint8 = Uint8.t 4 | type t = uint8 5 | 6 | let add = Uint8.add 7 | let sub = Uint8.sub 8 | let mul = Uint8.mul 9 | let div = Uint8.div 10 | let rem = Uint8.rem 11 | let logand = Uint8.logand 12 | let logor = Uint8.logor 13 | let logxor = Uint8.logxor 14 | let lognot = Uint8.lognot 15 | let shift_left = Uint8.shift_left 16 | let shift_right = Uint8.shift_right 17 | let of_int = Uint8.of_int 18 | let to_int = Uint8.to_int 19 | let of_float = Uint8.of_float 20 | let to_float = Uint8.to_float 21 | let of_int32 = Uint8.of_int32 22 | let to_int32 = Uint8.to_int32 23 | let bits_of_float = Uint8.of_float (* This may cause issues *) 24 | let float_of_bits = Uint8.to_float (* This may cause issues *) 25 | 26 | let zero = of_int 0 27 | let one = of_int 1 28 | let succ = Uint8.succ 29 | let pred = Uint8.pred 30 | let max_int = Uint8.max_int 31 | let min_int = Uint8.min_int 32 | 33 | module Conv = Uint.Str_conv.Make(struct 34 | type t = uint8 35 | let fmt = "Ul" 36 | let name = "Uint8" 37 | let zero = zero 38 | let max_int = max_int 39 | let bits = 8 40 | let of_int = of_int 41 | let to_int = to_int 42 | let add = add 43 | let mul = mul 44 | let divmod = (fun x y -> div x y, rem x y) 45 | end) 46 | 47 | let of_string = Conv.of_string 48 | let to_string = Conv.to_string 49 | let to_string_bin = Conv.to_string_bin 50 | let to_string_oct = Conv.to_string_oct 51 | let to_string_hex = Conv.to_string_hex 52 | let printer = Conv.printer 53 | let printer_bin = Conv.printer_bin 54 | let printer_oct = Conv.printer_oct 55 | let printer_hex = Conv.printer_hex 56 | 57 | let compare = Stdlib.compare 58 | -------------------------------------------------------------------------------- /lib/uint8.mli: -------------------------------------------------------------------------------- 1 | type t = Stdint.Uint8.t 2 | type uint8 = t 3 | val zero : uint8 4 | val one : uint8 5 | val add : uint8 -> uint8 -> uint8 6 | val sub : uint8 -> uint8 -> uint8 7 | val mul : uint8 -> uint8 -> uint8 8 | val div : uint8 -> uint8 -> uint8 9 | val rem : uint8 -> uint8 -> uint8 10 | val succ : uint8 -> uint8 11 | val pred : uint8 -> uint8 12 | val max_int : uint8 13 | val min_int : uint8 14 | val logand : uint8 -> uint8 -> uint8 15 | val logor : uint8 -> uint8 -> uint8 16 | val logxor : uint8 -> uint8 -> uint8 17 | val lognot : uint8 -> uint8 18 | val shift_left : uint8 -> int -> uint8 19 | val shift_right : uint8 -> int -> uint8 20 | val of_int : int -> uint8 21 | val to_int : uint8 -> int 22 | val of_float : float -> uint8 23 | val to_float : uint8 -> float 24 | val of_int32 : int32 -> uint8 25 | val to_int32 : uint8 -> int32 26 | val of_string : string -> uint8 27 | val to_string : uint8 -> string 28 | val to_string_bin : uint8 -> string 29 | val to_string_oct : uint8 -> string 30 | val to_string_hex : uint8 -> string 31 | val bits_of_float : float -> uint8 32 | [@@ocaml.alert deprecated] 33 | val float_of_bits : uint8 -> float 34 | [@@ocaml.alert deprecated] 35 | val compare : t -> t -> int 36 | val printer : Format.formatter -> uint8 -> unit 37 | val printer_bin : Format.formatter -> uint8 -> unit 38 | val printer_oct : Format.formatter -> uint8 -> unit 39 | val printer_hex : Format.formatter -> uint8 -> unit 40 | -------------------------------------------------------------------------------- /spec/dune: -------------------------------------------------------------------------------- 1 | (executable 2 | (name test) 3 | (libraries uint crowbar core) 4 | (modules test) 5 | ) 6 | -------------------------------------------------------------------------------- /spec/test.ml: -------------------------------------------------------------------------------- 1 | open Crowbar 2 | open Core 3 | 4 | module type Testable = sig 5 | type t 6 | val to_int : t -> int 7 | val of_int : int -> t 8 | val to_int32 : t -> int32 9 | val of_int32 : int32 -> t 10 | val to_string: t -> string 11 | val logand: t -> t -> t 12 | val logor: t -> t -> t 13 | val logxor: t -> t -> t 14 | val lognot: t -> t 15 | val shift_left : t -> int -> t 16 | val shift_right: t -> int -> t 17 | val to_float: t -> float 18 | val of_float: float -> t 19 | val max_int : t 20 | end 21 | 22 | module type TaggedTestable = sig 23 | include Testable 24 | val name : string 25 | end 26 | 27 | module Test (T: TaggedTestable) (E : Testable) = struct 28 | let valid x = 29 | let upper = T.max_int |> T.to_int in 30 | let lower = 0 in 31 | x < upper && x > lower 32 | let validi x = 33 | Int32.( 34 | let upper = T.max_int |> T.to_int32 in 35 | let lower = zero in 36 | x < upper && x > lower 37 | ) 38 | 39 | let add_tests () = 40 | add_test ~name:(T.name ^ "_int_conv") [int] 41 | (fun i -> 42 | guard(valid i); 43 | check_eq i (i |> T.of_int |> T.to_int) 44 | ); 45 | add_test ~name:(T.name ^ "_int32_conv") [int32] 46 | (fun i -> 47 | guard(validi i); 48 | check_eq i (i |> T.of_int32 |> T.to_int32) 49 | ); 50 | add_test ~name:(T.name ^ "_string_conv") [int32] 51 | (fun i -> 52 | guard(validi i); 53 | check_eq (Int32.to_string i) (i |> T.of_int32 |> T.to_string) 54 | ); 55 | add_test ~name:(T.name ^ "_land") [int; int] 56 | (fun i j -> 57 | guard(valid i); 58 | guard(valid j); 59 | check_eq 60 | (T.logand (T.of_int i) (T.of_int j) |> T.to_int ) 61 | (E.logand (E.of_int i) (E.of_int j) |> E.to_int ) 62 | ); 63 | add_test ~name:(T.name ^ "_lor") [int; int] 64 | (fun i j -> 65 | guard(valid i); 66 | guard(valid j); 67 | check_eq 68 | (T.logor (T.of_int i) (T.of_int j) |> T.to_int ) 69 | (E.logor (E.of_int i) (E.of_int j) |> E.to_int ) 70 | ); 71 | add_test ~name:(T.name ^ "_lxor") [int; int] 72 | (fun i j -> 73 | guard(valid i); 74 | guard(valid j); 75 | check_eq 76 | (T.logxor (T.of_int i) (T.of_int j) |> T.to_int ) 77 | (E.logxor (E.of_int i) (E.of_int j) |> E.to_int ) 78 | ); 79 | add_test ~name:(T.name ^ "_lnot") [int32] 80 | (fun i -> 81 | guard(validi i); 82 | check_eq 83 | (i |> T.of_int32 |> T.lognot |> T.to_int32) 84 | (i |> E.of_int32 |> E.lognot |> E.to_int32) 85 | ); 86 | add_test ~name:(T.name ^ "_lsl") [int32; range 31] 87 | (fun i j -> 88 | guard(validi i); 89 | guard(valid j); 90 | check_eq 91 | (i |> T.of_int32 |> (fun i -> T.shift_left i j) |> T.to_int32) 92 | (i |> E.of_int32 |> (fun i -> E.shift_left i j) |> E.to_int32) 93 | ); 94 | add_test ~name:(T.name ^ "_lsr") [int32; range 31] 95 | (fun i j -> 96 | guard(validi i); 97 | guard(valid j); 98 | check_eq 99 | (i |> T.of_int32 |> (fun i -> T.shift_right i j) |> T.to_int32) 100 | (i |> E.of_int32 |> (fun i -> E.shift_right i j) |> E.to_int32) 101 | ); 102 | add_test ~name:(T.name ^ "_float") [Crowbar.float] 103 | (fun i -> 104 | check_eq 105 | (i |> T.of_float |> T.to_float) 106 | (i |> E.of_float |> E.to_float) 107 | ) 108 | end 109 | 110 | module T_Uint8 = Test( 111 | struct 112 | include Uint8 113 | let name = "uint8" 114 | end 115 | ) (Stdint.Uint8) 116 | let () = T_Uint8.add_tests () 117 | 118 | module T_Uint16 = Test( 119 | struct 120 | include Uint16 121 | let name = "uint16" 122 | end 123 | ) (Stdint.Uint16) 124 | let () = T_Uint16.add_tests () 125 | 126 | module T_Uint32 = Test( 127 | struct 128 | include Uint32 129 | let name = "uint32" 130 | end 131 | ) (Stdint.Uint32) 132 | let () = T_Uint32.add_tests () 133 | 134 | module T_Uint64 = Test( 135 | struct 136 | include Uint64 137 | let name = "uint64" 138 | end 139 | ) (Stdint.Uint64) 140 | let () = T_Uint64.add_tests () 141 | 142 | module T_Uint128 = Test( 143 | struct 144 | include Uint128 145 | let name = "uint128" 146 | end 147 | ) (Stdint.Uint128) 148 | let () = T_Uint128.add_tests () 149 | -------------------------------------------------------------------------------- /uint.opam: -------------------------------------------------------------------------------- 1 | opam-version: "2.0" 2 | name: "uint" 3 | version: "2.0.1" 4 | maintainer: "Andre Nathan " 5 | authors: [ 6 | "Andre Nathan " 7 | "Jeff Shaw " 8 | ] 9 | license: "MIT" 10 | homepage: "https://github.com/andrenth/ocaml-uint" 11 | dev-repo: "git+https://github.com/andrenth/ocaml-uint.git" 12 | bug-reports: "https://github.com/andrenth/ocaml-uint/issues" 13 | synopsis: "Deprecated: An unsigned integer library" 14 | build: [ 15 | ["dune" "build" "-p" name "-j" jobs] 16 | ["dune" "build" "@doc" "-p" name ] {with-doc} 17 | ] 18 | depends: [ 19 | "dune" {>= "1.11"} 20 | "ocamlfind" {>= "1.5"} 21 | "ocaml" {>= "4.07.0"} 22 | "stdint" {>= "0.5.0"} 23 | ] 24 | --------------------------------------------------------------------------------