sig
  type 'a how_to_journalize =
      Journalize of string * 'Type.t
    | Journalization_not_required
    | Journalization_must_not_happen of string
  val register : 'Db.how_to_journalize -> 'Pervasives.ref -> '-> unit
  val register_compute :
    string ->
    Project.Computation.t list ->
    (unit -> unit) Pervasives.ref -> (unit -> unit) -> Project.Computation.t
  val register_guarded_compute :
    string ->
    (unit -> bool) -> (unit -> unit) Pervasives.ref -> (unit -> unit) -> unit
  module Main :
    sig
      val extend : (unit -> unit) -> unit
      val play : (unit -> unit) Pervasives.ref
      val apply : unit -> unit
    end
  module Toplevel : sig val run : ((unit -> unit) -> unit) Pervasives.ref end
  module Semantic_Callgraph :
    sig
      val dump : (unit -> unit) Pervasives.ref
      val topologically_iter_on_functions :
        ((Db_types.kernel_function -> unit) -> unit) Pervasives.ref
    end
  module Value :
    sig
      type state = Relations_type.Model.t
      type t = Cvalue_type.V.t
      exception Aborted
      val self : Project.Computation.t
      val mark_as_computed : unit -> unit
      val compute : (unit -> unit) Pervasives.ref
      val is_computed : unit -> bool
      val degeneration_occurred :
        (Cil_types.kinstr -> Cil_types.lval option -> unit) Pervasives.ref
      val register_builtin :
        (string ->
         (Db.Value.state ->
          (Cil_types.exp * Db.Value.t) list ->
          Cvalue_type.V_Offsetmap.t option * Db.Value.state *
          Locations.Location_Bits.Top_Param.t) ->
         unit)
        Pervasives.ref
      val mem_builtin : (string -> bool) Pervasives.ref
      val fun_set_args : Db.Value.t list -> unit
      val fun_use_default_args : unit -> unit
      val fun_get_args : unit -> Db.Value.t list option
      val globals_set_initial_state : Db.Value.state -> unit
      val globals_use_default_initial_state : unit -> unit
      val globals_state : unit -> Db.Value.state
      val globals_use_supplied_state : unit -> bool
      val get_initial_state : Db_types.kernel_function -> Db.Value.state
      val get_state : Cil_types.kinstr -> Db.Value.state
      val find : Db.Value.state -> Locations.location -> Db.Value.t
      val eval_lval :
        (with_alarms:CilE.warn_mode ->
         Locations.Zone.t option ->
         Db.Value.state ->
         Cil_types.lval -> Locations.Zone.t option * Db.Value.t)
        Pervasives.ref
      val eval_expr :
        (with_alarms:CilE.warn_mode ->
         Db.Value.state -> Cil_types.exp -> Db.Value.t)
        Pervasives.ref
      val eval_expr_with_state :
        (with_alarms:CilE.warn_mode ->
         Db.Value.state -> Cil_types.exp -> Db.Value.state * Db.Value.t)
        Pervasives.ref
      val find_lv_plus :
        (with_alarms:CilE.warn_mode ->
         Relations_type.Model.t ->
         Cil_types.exp -> (Cil_types.lval * Ival.t) list)
        Pervasives.ref
      val expr_to_kernel_function :
        (Cil_types.kinstr ->
         with_alarms:CilE.warn_mode ->
         deps:Locations.Zone.t option ->
         Cil_types.exp -> Locations.Zone.t * Kernel_function.Set.t)
        Pervasives.ref
      val expr_to_kernel_function_state :
        (Db.Value.state ->
         deps:Locations.Zone.t option ->
         Cil_types.exp -> Locations.Zone.t * Kernel_function.Set.t)
        Pervasives.ref
      exception Not_a_call
      val call_to_kernel_function : Cil_types.stmt -> Kernel_function.Set.t
      val valid_behaviors :
        (Db_types.kernel_function ->
         Db.Value.state -> Cil_types.funbehavior list)
        Pervasives.ref
      val is_accessible : Cil_types.kinstr -> bool
      val is_reachable : Db.Value.state -> bool
      val is_reachable_stmt : Cil_types.stmt -> bool
      exception Void_Function
      val find_return_loc : Db_types.kernel_function -> Locations.location
      val is_called : (Db_types.kernel_function -> bool) Pervasives.ref
      val callers :
        (Db_types.kernel_function ->
         (Db_types.kernel_function * Cil_types.stmt list) list)
        Pervasives.ref
      val never_terminates :
        (Db_types.kernel_function -> bool) Pervasives.ref
      val access :
        (Cil_types.kinstr -> Cil_types.lval -> Db.Value.t) Pervasives.ref
      val access_expr :
        (Cil_types.kinstr -> Cil_types.exp -> Db.Value.t) Pervasives.ref
      val access_location :
        (Cil_types.kinstr -> Locations.location -> Db.Value.t) Pervasives.ref
      val access_after :
        (Cil_types.kinstr -> Cil_types.lval -> Db.Value.t) Pervasives.ref
      val access_location_after :
        (Cil_types.kinstr -> Locations.location -> Db.Value.t) Pervasives.ref
      val lval_to_offsetmap_after :
        (Cil_types.kinstr ->
         Cil_types.lval -> Cvalue_type.V_Offsetmap.t option)
        Pervasives.ref
      val lval_to_loc :
        (Cil_types.kinstr ->
         with_alarms:CilE.warn_mode -> Cil_types.lval -> Locations.location)
        Pervasives.ref
      val lval_to_loc_with_deps :
        (Cil_types.kinstr ->
         with_alarms:CilE.warn_mode ->
         deps:Locations.Zone.t ->
         Cil_types.lval -> Locations.Zone.t * Locations.location)
        Pervasives.ref
      val lval_to_loc_with_deps_state :
        (Db.Value.state ->
         deps:Locations.Zone.t ->
         Cil_types.lval -> Locations.Zone.t * Locations.location)
        Pervasives.ref
      val lval_to_loc_state :
        (Db.Value.state -> Cil_types.lval -> Locations.location)
        Pervasives.ref
      val lval_to_offsetmap :
        (Cil_types.kinstr ->
         Cil_types.lval ->
         with_alarms:CilE.warn_mode -> Cvalue_type.V_Offsetmap.t option)
        Pervasives.ref
      val lval_to_zone :
        (Cil_types.kinstr ->
         with_alarms:CilE.warn_mode -> Cil_types.lval -> Locations.Zone.t)
        Pervasives.ref
      val lval_to_zone_state :
        (Db.Value.state -> Cil_types.lval -> Locations.Zone.t) Pervasives.ref
      val assigns_to_zone_inputs_state :
        (Db.Value.state ->
         Cil_types.identified_term Cil_types.assigns list -> Locations.Zone.t)
        Pervasives.ref
      module Record_Value_Callbacks :
        sig
          type param =
              (Db_types.kernel_function * Cil_types.kinstr) list *
              state Cilutil.InstrHashtbl.t
          type result = unit
          val extend : (param -> result) -> unit
          val apply : param -> result
          val is_empty : unit -> bool
          val clear : unit -> unit
          val length : unit -> int
        end
      module Record_Value_Superposition_Callbacks :
        sig
          type param =
              (Db_types.kernel_function * Cil_types.kinstr) list *
              State_set.t Cilutil.InstrHashtbl.t
          type result = unit
          val extend : (param -> result) -> unit
          val apply : param -> result
          val is_empty : unit -> bool
          val clear : unit -> unit
          val length : unit -> int
        end
      module Call_Value_Callbacks :
        sig
          type param =
              state * (Db_types.kernel_function * Cil_types.kinstr) list
          type result = unit
          val extend : (param -> result) -> unit
          val apply : param -> result
          val is_empty : unit -> bool
          val clear : unit -> unit
          val length : unit -> int
        end
      val pretty : Format.formatter -> Db.Value.t -> unit
      val pretty_state_without_null :
        Format.formatter -> Db.Value.state -> unit
      val pretty_state : Format.formatter -> Db.Value.state -> unit
      val display : Format.formatter -> Db_types.kernel_function -> unit
      val display_globals : Format.formatter -> unit -> unit
      val noassert_get_state : Cil_types.kinstr -> Db.Value.state
      val initial_state_only_globals :
        (unit -> Db.Value.state) Pervasives.ref
      val update_table : Cil_types.kinstr -> Db.Value.state -> unit
      val memoize : (Db_types.kernel_function -> unit) Pervasives.ref
      val merge_initial_state :
        Db_types.kernel_function -> Db.Value.state -> unit
    end
  module From :
    sig
      val compute_all : (unit -> unit) Pervasives.ref
      val compute_all_calldeps : (unit -> unit) Pervasives.ref
      val compute : (Db_types.kernel_function -> unit) Pervasives.ref
      val is_computed : (Db_types.kernel_function -> bool) Pervasives.ref
      val get : (Db_types.kernel_function -> Function_Froms.t) Pervasives.ref
      val access :
        (Locations.Zone.t -> Db_types.from_model -> Locations.Zone.t)
        Pervasives.ref
      val find_deps_no_transitivity :
        (Cil_types.kinstr -> Cil_types.exp -> Locations.Zone.t)
        Pervasives.ref
      val self : Project.Computation.t Pervasives.ref
      val pretty :
        (Format.formatter -> Db_types.kernel_function -> unit) Pervasives.ref
      val display : (Format.formatter -> unit) Pervasives.ref
      val update :
        (Locations.location ->
         Locations.Zone.t -> Db_types.from_model -> Db_types.from_model)
        Pervasives.ref
      module Record_From_Callbacks :
        sig
          type param =
              Kernel_function.t Cilutil.Stack.t *
              Lmap_bitwise.From_Model.t Inthash.t
          type result = unit
          val extend : (param -> result) -> unit
          val apply : param -> result
          val is_empty : unit -> bool
          val clear : unit -> unit
          val length : unit -> int
        end
      module Callwise :
        sig
          val iter :
            ((Cil_types.kinstr -> Function_Froms.t -> unit) -> unit)
            Pervasives.ref
          val find : (Cil_types.kinstr -> Function_Froms.t) Pervasives.ref
        end
    end
  module Users :
    sig
      val get :
        (Db_types.kernel_function -> Kernel_function.Set.t) Pervasives.ref
    end
  module Access_path :
    sig
      type t =
          (Locations.Zone.t * Locations.Location_Bits.t) BaseUtils.BaseMap.t
      val compute :
        (Relations_type.Model.t -> BaseUtils.BaseSet.t -> Db.Access_path.t)
        Pervasives.ref
      val filter :
        (Db.Access_path.t -> Locations.Zone.t -> Db.Access_path.t)
        Pervasives.ref
      val pretty :
        (Format.formatter -> Db.Access_path.t -> unit) Pervasives.ref
    end
  module Properties :
    sig
      module Interp :
        sig
          val lval :
            (Db_types.kernel_function ->
             Cil_types.stmt -> string -> Cil_types.term_lval)
            Pervasives.ref
          val expr :
            (Db_types.kernel_function ->
             Cil_types.stmt -> string -> Cil_types.term)
            Pervasives.ref
          val term_lval_to_lval :
            (result:Cil_types.varinfo option ->
             Cil_types.term_lval -> Cil_types.lval)
            Pervasives.ref
          val term_to_lval :
            (result:Cil_types.varinfo option ->
             Cil_types.term -> Cil_types.lval)
            Pervasives.ref
          val term_to_exp :
            (result:Cil_types.varinfo option ->
             Cil_types.term -> Cil_types.exp)
            Pervasives.ref
          val loc_to_exp :
            (result:Cil_types.varinfo option ->
             Cil_types.term -> Cil_types.exp list)
            Pervasives.ref
          val loc_to_lval :
            (result:Cil_types.varinfo option ->
             Cil_types.term -> Cil_types.lval list)
            Pervasives.ref
          val identified_term_zone_to_loc :
            (result:Cil_types.varinfo option ->
             Db.Value.state ->
             Cil_types.identified_term Cil_types.zone -> Locations.location)
            Pervasives.ref
          val loc_to_loc :
            (result:Cil_types.varinfo option ->
             Db.Value.state -> Cil_types.term -> Locations.location)
            Pervasives.ref
          val loc_to_offset :
            (result:Cil_types.varinfo option ->
             Cil_types.term -> Cil_types.offset list)
            Pervasives.ref
          val force_term_to_exp :
            (Cil_types.term -> Cil_types.exp * Cilutil.opaque_term_env)
            Pervasives.ref
          val force_back_exp_to_term :
            (Cilutil.opaque_term_env -> Cil_types.exp -> Cil_types.term)
            Pervasives.ref
          val force_exp_to_term :
            (Cil_types.location -> Cil_types.exp -> Cil_types.term)
            Pervasives.ref
          val force_lval_to_term_lval :
            (Cil_types.location -> Cil_types.lval -> Cil_types.term_lval)
            Pervasives.ref
          val force_term_offset_to_offset :
            (Cil_types.term_offset ->
             Cil_types.offset * Cilutil.opaque_term_env)
            Pervasives.ref
          val force_back_offset_to_term_offset :
            (Cilutil.opaque_term_env ->
             Cil_types.offset -> Cil_types.term_offset)
            Pervasives.ref
          val force_exp_to_predicate :
            (Cil_types.location ->
             Cil_types.exp -> Cil_types.predicate Cil_types.named)
            Pervasives.ref
          val force_exp_to_assertion :
            (Cil_types.location -> Cil_types.exp -> Cil_types.code_annotation)
            Pervasives.ref
          val force_term_lval_to_lval :
            (Cil_types.term_lval -> Cil_types.lval * Cilutil.opaque_term_env)
            Pervasives.ref
          val force_back_lval_to_term_lval :
            (Cilutil.opaque_term_env -> Cil_types.lval -> Cil_types.term_lval)
            Pervasives.ref
          val from_range_to_comprehension :
            (Cil.visitor_behavior -> Project.t -> Cil_types.file -> unit)
            Pervasives.ref
          val range_to_comprehension :
            (Cil_types.term -> Cil_types.term) Pervasives.ref
          val from_comprehension_to_range :
            (Cil.visitor_behavior -> Project.t -> Cil_types.file -> unit)
            Pervasives.ref
          val term_offset_to_offset :
            (result:Cil_types.varinfo option ->
             Cil_types.term_offset -> Cil_types.offset)
            Pervasives.ref
          module To_zone :
            sig
              type t_ctx = {
                state_opt : bool option;
                ki_opt : (Cil_types.stmt * bool) option;
                kf : Kernel_function.t;
              }
              val mk_ctx_func_contrat :
                (Db_types.kernel_function ->
                 state_opt:bool option -> Db.Properties.Interp.To_zone.t_ctx)
                Pervasives.ref
              val mk_ctx_stmt_contrat :
                (Db_types.kernel_function ->
                 Cil_types.stmt ->
                 state_opt:bool option -> Db.Properties.Interp.To_zone.t_ctx)
                Pervasives.ref
              val mk_ctx_stmt_annot :
                (Db_types.kernel_function ->
                 Cil_types.stmt ->
                 before:bool -> Db.Properties.Interp.To_zone.t_ctx)
                Pervasives.ref
              type t = {
                before : bool;
                ki : Cil_types.stmt;
                zone : Locations.Zone.t;
              }
              type t_decl = Cilutil.VarinfoSet.t
              type t_pragmas = {
                ctrl : Cilutil.StmtSet.t;
                stmt : Cilutil.StmtSet.t;
              }
              val from_term :
                (Cil_types.term ->
                 Db.Properties.Interp.To_zone.t_ctx ->
                 Db.Properties.Interp.To_zone.t list *
                 Db.Properties.Interp.To_zone.t_decl)
                Pervasives.ref
              val from_terms :
                (Cil_types.term list ->
                 Db.Properties.Interp.To_zone.t_ctx ->
                 Db.Properties.Interp.To_zone.t list *
                 Db.Properties.Interp.To_zone.t_decl)
                Pervasives.ref
              val from_pred :
                (Cil_types.predicate Cil_types.named ->
                 Db.Properties.Interp.To_zone.t_ctx ->
                 Db.Properties.Interp.To_zone.t list *
                 Db.Properties.Interp.To_zone.t_decl)
                Pervasives.ref
              val from_preds :
                (Cil_types.predicate Cil_types.named list ->
                 Db.Properties.Interp.To_zone.t_ctx ->
                 Db.Properties.Interp.To_zone.t list *
                 Db.Properties.Interp.To_zone.t_decl)
                Pervasives.ref
              val from_zones :
                (Cil_types.identified_term Cil_types.zone list ->
                 Db.Properties.Interp.To_zone.t_ctx ->
                 Db.Properties.Interp.To_zone.t list *
                 Db.Properties.Interp.To_zone.t_decl)
                Pervasives.ref
              val from_zone :
                (Cil_types.identified_term Cil_types.zone ->
                 Db.Properties.Interp.To_zone.t_ctx ->
                 Db.Properties.Interp.To_zone.t list *
                 Db.Properties.Interp.To_zone.t_decl)
                Pervasives.ref
              val from_stmt_annot :
                (Cil_types.code_annotation ->
                 before:bool ->
                 Cil_types.stmt * Db_types.kernel_function ->
                 (Db.Properties.Interp.To_zone.t list *
                  Db.Properties.Interp.To_zone.t_decl) *
                 Db.Properties.Interp.To_zone.t_pragmas)
                Pervasives.ref
              val from_stmt_annots :
                ((Db_types.rooted_code_annotation Db_types.before_after ->
                  bool)
                 option ->
                 Cil_types.stmt * Db_types.kernel_function ->
                 (Db.Properties.Interp.To_zone.t list *
                  Db.Properties.Interp.To_zone.t_decl) *
                 Db.Properties.Interp.To_zone.t_pragmas)
                Pervasives.ref
              val from_func_annots :
                (((Cil_types.stmt -> unit) ->
                  Db_types.kernel_function -> unit) ->
                 (Db_types.rooted_code_annotation Db_types.before_after ->
                  bool)
                 option ->
                 Db_types.kernel_function ->
                 (Db.Properties.Interp.To_zone.t list *
                  Db.Properties.Interp.To_zone.t_decl) *
                 Db.Properties.Interp.To_zone.t_pragmas)
                Pervasives.ref
              val code_annot_filter :
                (Db_types.rooted_code_annotation Db_types.before_after ->
                 ai:bool ->
                 user_assert:bool ->
                 slicing_pragma:bool ->
                 loop_inv:bool -> loop_var:bool -> others:bool -> bool)
                Pervasives.ref
            end
          val code_annot :
            (Db_types.kernel_function ->
             Cil_types.stmt ->
             before:bool -> string -> Cil_types.code_annotation)
            Pervasives.ref
        end
      val synchronize_alarms : Project.Computation.t list -> unit
      val add_alarm :
        Db_types.kernel_function ->
        Cil_types.stmt ->
        Project.Computation.t list ->
        Alarms.t -> Cil_types.code_annotation -> unit
      val add_assert :
        Db_types.kernel_function ->
        Cil_types.stmt ->
        Project.Computation.t list -> before:bool -> string -> unit
    end
  module Syntactic_Callgraph :
    sig val dump : (unit -> unit) Pervasives.ref end
  module Postdominators :
    sig
      val compute : (Db_types.kernel_function -> unit) Pervasives.ref
      exception Top
      val stmt_postdominators :
        (Db_types.kernel_function -> Cil_types.stmt -> Cilutil.StmtSet.t)
        Pervasives.ref
      val is_postdominator :
        (Db_types.kernel_function ->
         opening:Cil_types.stmt -> closing:Cil_types.stmt -> bool)
        Pervasives.ref
      val display : (unit -> unit) Pervasives.ref
      val print_dot :
        (string -> Db_types.kernel_function -> unit) Pervasives.ref
    end
  module Dominators :
    sig
      val compute : (Db_types.kernel_function -> unit) Pervasives.ref
      exception Top
      val stmt_dominators :
        (Db_types.kernel_function -> Cil_types.stmt -> Cilutil.StmtSet.t)
        Pervasives.ref
      val is_dominator :
        (Db_types.kernel_function ->
         opening:Cil_types.stmt -> closing:Cil_types.stmt -> bool)
        Pervasives.ref
      val display : (unit -> unit) Pervasives.ref
      val print_dot :
        (string -> Db_types.kernel_function -> unit) Pervasives.ref
    end
  module RteGen :
    sig
      val annotate_kf : (Db_types.kernel_function -> unit) Pervasives.ref
      val self : Project.Computation.t Pervasives.ref
    end
  module Constant_Propagation :
    sig
      val get :
        (Cilutil.StringSet.t -> cast_intro:bool -> Project.t) Pervasives.ref
      val compute : (unit -> unit) Pervasives.ref
    end
  module Miel :
    sig
      val extract_all : (unit -> unit) Pervasives.ref
      val run_gui : (unit -> unit) Pervasives.ref
      val gui_present : bool Pervasives.ref
    end
  module Impact :
    sig
      val compute_pragmas : (unit -> unit) Pervasives.ref
      val from_stmt : (Cil_types.stmt -> Cil_types.stmt list) Pervasives.ref
      val slice : (Cil_types.stmt list -> unit) Pervasives.ref
    end
  module Security :
    sig
      val run_whole_analysis : (unit -> unit) Pervasives.ref
      val run_ai_analysis : (unit -> unit) Pervasives.ref
      val run_slicing_analysis : (unit -> Project.t) Pervasives.ref
      val self : Project.Computation.t Pervasives.ref
    end
  module Pdg :
    sig
      exception Bottom
      exception Top
      exception NotFound
      type t = PdgTypes.Pdg.t
      type t_node = PdgTypes.Node.t
      type t_node_key = PdgIndex.Key.t
      type t_nodes_and_undef =
          (Db.Pdg.t_node * Locations.Zone.t option) list *
          Locations.Zone.t option
      val self : Project.Computation.t Pervasives.ref
      val get : (Db_types.kernel_function -> Db.Pdg.t) Pervasives.ref
      val node_key : (Db.Pdg.t_node -> Db.Pdg.t_node_key) Pervasives.ref
      val from_same_fun : Db.Pdg.t -> Db.Pdg.t -> bool
      val find_decl_var_node :
        (Db.Pdg.t -> Cil_types.varinfo -> Db.Pdg.t_node) Pervasives.ref
      val find_ret_output_node : (Db.Pdg.t -> Db.Pdg.t_node) Pervasives.ref
      val find_output_nodes :
        (Db.Pdg.t -> PdgIndex.Signature.t_out_key -> Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_input_node : (Db.Pdg.t -> int -> Db.Pdg.t_node) Pervasives.ref
      val find_all_inputs_nodes :
        (Db.Pdg.t -> Db.Pdg.t_node list) Pervasives.ref
      val find_stmt_node :
        (Db.Pdg.t -> Cil_types.stmt -> Db.Pdg.t_node) Pervasives.ref
      val find_simple_stmt_nodes :
        (Db.Pdg.t -> Cil_types.stmt -> Db.Pdg.t_node list) Pervasives.ref
      val find_stmt_and_blocks_nodes :
        (Db.Pdg.t -> Cil_types.stmt -> Db.Pdg.t_node list) Pervasives.ref
      val find_top_input_node : (Db.Pdg.t -> Db.Pdg.t_node) Pervasives.ref
      val find_entry_point_node : (Db.Pdg.t -> Db.Pdg.t_node) Pervasives.ref
      val find_location_nodes_at_stmt :
        (Db.Pdg.t ->
         Cil_types.stmt ->
         before:bool -> Locations.Zone.t -> Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_location_nodes_at_end :
        (Db.Pdg.t -> Locations.Zone.t -> Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_location_nodes_at_begin :
        (Db.Pdg.t -> Locations.Zone.t -> Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_call_stmts :
        (Db_types.kernel_function ->
         caller:Db_types.kernel_function -> Cil_types.stmt list)
        Pervasives.ref
      val find_call_ctrl_node :
        (Db.Pdg.t -> Cil_types.stmt -> Db.Pdg.t_node) Pervasives.ref
      val find_call_input_node :
        (Db.Pdg.t -> Cil_types.stmt -> int -> Db.Pdg.t_node) Pervasives.ref
      val find_call_output_node :
        (Db.Pdg.t -> Cil_types.stmt -> Db.Pdg.t_node) Pervasives.ref
      val find_code_annot_nodes :
        (Db.Pdg.t ->
         before:bool ->
         Cil_types.stmt ->
         Cil_types.code_annotation ->
         Db.Pdg.t_node list * Db.Pdg.t_node list * Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_fun_precond_nodes :
        (Db.Pdg.t ->
         Cil_types.predicate -> Db.Pdg.t_node list * Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_fun_postcond_nodes :
        (Db.Pdg.t ->
         Cil_types.predicate -> Db.Pdg.t_node list * Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_fun_variant_nodes :
        (Db.Pdg.t ->
         Cil_types.term -> Db.Pdg.t_node list * Db.Pdg.t_nodes_and_undef)
        Pervasives.ref
      val find_call_out_nodes_to_select :
        (Db.Pdg.t ->
         Db.Pdg.t_node list ->
         Db.Pdg.t -> Cil_types.stmt -> Db.Pdg.t_node list)
        Pervasives.ref
      val find_in_nodes_to_select_for_this_call :
        (Db.Pdg.t ->
         Db.Pdg.t_node list ->
         Cil_types.stmt -> Db.Pdg.t -> Db.Pdg.t_node list)
        Pervasives.ref
      val direct_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val direct_ctrl_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val direct_data_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val direct_addr_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val all_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node list -> Db.Pdg.t_node list) Pervasives.ref
      val all_data_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node list -> Db.Pdg.t_node list) Pervasives.ref
      val all_ctrl_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node list -> Db.Pdg.t_node list) Pervasives.ref
      val all_addr_dpds :
        (Db.Pdg.t -> Db.Pdg.t_node list -> Db.Pdg.t_node list) Pervasives.ref
      val direct_uses :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val direct_ctrl_uses :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val direct_data_uses :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val direct_addr_uses :
        (Db.Pdg.t -> Db.Pdg.t_node -> Db.Pdg.t_node list) Pervasives.ref
      val all_uses :
        (Db.Pdg.t -> Db.Pdg.t_node list -> Db.Pdg.t_node list) Pervasives.ref
      val custom_related_nodes :
        ((Db.Pdg.t_node -> Db.Pdg.t_node list) ->
         Db.Pdg.t_node list -> Db.Pdg.t_node list)
        Pervasives.ref
      val iter_nodes :
        ((Db.Pdg.t_node -> unit) -> Db.Pdg.t -> unit) Pervasives.ref
      val extract : (Db.Pdg.t -> string -> unit) Pervasives.ref
      val pretty_node :
        (bool -> Format.formatter -> Db.Pdg.t_node -> unit) Pervasives.ref
      val pretty_key :
        (Format.formatter -> Db.Pdg.t_node_key -> unit) Pervasives.ref
      val pretty :
        (?bw:bool -> Format.formatter -> Db.Pdg.t -> unit) Pervasives.ref
      module F_FctMarks :
        functor (M : PdgMarks.T_Mark->
          sig
            type t_mark = M.t
            type t_call_info = M.t_call_info
            type t_idx = (t_mark, t_call_info) PdgIndex.FctIndex.t
            type t = PdgTypes.Pdg.t * t_idx
            val create : PdgTypes.Pdg.t -> t
            val get_idx : t -> t_idx
            type t_mark_info_inter = t_mark PdgMarks.t_info_inter
            val empty_to_prop : t_mark_info_inter
            val mark_and_propagate :
              t ->
              ?to_prop:t_mark_info_inter ->
              t_mark PdgMarks.t_select -> t_mark_info_inter
          end
    end
  module Scope :
    sig
      val get_data_scope_at_stmt :
        (Db_types.kernel_function ->
         Cil_types.stmt ->
         Cil_types.lval ->
         Cilutil.StmtSet.t * (Cilutil.StmtSet.t * Cilutil.StmtSet.t))
        Pervasives.ref
      val get_prop_scope_at_stmt :
        (Db_types.kernel_function ->
         Cil_types.stmt ->
         Cil_types.code_annotation ->
         Cilutil.StmtSet.t * Cil_types.code_annotation list)
        Pervasives.ref
      val check_asserts :
        (unit -> Cil_types.code_annotation list) Pervasives.ref
      val rm_asserts : (unit -> unit) Pervasives.ref
      val get_defs :
        (Db_types.kernel_function ->
         Cil_types.stmt ->
         Cil_types.lval ->
         (Cilutil.StmtSet.t * Locations.Zone.t option) option)
        Pervasives.ref
      type t_zones = Locations.Zone.t Inthash.t
      val build_zones :
        (Db_types.kernel_function ->
         Cil_types.stmt ->
         Cil_types.lval -> Cilutil.StmtSet.t * Db.Scope.t_zones)
        Pervasives.ref
      val pretty_zones :
        (Format.formatter -> Db.Scope.t_zones -> unit) Pervasives.ref
      val get_zones :
        (Db.Scope.t_zones -> Cil_types.stmt -> Locations.Zone.t)
        Pervasives.ref
    end
  module Sparecode :
    sig
      val get :
        (select_annot:bool -> select_slice_pragma:bool -> Project.t)
        Pervasives.ref
      val rm_unused_globals :
        (?project:Project.t -> unit -> Project.t) Pervasives.ref
    end
  module Occurrence :
    sig
      type t = (Cil_types.kinstr * Cil_types.lval) list
      val get : (Cil_types.varinfo -> Db.Occurrence.t) Pervasives.ref
      val get_last_result :
        (unit -> (Db.Occurrence.t * Cil_types.varinfo) option) Pervasives.ref
      val print_all : (unit -> unit) Pervasives.ref
      val self : Project.Computation.t Pervasives.ref
    end
  module Slicing :
    sig
      exception No_Project
      exception Existing_Project
      val self : Project.Computation.t Pervasives.ref
      val set_modes :
        (?calls:int ->
         ?callers:bool ->
         ?sliceUndef:bool ->
         ?keepAnnotations:bool -> ?print:bool -> unit -> unit)
        Pervasives.ref
      module Project :
        sig
          type t = SlicingTypes.sl_project
          val dyn_t : Db.Slicing.Project.t Type.t
          val mk_project : (string -> Db.Slicing.Project.t) Pervasives.ref
          val from_unique_name :
            (string -> Db.Slicing.Project.t) Pervasives.ref
          val get_all : (unit -> Db.Slicing.Project.t list) Pervasives.ref
          val set_project :
            (Db.Slicing.Project.t option -> unit) Pervasives.ref
          val get_project :
            (unit -> Db.Slicing.Project.t option) Pervasives.ref
          val get_name : (Db.Slicing.Project.t -> string) Pervasives.ref
          val is_called :
            (Db.Slicing.Project.t -> Db_types.kernel_function -> bool)
            Pervasives.ref
          val has_persistent_selection :
            (Db.Slicing.Project.t -> Db_types.kernel_function -> bool)
            Pervasives.ref
          val change_slicing_level :
            (Db.Slicing.Project.t -> Db_types.kernel_function -> int -> unit)
            Pervasives.ref
          val default_slice_names :
            (Db_types.kernel_function -> bool -> int -> string)
            Pervasives.ref
          val extract :
            (string ->
             ?f_slice_names:(Db_types.kernel_function ->
                             bool -> int -> string) ->
             Db.Slicing.Project.t -> Project.t)
            Pervasives.ref
          val print_extracted_project :
            (?fmt:Format.formatter -> extracted_prj:Project.t -> unit)
            Pervasives.ref
          val print_dot :
            (filename:string -> title:string -> Db.Slicing.Project.t -> unit)
            Pervasives.ref
          val pretty :
            (Format.formatter -> Db.Slicing.Project.t -> unit) Pervasives.ref
          val is_directly_called_internal :
            (Db.Slicing.Project.t -> Db_types.kernel_function -> bool)
            Pervasives.ref
        end
      module Mark :
        sig
          type t = SlicingTypes.sl_mark
          val dyn_t : Db.Slicing.Mark.t Type.t
          val make :
            (data:bool -> addr:bool -> ctrl:bool -> Db.Slicing.Mark.t)
            Pervasives.ref
          val compare :
            (Db.Slicing.Mark.t -> Db.Slicing.Mark.t -> int) Pervasives.ref
          val is_bottom : (Db.Slicing.Mark.t -> bool) Pervasives.ref
          val is_spare : (Db.Slicing.Mark.t -> bool) Pervasives.ref
          val is_data : (Db.Slicing.Mark.t -> bool) Pervasives.ref
          val is_ctrl : (Db.Slicing.Mark.t -> bool) Pervasives.ref
          val is_addr : (Db.Slicing.Mark.t -> bool) Pervasives.ref
          val get_from_src_func :
            (Db.Slicing.Project.t ->
             Db_types.kernel_function -> Db.Slicing.Mark.t)
            Pervasives.ref
          val pretty :
            (Format.formatter -> Db.Slicing.Mark.t -> unit) Pervasives.ref
        end
      module Select :
        sig
          type t = SlicingTypes.sl_select
          val dyn_t : Db.Slicing.Select.t Type.t
          type t_set = SlicingTypes.sl_selects
          val dyn_t_set : Db.Slicing.Select.t_set Type.t
          val empty_selects : Db.Slicing.Select.t_set
          val select_stmt :
            (Db.Slicing.Select.t_set ->
             spare:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_ctrl :
            (Db.Slicing.Select.t_set ->
             spare:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_lval_rw :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             rd:Cilutil.StringSet.t ->
             wr:Cilutil.StringSet.t ->
             Cil_types.stmt ->
             scope:Cil_types.stmt ->
             eval:Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_lval :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Cilutil.StringSet.t ->
             before:bool ->
             Cil_types.stmt ->
             scope:Cil_types.stmt ->
             eval:Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_zone :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Locations.Zone.t ->
             before:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_term :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Cil_types.term ->
             before:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_pred :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Cil_types.predicate Cil_types.named ->
             before:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_annot :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             spare:bool ->
             Cil_types.code_annotation ->
             before:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_stmt_annots :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             spare:bool ->
             ai:bool ->
             user_assert:bool ->
             slicing_pragma:bool ->
             loop_inv:bool ->
             loop_var:bool ->
             Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_lval_rw :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             rd:Cilutil.StringSet.t ->
             wr:Cilutil.StringSet.t ->
             scope:Cil_types.stmt ->
             eval:Cil_types.stmt ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_lval :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Cilutil.StringSet.t ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_zone :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Locations.Zone.t ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_return :
            (Db.Slicing.Select.t_set ->
             spare:bool ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_calls_to :
            (Db.Slicing.Select.t_set ->
             spare:bool ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_calls_into :
            (Db.Slicing.Select.t_set ->
             spare:bool ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val select_func_annots :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             spare:bool ->
             ai:bool ->
             user_assert:bool ->
             slicing_pragma:bool ->
             loop_inv:bool ->
             loop_var:bool ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val pretty :
            (Format.formatter -> Db.Slicing.Select.t -> unit) Pervasives.ref
          val get_function :
            (Db.Slicing.Select.t -> Db_types.kernel_function) Pervasives.ref
          val merge_internal :
            (Db.Slicing.Select.t ->
             Db.Slicing.Select.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val add_to_selects_internal :
            (Db.Slicing.Select.t ->
             Db.Slicing.Select.t_set -> Db.Slicing.Select.t_set)
            Pervasives.ref
          val iter_selects_internal :
            ((Db.Slicing.Select.t -> unit) -> Db.Slicing.Select.t_set -> unit)
            Pervasives.ref
          val fold_selects_internal :
            ('-> Db.Slicing.Select.t -> 'a) ->
            '-> Db.Slicing.Select.t_set -> 'a
          val select_stmt_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Cil_types.stmt -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_min_call_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Cil_types.stmt -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_stmt_zone_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Cil_types.stmt ->
             before:bool ->
             Locations.Zone.t -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_zone_at_entry_point_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Locations.Zone.t -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_zone_at_end_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Locations.Zone.t -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_modified_output_zone_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Locations.Zone.t -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_stmt_ctrl_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Cil_types.stmt -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_pdg_nodes_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Db.Pdg.t_node list -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_entry_point_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_return_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_decl_var_internal :
            (Db_types.kernel_function ->
             ?select:Db.Slicing.Select.t ->
             Cil_types.varinfo -> Db.Slicing.Mark.t -> Db.Slicing.Select.t)
            Pervasives.ref
          val select_pdg_nodes :
            (Db.Slicing.Select.t_set ->
             Db.Slicing.Mark.t ->
             Db.Pdg.t_node list ->
             Db_types.kernel_function -> Db.Slicing.Select.t_set)
            Pervasives.ref
        end
      module Slice :
        sig
          type t = SlicingTypes.sl_fct_slice
          val dyn_t : Db.Slicing.Slice.t Type.t
          val create :
            (Db.Slicing.Project.t ->
             Db_types.kernel_function -> Db.Slicing.Slice.t)
            Pervasives.ref
          val remove :
            (Db.Slicing.Project.t -> Db.Slicing.Slice.t -> unit)
            Pervasives.ref
          val remove_uncalled : (Db.Slicing.Project.t -> unit) Pervasives.ref
          val get_all :
            (Db.Slicing.Project.t ->
             Db_types.kernel_function -> Db.Slicing.Slice.t list)
            Pervasives.ref
          val get_function :
            (Db.Slicing.Slice.t -> Db_types.kernel_function) Pervasives.ref
          val get_callers :
            (Db.Slicing.Slice.t -> Db.Slicing.Slice.t list) Pervasives.ref
          val get_called_slice :
            (Db.Slicing.Slice.t ->
             Cil_types.stmt -> Db.Slicing.Slice.t option)
            Pervasives.ref
          val get_called_funcs :
            (Db.Slicing.Slice.t ->
             Cil_types.stmt -> Db_types.kernel_function list)
            Pervasives.ref
          val get_mark_from_stmt :
            (Db.Slicing.Slice.t -> Cil_types.stmt -> Db.Slicing.Mark.t)
            Pervasives.ref
          val get_mark_from_label :
            (Db.Slicing.Slice.t ->
             Cil_types.stmt -> Cil_types.label -> Db.Slicing.Mark.t)
            Pervasives.ref
          val get_mark_from_local_var :
            (Db.Slicing.Slice.t -> Cil_types.varinfo -> Db.Slicing.Mark.t)
            Pervasives.ref
          val get_mark_from_formal :
            (Db.Slicing.Slice.t -> Cil_types.varinfo -> Db.Slicing.Mark.t)
            Pervasives.ref
          val get_user_mark_from_inputs :
            (Db.Slicing.Slice.t -> Db.Slicing.Mark.t) Pervasives.ref
          val get_num_id : (Db.Slicing.Slice.t -> int) Pervasives.ref
          val from_num_id :
            (Db.Slicing.Project.t ->
             Db_types.kernel_function -> int -> Db.Slicing.Slice.t)
            Pervasives.ref
          val pretty :
            (Format.formatter -> Db.Slicing.Slice.t -> unit) Pervasives.ref
        end
      module Request :
        sig
          val apply_all :
            (Db.Slicing.Project.t -> propagate_to_callers:bool -> unit)
            Pervasives.ref
          val add_selection :
            (Db.Slicing.Project.t -> Db.Slicing.Select.t_set -> unit)
            Pervasives.ref
          val add_persistent_selection :
            (Db.Slicing.Project.t -> Db.Slicing.Select.t_set -> unit)
            Pervasives.ref
          val add_persistent_cmdline :
            (Db.Slicing.Project.t -> unit) Pervasives.ref
          val is_already_selected_internal :
            (Db.Slicing.Slice.t -> Db.Slicing.Select.t -> bool)
            Pervasives.ref
          val add_slice_selection_internal :
            (Db.Slicing.Project.t ->
             Db.Slicing.Slice.t -> Db.Slicing.Select.t -> unit)
            Pervasives.ref
          val add_selection_internal :
            (Db.Slicing.Project.t -> Db.Slicing.Select.t -> unit)
            Pervasives.ref
          val add_call_slice :
            (Db.Slicing.Project.t ->
             caller:Db.Slicing.Slice.t -> to_call:Db.Slicing.Slice.t -> unit)
            Pervasives.ref
          val add_call_fun :
            (Db.Slicing.Project.t ->
             caller:Db.Slicing.Slice.t ->
             to_call:Db_types.kernel_function -> unit)
            Pervasives.ref
          val add_call_min_fun :
            (Db.Slicing.Project.t ->
             caller:Db.Slicing.Slice.t ->
             to_call:Db_types.kernel_function -> unit)
            Pervasives.ref
          val apply_all_internal :
            (Db.Slicing.Project.t -> unit) Pervasives.ref
          val apply_next_internal :
            (Db.Slicing.Project.t -> unit) Pervasives.ref
          val merge_slices :
            (Db.Slicing.Project.t ->
             Db.Slicing.Slice.t ->
             Db.Slicing.Slice.t -> replace:bool -> Db.Slicing.Slice.t)
            Pervasives.ref
          val copy_slice :
            (Db.Slicing.Project.t -> Db.Slicing.Slice.t -> Db.Slicing.Slice.t)
            Pervasives.ref
          val split_slice :
            (Db.Slicing.Project.t ->
             Db.Slicing.Slice.t -> Db.Slicing.Slice.t list)
            Pervasives.ref
          val propagate_user_marks :
            (Db.Slicing.Project.t -> unit) Pervasives.ref
          val pretty :
            (Format.formatter -> Db.Slicing.Project.t -> unit) Pervasives.ref
        end
    end
  module type INOUT =
    sig
      type t
      val self_internal : Project.Computation.t Pervasives.ref
      val self_external : Project.Computation.t Pervasives.ref
      val compute : (Db_types.kernel_function -> unit) Pervasives.ref
      val get_internal :
        (Db_types.kernel_function -> Db.INOUT.t) Pervasives.ref
      val get_external :
        (Db_types.kernel_function -> Db.INOUT.t) Pervasives.ref
      val statement : (Cil_types.stmt -> Db.INOUT.t) Pervasives.ref
      val kinstr : Cil_types.kinstr -> Db.INOUT.t option
      val display :
        (Format.formatter -> Db_types.kernel_function -> unit) Pervasives.ref
      val pretty : Format.formatter -> Db.INOUT.t -> unit
    end
  module Inputs :
    sig
      type t = Locations.Zone.t
      val self_internal : Project.Computation.t ref
      val self_external : Project.Computation.t ref
      val compute : (Db_types.kernel_function -> unit) ref
      val get_internal : (Db_types.kernel_function -> t) ref
      val get_external : (Db_types.kernel_function -> t) ref
      val statement : (Cil_types.stmt -> t) ref
      val kinstr : Cil_types.kinstr -> t option
      val display :
        (Format.formatter -> Db_types.kernel_function -> unit) ref
      val pretty : Format.formatter -> t -> unit
      val expr : (Cil_types.stmt -> Cil_types.exp -> t) Pervasives.ref
      val self_with_formals : Project.Computation.t Pervasives.ref
      val get_with_formals : (Db_types.kernel_function -> t) Pervasives.ref
      val display_with_formals :
        (Format.formatter -> Db_types.kernel_function -> unit) Pervasives.ref
    end
  module Outputs :
    sig
      type t = Locations.Zone.t
      val self_internal : Project.Computation.t ref
      val self_external : Project.Computation.t ref
      val compute : (Db_types.kernel_function -> unit) ref
      val get_internal : (Db_types.kernel_function -> t) ref
      val get_external : (Db_types.kernel_function -> t) ref
      val statement : (Cil_types.stmt -> t) ref
      val kinstr : Cil_types.kinstr -> t option
      val display :
        (Format.formatter -> Db_types.kernel_function -> unit) ref
      val pretty : Format.formatter -> t -> unit
      val display_external :
        (Format.formatter -> Db_types.kernel_function -> unit) Pervasives.ref
    end
  module InOutContext :
    sig
      type t = Inout_type.t
      val self_internal : Project.Computation.t ref
      val self_external : Project.Computation.t ref
      val compute : (Db_types.kernel_function -> unit) ref
      val get_internal : (Db_types.kernel_function -> t) ref
      val get_external : (Db_types.kernel_function -> t) ref
      val statement : (Cil_types.stmt -> t) ref
      val kinstr : Cil_types.kinstr -> t option
      val display :
        (Format.formatter -> Db_types.kernel_function -> unit) ref
      val pretty : Format.formatter -> t -> unit
    end
  module Metrics :
    sig
      type t = {
        sloc : int;
        call_statements : int;
        goto_statements : int;
        assign_statements : int;
        if_statements : int;
        loop_statements : int;
        mem_access : int;
        functions_without_source : int Cilutil.VarinfoHashtbl.t;
        functions_with_source : int Cilutil.VarinfoHashtbl.t;
        function_definitions : int;
        cyclos : int;
      }
      val compute : (unit -> unit) Pervasives.ref
      val pretty : (Format.formatter -> unit) Pervasives.ref
      val dump : (unit -> unit) Pervasives.ref
      val last_result : (unit -> Db.Metrics.t) Pervasives.ref
    end
  module Derefs :
    sig
      type t = Locations.Zone.t
      val self_internal : Project.Computation.t ref
      val self_external : Project.Computation.t ref
      val compute : (Db_types.kernel_function -> unit) ref
      val get_internal : (Db_types.kernel_function -> t) ref
      val get_external : (Db_types.kernel_function -> t) ref
      val statement : (Cil_types.stmt -> t) ref
      val kinstr : Cil_types.kinstr -> t option
      val display :
        (Format.formatter -> Db_types.kernel_function -> unit) ref
      val pretty : Format.formatter -> t -> unit
    end
  val progress : (unit -> unit) Pervasives.ref
  exception Cancel
end