Source file array_maker.ml

(* This file provides a generic way to build high-level module on *)
(* array like structures                                          *)

module type ArrayLike = sig
  type elem

  type t

  val array_get : t -> int -> elem

  val array_set : t -> int -> elem -> unit

  val array_length : t -> int

  val make : elem -> int -> t

  val empty : t
end

module Make (A : ArrayLike) = struct
  let array_fold f a arr =
    let size = A.array_length arr in
    let rec aux accu idx =
      if idx >= size then accu else aux (f accu (A.array_get arr idx)) (idx + 1)
    in
    aux a 0

  let array_iter f arr = array_fold (fun _ a -> f a) () arr

  let array_iteri f arr =
    let i = ref 0 in
    array_iter (f !i) arr

  let array_for_all pred arr =
    try
      array_iter (fun a -> if pred a |> not then raise Exit) arr ;
      true
    with Exit -> false

  let array_exists pred arr =
    try
      array_iter (fun a -> if pred a then raise Exit) arr ;
      true
    with Exit -> false

  let array_to_list arr =
    let rec aux accu idx =
      if idx < 0 then accu else aux (A.array_get arr idx :: accu) (idx - 1)
    in
    aux [] (A.array_length arr - 1)

  let array_of_list = function
    | [] -> A.empty
    | h :: _ as l ->
        let size = List.length l in
        let ear = A.make h size in
        List.iteri (A.array_set ear) l ;
        ear
end

module LinconsExt = Make (struct
  open Apron
  include Lincons1

  type elem = t

  type t = earray

  let make elem = array_make elem.env

  let empty = array_make (Environment.make [||] [||]) 0
end)

module TconsExt = Make (struct
  open Apron
  include Tcons1

  type elem = t

  type t = earray

  let make elem = array_make elem.env

  let empty = array_make (Environment.make [||] [||]) 0
end)

module GeneratorExt = Make (struct
  open Apron
  include Generator1

  type elem = t

  type t = earray

  let make elem = array_make elem.env

  let empty = array_make (Environment.make [||] [||]) 0
end)