sig
  module Make :
    functor
      (Value : Abstract_value.External) (Eva : sig
                                                 type state
                                                 type value = Value.t
                                                 type origin
                                                 type loc
                                                 module Valuation :
                                                   sig
                                                     type t
                                                     type value = value
                                                     type origin = origin
                                                     type loc = loc
                                                     val empty : t
                                                     val find :
                                                       t ->
                                                       Cil_types.exp ->
                                                       (value, origin)
                                                       Eval.record_val
                                                       Eval.or_top
                                                     val add :
                                                       t ->
                                                       Cil_types.exp ->
                                                       (value, origin)
                                                       Eval.record_val -> 
                                                       t
                                                     val fold :
                                                       (Cil_types.exp ->
                                                        (value, origin)
                                                        Eval.record_val ->
                                                        '-> 'a) ->
                                                       t -> '-> 'a
                                                     val find_loc :
                                                       t ->
                                                       Cil_types.lval ->
                                                       loc Eval.record_loc
                                                       Eval.or_top
                                                     val filter :
                                                       (Cil_types.exp ->
                                                        (value, origin)
                                                        Eval.record_val ->
                                                        bool) ->
                                                       (Cil_types.lval ->
                                                        loc Eval.record_loc ->
                                                        bool) ->
                                                       t -> t
                                                   end
                                                 val evaluate :
                                                   ?valuation:Valuation.t ->
                                                   ?indeterminate:bool ->
                                                   ?reduction:bool ->
                                                   state ->
                                                   Cil_types.exp ->
                                                   (Valuation.t * value)
                                                   Eval.evaluated
                                                 val lvaluate :
                                                   ?valuation:Valuation.t ->
                                                   for_writing:bool ->
                                                   state ->
                                                   Cil_types.lval ->
                                                   (Valuation.t * loc *
                                                    Cil_types.typ)
                                                   Eval.evaluated
                                                 val reduce :
                                                   ?valuation:Valuation.t ->
                                                   state ->
                                                   Cil_types.exp ->
                                                   bool ->
                                                   Valuation.t Eval.evaluated
                                                 val loc_size :
                                                   loc -> Int_Base.t
                                                 val reinterpret :
                                                   Cil_types.exp ->
                                                   Cil_types.typ ->
                                                   value ->
                                                   value Eval.evaluated
                                                 val do_promotion :
                                                   src_typ:Cil_types.typ ->
                                                   dst_typ:Cil_types.typ ->
                                                   Cil_types.exp ->
                                                   value ->
                                                   value Eval.evaluated
                                                 val split_by_evaluation :
                                                   Cil_types.exp ->
                                                   Integer.t list ->
                                                   state list ->
                                                   (Integer.t * state list *
                                                    bool)
                                                   list * state list
                                                 val check_copy_lval :
                                                   Cil_types.lval * loc ->
                                                   Cil_types.lval * loc ->
                                                   bool Eval.evaluated
                                                 val check_non_overlapping :
                                                   state ->
                                                   Cil_types.lval list ->
                                                   Cil_types.lval list ->
                                                   unit Eval.evaluated
                                                 val eval_function_exp :
                                                   Cil_types.exp ->
                                                   state ->
                                                   (Kernel_function.t *
                                                    Valuation.t)
                                                   list Eval.evaluated
                                               end->
      sig
        val evaluate :
          ?valuation:Eva.Valuation.t ->
          ?indeterminate:bool ->
          ?reduction:bool ->
          Eva.state ->
          Cil_types.exp -> (Eva.Valuation.t * Value.t) Eval.evaluated
      end
end