Module Spec.D

include module type of struct include ContainDomain.Dom end
val final : bool ref
val report : string -> unit
module Danger = ContainDomain.Dom.Danger
module StringPair = ContainDomain.Dom.StringPair
module InhRel = ContainDomain.Dom.InhRel
val inc : InhRel.t ref
include sig ... end
val equal : t -> t -> Ppx_deriving_runtime.bool
val compare : t -> t -> Ppx_deriving_runtime.int
type group = Printable.Std.group = |
val show_group : group -> 'a
val to_group : 'a -> 'b option
val trace_enabled : bool
val tag : 'a -> 'b
val pretty : unit -> (ContainDomain.FuncName.t * Danger.t * ContainDomain.Diff.t) -> Pretty.doc
val to_yojson : (ContainDomain.FuncName.t * Danger.t * ContainDomain.Diff.t) -> [> `Assoc of (string * Printable.json) list ]
val name : unit -> string
val arbitrary : unit -> (ContainDomain.FuncName.t * Danger.t * ContainDomain.Diff.t) QCheck.arbitrary
val pretty_diff : unit -> (t * t) -> Pretty.doc
val op_scheme : ('a -> 'b -> ContainDomain.FuncName.t) -> ('c -> 'd -> Danger.t) -> ('e -> 'f -> ContainDomain.Diff.t) -> ('a * 'c * 'e) -> ('b * 'd * 'f) -> t
val public_vars : (string, string list) Hashtbl.t
val private_vars : (string, string list) Hashtbl.t
val public_methods : (string, string list) Hashtbl.t
val func_ptrs : (string, string list) Hashtbl.t
val private_methods : (string, string list) Hashtbl.t
val friends : (string, string list) Hashtbl.t
val derived : (string, string list) Hashtbl.t
val vtbls : (string, string list) Hashtbl.t
val analyzed_funs : (string, unit) Hashtbl.t
val required_non_public_funs : (string, string list) Hashtbl.t
val reentrant_funs : (string, unit) Hashtbl.t
val danger_funs : (string, string list) Hashtbl.t
val local_classes : (string, unit) Hashtbl.t
val safe_methods : (string, Str.regexp list) Hashtbl.t
val safe_vars : (string, Str.regexp list) Hashtbl.t
val enable_dbg : bool
val dbg_line_start : int
val dbg_line_end : int
val dbg_report : string -> unit
val error : string -> unit
val taintedFunDec : Cil.varinfo
val get_tainted_fields : (Cil.varinfo -> 'a * 'b * 'c) -> 'a
val get_fptr_items : (Cil.varinfo -> 'a * 'b * 'c) -> 'b
val get_class_items : (Cil.varinfo -> 'a * 'b * 'c) -> 'c
val unresFunDec : Cil.fundec
val set_funname : Cil.fundec -> ('a * 'b * 'c) -> [> `Lifted of Cil.fundec ] * 'b * 'c
val get_name : 'a -> ([> `Lifted of ContainDomain.FuncName.t ] * 'b * 'c) -> ContainDomain.FuncName.t option
val unkown_this : Cil.varinfo
val return_var : Cil.varinfo
val isnot_mainclass : string -> bool
val dump_local_classes : (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> unit
val isnot_localclass : Basetype.RawStrings.t -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val islocal_notmainclass : Basetype.RawStrings.t -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val is_ext : string -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val get_inherited_from : string -> string list
val remove_formals : CilType.Varinfo.t list -> ('a * Danger.t * 'b) -> 'a * Danger.t * 'b
val add_formals : Cil.fundec -> ('a * Danger.t * 'b) -> 'a * Danger.t * 'b
val empty_formals : Cil.fundec -> CilType.Varinfo.t list -> ('a * Danger.t * 'b) -> 'a * Danger.t * 'b
val used_args : Danger.t -> Cil.exp -> ContainDomain.ArgSet.t
val must_be_constructed_from_this : Danger.t -> Cil.exp -> bool
val may_be_constructed_from_this_direct : 'a -> Cil.exp -> bool
val may_be_constructed_from_this : Danger.t -> Cil.exp -> bool
val get_field_from_this : Cil.exp -> Danger.t -> ContainDomain.FieldSet.t
val used_ptrs : Danger.t -> Cil.exp -> ContainDomain.ArgSet.t
val is_tainted : ContainDomain.FieldSet.t -> Danger.t -> Cil.exp -> bool
val get_globals : Cil.exp -> Cil.varinfo list
val get_vars : Cil.exp -> Cil.varinfo list
val check_safety : (string, Str.regexp list) Hashtbl.t -> string -> bool
val is_safe : Cil.exp -> bool
val is_safe_name : string -> bool
val is_public_method_name : string -> bool
val is_private_method_name : string -> bool
val is_public_method : t -> bool
val is_private_method : t -> bool
val may_be_a_perfectly_normal_global : Cil.exp -> 'a -> ('b * Danger.t * 'c) -> ContainDomain.FieldSet.t -> bool
val maybe_deref : Cil.exp -> bool
val danger_assign : Danger.key -> Danger.value -> ('a * Danger.t * 'b) -> bool -> 'c -> 'a * Danger.t * 'b
val uid : int ref
val dumpDomSize : Danger.t -> unit
val dangerDump : string -> Danger.t -> unit
val danger_propagate : Danger.key -> ContainDomain.ArgSet.t -> ('a * Danger.t * ContainDomain.Diff.t) -> bool -> ContainDomain.FieldSet.t -> (Cil.varinfo -> 'b * 'c * ContainDomain.ClassNameSet.t) -> string -> 'a * Danger.t * ContainDomain.Diff.t
val is_bad_reachable : Danger.key -> Danger.t -> bool
val warn_bad_dereference : Cil.exp -> bool -> ('a * Danger.t * 'b) -> 'c -> string -> unit
val has_bad_reachables : 'a -> Cil.exp list -> bool -> ('b * Danger.t * 'c) -> 'd -> 'e -> bool
val is_loc_method : Cil.exp option -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> bool
val warn_bad_reachables : 'a -> Cil.exp list -> bool -> ('b * Danger.t * 'c) -> 'd -> string -> (Cil.varinfo -> 'e * 'f * ContainDomain.ClassNameSet.t) -> unit
val get_this : Danger.t -> Cil.exp -> CilType.Varinfo.t
val get_lval_from_exp : Cil.exp -> Cil.lhost * Cil.offset
val filter_argset_self : Cil.exp -> ContainDomain.ArgSet.t -> Danger.t -> ContainDomain.ArgSet.t
val assign_to_lval : ContainDomain.FieldSet.t -> Cil.lval -> ('a * Danger.t * ContainDomain.Diff.t) -> ContainDomain.ArgSet.t -> bool -> (Cil.varinfo -> 'b * 'c * ContainDomain.ClassNameSet.t) -> string -> 'a * Danger.t * ContainDomain.Diff.t
val assign_to_lval_no_prop : 'a -> Cil.lval -> ('b * Danger.t * 'c) -> Danger.value -> bool -> 'd -> 'b * Danger.t * 'c
val string_of_int64 : int64 -> string
val filter_type : Str.regexp
val split : string -> string -> string list
val gen_vtbl_name : string -> (Cil.varinfo -> 'a * 'b * ContainDomain.ClassNameSet.t) -> string
val add_required_fun : string -> (string, string list) Hashtbl.t -> unit
val add_required_fun_priv : string -> unit
val add_local_class : string -> ('a * 'b * ContainDomain.Diff.t) -> 'a * 'b * ContainDomain.Diff.t
val get_vfunc_set : string -> int -> ('a * 'b * ContainDomain.Diff.t) -> ('a * 'b * ContainDomain.Diff.t) * string list
val muid : int ref
val assign_argmap : ContainDomain.FieldSet.t -> Cil.lval -> Cil.exp -> ('a * Danger.t * ContainDomain.Diff.t) -> bool -> (Cil.varinfo -> 'b * 'c * ContainDomain.ClassNameSet.t) -> 'a * Danger.t * ContainDomain.Diff.t
val is_method : Cil.exp option -> bool
val assign_to_local : 'a -> Cil.lval -> Cil.exp option -> ('b * Danger.t * ContainDomain.Diff.t) -> ContainDomain.FieldSet.t -> (Cil.varinfo -> 'c * 'd * ContainDomain.ClassNameSet.t) -> 'b * Danger.t * ContainDomain.Diff.t
val remove_htbl_entry : ('a, 'b list) Hashtbl.t -> 'a -> 'b -> unit
val add_htbl_entry : ('a, 'b list) Hashtbl.t -> 'a -> 'b -> unit
val filter_vtbl : Str.regexp
val add_func_ptr : Basetype.Variables.t -> ('a * 'b * ContainDomain.Diff.t) -> 'a * 'b * ContainDomain.Diff.t
val warn_tainted : ContainDomain.FieldSet.t -> ('a * Danger.t * 'b) -> Cil.exp -> string -> unit
val may_be_fp : Cil.exp -> Danger.t -> bool -> bool
val warn_glob : Cil.exp -> string -> unit
val show : t -> string