Index of values


__ocaml_lex_comment_rec [Script]
__ocaml_lex_proof_rec [Script]
__ocaml_lex_tables [Script]
__ocaml_lex_token_rec [Script]

A
a_false [Whylib.Create]
a_sizeof [Region.Create]
a_true [Whylib.Create]
acc_field [Mdata.S]
Takes a record term of type (tau_of F.fcomp) and returns the term of type (tau_of F) for its field 'F'
acc_field [Datalib.Create]
acc_index [Mdata.S]
Takes term of type 'a farray and returns the 'a at index i.
acc_index [Datalib.Create]
access [Funvar_mem.Create.Lookup]
access [Datalib.Create]
add [Wpo]
add [State_builder.Dashtbl]
add [Runtime_mem.Create.Aint]
add [Store_mem.Create]
add [Map.S]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [Cil2cfg.HEsig]
add [State_builder.Hashtbl]
Add a new binding.
add [Cil2cfg.HE]
add [Hashtbl.S]
add [Set.S]
add x s returns a set containing all elements of s, plus x.
add_array_length_hyp [Hoare_mem.Create]
add_as_goal [Mcfg.S]
add_as_goal env g p add g as goal to p (g /\ p)
add_as_goal [Cfgpropid.Create]
add_as_goal [CfgWeakestPrecondition.Create]
add_as_hyp [Mcfg.S]
add_as_hyp env h p add h as hypothesis in p (h => p)
add_as_hyp [Cfgpropid.Create]
add_as_hyp [CfgWeakestPrecondition.Create]
add_assigns [Mcfg.S]
add_assigns [WpAnnot]
add_assigns [Cfgpropid.Create]
add_assigns [CfgWeakestPrecondition.Create]
add_assigns_goal [Calculus.Cfg]
add_axiom [Mcfg.S]
add_axiom [Data_mem.Create.Compound]
add_axiom [Cfgpropid.Create]
add_axiom [Translate_prop.Create]
Compile an axiom and add it to the list of global declarations.
add_axiom [CfgWeakestPrecondition.Create]
add_axiom [Calculus.Cfg]
add_behaviors_props [WpAnnot]
add_bhv_assigns [WpAnnot]
add_cfg_menu [Wp_gui]
add_complet_behaviors_props [WpAnnot]
add_declaration [Mdata.S]
add_declaration [Datalib.Create]
add_depend [Datalib.Collector]
add_disjoint_behaviors_props [WpAnnot]
add_edge [Cil2cfg]
add_edges_before [Cil2cfg]
add_effect_assigns [CfgWeakestPrecondition.Create]
add_fct_pre [WpAnnot]
add_glob_axiom [WpAnnot]
add_goal [Mcfg.S]
add_goal [Cfgpropid.Create]
add_goal [CfgWeakestPrecondition.Create]
add_goal [CfgProof.Create]
add_goal [Calculus.Cfg]
add_hyp [Mcfg.S]
add_hyp [Cfgpropid.Create]
add_hyp [CfgWeakestPrecondition.Create]
add_hyp [Calculus.Cfg]
add_int [Whylib]
add_int_format_hyp [Runtime_mem.Create]
add_integer [Translate_prop.Create]
add_inv_goal [Calculus.Cfg]
add_inv_hyp [Calculus.Cfg]
Similar to add_hyp and add_goal except that h and g already come from computations, so they are already represented in the memory model (no translation needed)
add_irreducible [Cil2cfg.WeiMaoZouChenInput]
store the node as an irreducible loop header.
add_irreducible [Cil2cfg.LoopInfo]
add_loop_assigns [WpAnnot]
add_loop_header [Cil2cfg.WeiMaoZouChenInput]
store the node as a loop header.
add_loop_header [Cil2cfg.LoopInfo]
add_lvar [Translate_prop.Create]
add_node [Cil2cfg]
add_normal_assigns [CfgWeakestPrecondition.Create]
add_oblig [Calculus.Cfg.R]
add_offset [Store_mem.Create]
add_on_edges [WpAnnot]
add_proof [WpAnnot]
accumulate int the proof the partial proof for this prop_id
add_prop [WpAnnot]
add_real [Whylib]
add_reentry_edge [Cil2cfg.WeiMaoZouChenInput]
store the edge between the two nodes (n1, n2) as a reentry edge.
add_reentry_edge [Cil2cfg.LoopInfo]
add_region_assigns [CfgWeakestPrecondition.Create]
add_script [Proof]
new_script goal keys proof registers the script proof for goal goal and keywords keys
add_set [Mdata.S]
add_set [Datalib.Create]
add_spec_assigns_as_hyp [WpAnnot]
add_state [Dashtbl.Graph]
add_stmt_spec_after [WpAnnot]
add_stmt_spec_before [WpAnnot]
add_stmt_spec_postcond [WpAnnot]
add_stmt_spec_precond_as_hyp [WpAnnot]
add_unique [Caveat_mem.Make.WP]
TODOopt should we have oredered lists ?
add_var_decl_hyp [Hoare_mem.Create]
Add some hypotheses about the variable because we are going out of its scope.
add_warning [Datalib.Collector]
When adding a warning, one has to provide : the source of the warning (for instance "model M"),, the effect of the warning (for instance "stop computation"), and a formated message about why this warning is emited.
add_wp_menu [Wp_gui]
addr [Store_mem.Create.Model]
addr [Translate_expr.Create]
addr mem lv interprets the left value lv as an address (memory location) in the memory mem.*
addr [CfgWeakestPrecondition.Create]
addr [Hoare_lib.Create.Hlib]
addr [Caveat_fol]
addr_format [Store_mem.Create]
addr_of_assignable [Store_mem.Create]
addr_of_data [Caveat_fol]
Pre the data should represent an object (as oposed to an address).
all_separated [Region.Create]
alloc [Runtime_mem.Create.RtLib]
alloc_vars [Store_mem.Create]
alpha [Mdata.S]
alpha [Datalib.Create]
alpha_bound_var [Fol]
alpha_unbound [Fol]
altergo [Prover.SMT]
apply [Mdata.S]
apply [Hook.S]
Apply all the functions of the hook on the given parameter.
apply [Fol_gformula.Predicate]
apply [Datalib.Create]
apply [Axiomatics]
apply_alpha [Fol]
apply_bindings [Datalib.Create]
apply_closure [Translate_prop.Create]
apply_function [Translate_prop.Create]
apply_hints [Translate_prop.Create]
apply_predicate [Translate_prop.Create]
apply_sigma [Translate_prop.Create]
array [Fol_ergo]
array_flag [Fol_ergo]
array_format [Mdata.S]
array_format [Data_mem.Create]
array_format [Datalib.Create]
array_length [Hoare_lib.Create.Hlib]
array_of_data [Translate_prop.Create]
array_of_path [Funvar_mem.Create]
as_hint [Translate_prop.Create]
assign [Mcfg.S]
assign [Cfgpropid.Create]
assign [CfgWeakestPrecondition.Create]
assignable [Store_mem.Create]
assignable_loc [Store_mem.Create]
assignable_range [Store_mem.Create]
assignable_sizeof [Store_mem.Create]
assigned [Translate_prop.Create]
Compiles an arbitrary term representing a set of left-values into a zone
assigned_for_assigns_goal [CfgWeakestPrecondition.Create]
assigned_of_assigns [CfgWeakestPrecondition.Create]
assigned_of_data [Translate_prop.Create]
assigns_clause [Translate_prop.Create]
assigns_goal [Mwp.S]
assigns_goal [Runtime_mem.Create]
assigns_goal [Store_mem.Create]
assigns_goal [Hoare_mem.Create]
assigns_goal [Funvar_mem.Create]
assigns_goal [Caveat_mem.Make.WP]
assigns_method [Mcfg.S]
assigns_method [Cfgpropid.Create]
assigns_method [CfgWeakestPrecondition.Create]
assigns_method [CfgProof.Create]
assigns_supported [Mwp.S]
assigns_supported [Runtime_mem.Create]
assigns_supported [Store_mem.Create]
assigns_supported [Hoare_mem.Create]
assigns_supported [Funvar_mem.Create]
assigns_supported [Caveat_mem.Make.WP]
axiom_env [Translate_prop.Create]

B
bad_eq_terms [Fol]
compare terms without knowing how to compare data : better than something for smart constructors (see eq_terms)
bad_pred_closed [Fol]
bad_pred_has_var [Fol]
bad_term_closed [Fol]
bad_term_has_var [Fol]
bar [Wpo]
base [Runtime_mem.Create.Tint]
base [Store_mem.Create.Model]
base [Region.Create]
An arbitrary base-address of any allocated C memory-block.
base [Hoare_lib.Create.Hlib]
base [Caveat_fol]
base_address [Mlogic.S]
base_address m l return the base address of l.
base_address [Runtime_mem.Create]
base_address [Store_mem.Create]
base_address [Hoare_mem.Create]
base_address [Funvar_mem.Create]
base_address [Caveat_mem.Make.WP]
basename [Mdata.S.Identifiable]
basename [Fol.Var]
basename [Ctypes]
basename [Datalib.Create.Identifiable]
basename [Datalib.Create.LTinfoId]
basename [Datalib.Create.Logicvar]
basename [Datalib.Create.LTypeinfo]
basename [Datalib.Create.Arrayinfo]
basename [Datalib.Create.Compinfo]
basename [Datalib.Create.Fieldinfo]
basename [Datalib.Create.Varinfo]
basename_of_var [Fol_gformula.Pool]
basename_of_var [Caveat_fol]
basetype [Ctypes]
behavior_name_of_config [WpAnnot]
binop [Whylib.Create]
bits_and [Mint.S]
bits_and [Mint_natural.Create]
bits_lshift [Mint.S]
bits_lshift [Mint_natural.Create]
bits_not [Mint.S]
bits_not [Mint_natural.Create]
bits_of_value [Runtime_mem.Create.Data]
bits_of_value [Runtime_mem.Create]
bits_or [Mint.S]
bits_or [Mint_natural.Create]
bits_rshift [Mint.S]
bits_rshift [Mint_natural.Create]
bits_xor [Mint.S]
bits_xor [Mint_natural.Create]
bkind_sid [Cil2cfg]
bkind_stmt [Cil2cfg]
blit [String]
String.blit src srcoff dst dstoff len copies len characters from string src, starting at character number srcoff, to string dst, starting at character number dstoff.
block [Region.Create]
The full block at given block
block_length [Mlogic.S]
block_length m l t return the block_length of the location l.
block_length [Runtime_mem.Create.RtLib]
block_length [Runtime_mem.Create]
block_length [Store_mem.Create]
block_length [Hoare_mem.Create]
block_length [Funvar_mem.Create]
block_length [Hoare_lib.Create.Hlib]
block_length [Caveat_mem.Make.WP]
blocks_closed_by_edge [Cil2cfg]
body_of_id_assigns [WpAnnot]
body_of_id_pred [WpAnnot]
bool_and [Whylib]
bool_not [Whylib]
bool_or [Whylib]
boolean_of_data [Translate_prop.Create]
boolean_of_float [Translate_expr.Create]
boolean_of_int [Translate_expr.Create]
boolean_of_integer [Translate_expr.Create]
boolean_of_ptr [Translate_expr.Create]
boolean_of_value [Translate_expr.Create]
build_bhv_assumes [WpFroms]
build_bhv_assumes [WpAnnot]
build_bhv_strategy [WpAnnot]
build_cfg [Register]
build_fimpl_call [WpFroms]
Build out = f_n (inputs)
build_prop_of_from [Mcfg.S]
build p => alpha(p) for functional dependencies verification.
build_prop_of_from [Cfgpropid.Create]
build_prop_of_from [CfgWeakestPrecondition.Create]
build_strategy_for_froms [WpAnnot]
build_wpos [CfgProof.Create]

C
c_bool [Fol]
c_bool [Ctypes]
Returns the type of int
c_char [Ctypes]
Returns the type of char
c_enum [Ctypes]
Returns the type of enums
c_float [Fol]
c_float [Ctypes]
Conforms to
c_float_of_str [Fol]
c_int [Fol]
c_int [Ctypes]
Conforms to
c_int_bounds [Ctypes]
c_int_of_str [Fol]
c_int_of_typ [Translate_expr.Create]
c_label [Clabels]
Assumes the logic label only comes from normalized labels.
c_object_of_data [Caveat_mem.Make.Export]
c_ptr [Ctypes]
Returns the type of pointers
call [CfgWeakestPrecondition.Create]
call_exit [Mcfg.S]
call_exit [Cfgpropid.Create]
call_exit [Translate_prop.Create]
call_exit [CfgWeakestPrecondition.Create]
call_normal [Mcfg.S]
call_normal [Cfgpropid.Create]
call_normal [CfgWeakestPrecondition.Create]
call_post [Translate_prop.Create]
call_post_for_froms [WpAnnot]
call_pre [Translate_prop.Create]
capitalize [String]
Return a copy of the argument, with the first character set to uppercase.
capture [Mdata.S]
capture [Datalib.Create]
cardinal [Store_mem.Create]
cardinal [Set.S]
Return the number of elements of a set.
case_of [Fol]
case_of_exp [CfgWeakestPrecondition.Create]
cast [Translate_prop.Create]
cast [CfgWeakestPrecondition.Create]
cast_int_to_loc [Mvalues.Model]
cast_int_to_loc [Runtime_mem.Create.Model]
cast_int_to_loc [Store_mem.Create.Model]
cast_int_to_loc [Hoare_mem.Create.Model]
cast_int_to_loc [Funvar_mem.Create.Model]
cast_int_to_loc [Datalib.Cvalues]
cast_int_to_loc [Caveat_mem.Make.WP.Model]
cast_loc_to_int [Mvalues.Model]
cast_loc_to_int [Runtime_mem.Create.Model]
cast_loc_to_int [Store_mem.Create.Model]
cast_loc_to_int [Hoare_mem.Create.Model]
cast_loc_to_int [Funvar_mem.Create.Model]
cast_loc_to_int [Datalib.Cvalues]
cast_loc_to_int [Caveat_mem.Make.WP.Model]
cast_loc_to_loc [Mvalues.S]
cast_loc_to_loc t1 t2 l returns the casted location of type t2 from the location l of type t1
cast_loc_to_loc [Runtime_mem.Create]
cast_loc_to_loc [Store_mem.Create]
cast_loc_to_loc [Hoare_mem.Create]
cast_loc_to_loc [Funvar_mem.Create]
cast_loc_to_loc [Caveat_mem.Make.WP]
cat [Prover]
catch_label_error [NormAtLabels]
cc_pred [Fol_eqs]
ccp [Fol_eqs]
ccpred [Fol_eqs]
cct [Fol_eqs]
cfg_block [Cil2cfg]
cfg_dot [Cil2cfg]
cfg_graph [Cil2cfg]
cfg_kf [Cil2cfg]
cfg_start [Cil2cfg]
cfg_stmt [Cil2cfg]
cfg_stmts [Cil2cfg]
build the nodes for the stmts, connect the last one with next, and return the node of the first stmt.
cfg_switch [Cil2cfg]
change_data_in_exp [Fol]
Similar to change_in_exp but only transforms data into data.
change_data_in_pred [Fol]
change_data_in_pred do_data_rec p where do_data_rec do_exp d
change_exp_in_pred [Fol]
apply do_exp on each sub expression of the predicate.
change_in_exp [Fol]
Apply do_var and do_data in term subexpressions.
change_mode [Calculus.Cfg.R]
check [Prover.Coq]
check [Prover.AltErgo]
check [Prover.SMT]
check [Prover]
check_assigns [CfgWeakestPrecondition.Create]
check_by [Prover]
check_indir_label [Caveat_mem.Make.WP]
We want to read d at label, but in Caveat model, everything comes from variables, so we cannot read at a label if the address is evaluated at another one...
check_names [Wp_parameters]
check_pred [Fol]
check_term [Fol]
choose [Proof]
choose [Set.S]
Return one element of the given set, or raise Not_found if the set is empty.
cil_field_info [Runtime_mem.Create]
cil_field_offset [Runtime_mem.Create]
cil_field_size [Runtime_mem.Create]
clean_graph [Cil2cfg]
clear [Mdata.S.Declarator]
clear [Mdata.S]
clear [Wpo.Results]
clear [Wpo]
clear [State_builder.Dashtbl]
clear [Proof]
clear [Hook.S]
Clear the hook.
clear [Cil2cfg.HEsig]
clear [State_builder.Hashtbl]
Clear the table.
clear [Cil2cfg.HE]
clear [State_builder.Ref]
Reset the reference to its default value.
clear [Datalib.Create.Declarator]
clear [Hashtbl.S]
clear [Datalib.Create]
close [Mdata.S]
close [Mcfg.S]
close [Script]
close [Prover.Log]
close [Cfgpropid.Create]
close [CfgWeakestPrecondition.Create]
close [Datalib.Create]
close_env [Funvar_mem.Create]
close_property [CfgWeakestPrecondition.Create]
closed [Mdata.S]
closed [Mdata.Addr]
closed [Datalib.Create]
cmdline_run [Register]
cnst_mult [Runtime_mem.Create.Aint]
cnst_mult_size [Runtime_mem.Create.Tint]
code_annot_names [WpAnnot]
collect_and [Fol_pretty]
collect_and [Fol_ergo]
collect_and [Fol_coq]
collect_assoc [Fol_pretty]
collect_assoc [Fol_ergo]
collect_assoc [Fol_coq]
collect_iff [Fol_pretty]
collect_iff [Fol_ergo]
collect_iff [Fol_coq]
collect_imply [Fol_pretty]
collect_imply [Fol_ergo]
collect_imply [Fol_coq]
collect_or [Fol_pretty]
collect_or [Fol_ergo]
collect_or [Fol_coq]
collect_scripts [Proof]
collect_signature [Hoare_mem.Create]
collect_signature [Funvar_mem.Create]
column_tbl [Po_navigator.Prover_Column]
command [Prover.Log]
comment [Script]
compare [Map.S]
Total ordering between maps.
compare [Fol.Var]
compare [Ctypes.AinfoComparable]
compare [String]
The comparison function for strings, with the same specification as Pervasives.compare.
compare [Ctypes]
compare [Cil2cfg.EL]
compare [Cil2cfg.VL]
compare [Datalib.Create.LTinfo]
compare [Set.S]
Total ordering between sets.
compare_c_float [Ctypes]
compare_c_int [Ctypes]
compare_edge_type [Cil2cfg.EL]
compare_prop_id [WpAnnot]
compile_function [Translate_prop.Create]
compile_predicate [Translate_prop.Create]
compile_user_axiom [Translate_prop.Create]
compile_user_hypothesis [Translate_prop.Create]
compiled [Prover.Coq]
compute [Vaddr]
compute [Calculus.Cfg]
compute [Axiomatics]
compute_bindings [Datalib.Create]
compute_int_mode [Runtime_mem.Create]
compute_rte_for [WpAnnot]
compute_wp_edge [Calculus.Cfg]
computer [Register]
concat [String]
String.concat sep sl concatenates the list of strings sl, inserting the separator string sep between each.
cond [Translate_expr.Create]
cond mem e interprets e as a boolean in memory mem.
cond [CfgWeakestPrecondition.Create]
cond_binop [Translate_expr.Create]
cond_rec [Translate_expr.Create]
cond_unop [Translate_expr.Create]
consolidate_loop [WpAnnot]
constant [Fol_pretty]
constant [Fol_ergo]
constant [Fol_coq]
constant [Ctypes]
contains [String]
String.contains s c tests if character c appears in the string s.
contains_from [String]
String.contains_from s start c tests if character c appears in s after position start.
context [CfgProof.Description]
Basename for environment files ; unique per updater
context [Datalib.Create]
copy [Datatype.S]
Deep copy: no possible sharing between x and copy x.
copy [Datatype.Set]
copy [String]
Return a copy of the given string.
copy [Hashtbl.S]
coq_for_env [Wpo]
coq_for_model [Wpo]
coq_normalize [Fol_norm]
coqc [Prover.Coq]
coqc_for_model [Wpo]
coqidelock [Prover.Coqide]
create [Wpo.Results]
create [Prover.Log]
create [Funvar_mem.Create]
create [String]
String.create n returns a fresh string of length n.
create [Cil2cfg.HEsig]
create [Cil2cfg.HE]
create [Cil2cfg]
create [CfgProof.Create]
create [Hashtbl.S]
create_and_add_state [Dashtbl.Graph]
create_data_name [Caveat_mem.Make.WP]
Create names for address variables, field, structure types...
create_proof [WpAnnot]
to be used only once for one of the related prop_id
ctype_of_data [Caveat_mem.Make.WP]
Try to find the data type needed to generated 'format' for indir and mu_indir
ctype_of_fvar [Caveat_fol]
cur_fct_default_bhv [WpAnnot]
current [Wp_error]
current [Prover.Log]
cut [Fol]
cvar [Mvalues.S]
cvar [Runtime_mem.Create.Data]
cvar [Store_mem.Create.Data]
cvar [Hoare_mem.Create]
cvar [Region.Create]
Base of a C-variable.
cvar [Funvar_mem.Create]
cvar [Caveat_mem.Make.WP]
cvar_of_var [Store_mem.Create.Data]
cvc3 [Prover.SMT]

D
data_alpha_cv [Caveat_fol]
data_binop [Translate_prop.Create]
data_cmp [Translate_prop.Create]
data_const [Translate_prop.Create]
data_field [Translate_prop.Create]
data_has_var [Caveat_fol]
data_index [Translate_prop.Create]
data_index_range [Translate_prop.Create]
data_load [Translate_prop.Create]
data_of_assignable [Translate_prop.Create]
data_of_boolean [Translate_prop.Create]
data_of_cvar_at [Caveat_fol]
data_of_cvar_at_l [Caveat_fol]
data_of_integer [Translate_prop.Create]
data_of_lvar [Caveat_fol]
data_of_real [Translate_prop.Create]
data_of_term [Translate_prop.Create]
data_of_term [Caveat_fol]
data_rec [Translate_prop.Create]
data_separated [Translate_prop.Create]
data_shift [Translate_prop.Create]
data_shift_range [Translate_prop.Create]
data_startof [Translate_prop.Create]
data_startof_set [Translate_prop.Create]
data_unop [Translate_prop.Create]
data_valid [Translate_prop.Create]
debug1 [Caveat_mem]
Trace call from outside
debug2 [Caveat_mem]
debug3 [Caveat_mem]
All the details
declare [Mdata.S.Declarator]
declare [Datalib.Create.Declarator]
decode [Mdata.S]
decode [Datalib.Create]
default [Prover.Coq]
default [Cil2cfg.EL]
default_edge_attributes [Cil2cfg.Printer]
default_vertex_attributes [Cil2cfg.Printer]
define [Mdata.S.Registry]
define [Data_mem.Create.Compound]
define [Translate_prop.Create.UserAxiomDefs]
define [Translate_prop.Create.UserDefinition]
define [Datalib.Create.Registry]
define [Datalib.Create.Register]
define_access [Data_mem.Create.LoadedCompound]
define_array [Data_mem.Create.UpdatedCompound]
define_array [Data_mem.Create.StoredCompound]
define_array [Data_mem.Create.LoadedCompound]
define_comp [Data_mem.Create.UpdatedCompound]
define_comp [Data_mem.Create.StoredCompound]
define_comp [Data_mem.Create.LoadedCompound]
define_update [Data_mem.Create.StoredCompound]
define_vinfo [Store_mem.Create.Data]
dependencies [Wprop.Info]
dependencies [Wprop.Actor]
dependencies [WpAnnot]
descr [Datatype.Set]
diff [Set.S]
Set difference.
dimension [Ctypes]
direct_lval [Caveat_mem.Make.WP]
disj [Caveat_mem.Make.WP]
dispatch [Register]
dispatch [Fol_split]
Splits conjunctions and unfold the definition of included over zones.
div_int [Whylib]
dnode_cpt [Cfgpropid.Create]
do_check_feedback [Register]
do_compute [Register]
do_data_rec [Caveat_fol]
propagate transformations do_data and do_exp in d.
do_exists [Datalib.Create]
do_exp_in_data [Caveat_fol]
propagate expression transformation do_exp in the data d
do_forall [Datalib.Create]
do_froms [WpAnnot]
do_instantiate [Translate_prop.Create]
do_labels [Calculus.Cfg]
Before storing something at a program point, we have to process the label at that point.
do_main_init_if_needed [Calculus.Cfg]
If kf is the 'main' function, process global initialisations as if they were a kind of prelude of the 'main'.
do_path [Caveat_fol]
do_subst [Datalib.Create]
do_wp_check [Register]
do_wp_checks [Register]
do_wp_checks_for [Register]
do_wp_passes [Register]
do_wp_print [Register]
do_wp_print_for [Register]
do_wp_proof [Register]
do_wp_proofs [Register]
do_wp_proofs_for [Register]
do_wpo_feedback [Register]
domain [Datalib.Create]
dot_annots [Cil2cfg]
dot_annots cfg bhv_name pp_annots
dot_cfg [Cil2cfg]
Output the graph in a dot file and return its name *
dot_lannots [Register]
dot_wp_res [Cil2cfg]
dot_wp_res cfg model pp_wp_res
dummy [Mdata.S]
dummy [Datalib.Create]
dump_scripts [Proof]
dump_scripts f saves all scripts from the database into file f.
dzone_assigned [Mwp.S]
dzone_assigned [Runtime_mem.Create]
dzone_assigned [Store_mem.Create]
dzone_assigned [Hoare_mem.Create]
dzone_assigned [Funvar_mem.Create]
dzone_assigned [Caveat_mem.Make.WP]
dzone_empty [Mwp.S]
dzone_empty [Runtime_mem.Create]
dzone_empty [Store_mem.Create]
dzone_empty [Hoare_mem.Create]
dzone_empty [Funvar_mem.Create]
dzone_empty [Caveat_mem.Make.WP]
dzone_of_var [Caveat_mem.Make.WP]
dzone_subset [Mwp.S]
dzone_subset [Runtime_mem.Create]
dzone_subset [Store_mem.Create]
dzone_subset [Hoare_mem.Create]
dzone_subset [Funvar_mem.Create]
dzone_subset [Caveat_mem.Make.WP]
dzone_union [Mwp.S]
dzone_union [Runtime_mem.Create]
dzone_union [Store_mem.Create]
dzone_union [Hoare_mem.Create]
dzone_union [Funvar_mem.Create]
dzone_union [Caveat_mem.Make.WP]

E
e_and [Formula.S]
e_and [Whylib.Create]
e_app [Fol]
e_app0 [Mdata.S]
e_app0 [Datalib.Create]
e_app1 [Mdata.S]
e_app1 [Datalib.Create]
e_app2 [Mdata.S]
e_app2 [Datalib.Create]
e_app3 [Mdata.S]
e_app3 [Datalib.Create]
e_app4 [Mdata.S]
e_app4 [Datalib.Create]
e_app5 [Mdata.S]
e_app5 [Datalib.Create]
e_band [Formula.S]
e_band [Whylib.Create]
e_bnot [Formula.S]
e_bnot [Whylib.Create]
e_bool [Formula.S]
e_bool [Whylib.Create]
e_bor [Formula.S]
e_bor [Whylib.Create]
e_bxor [Formula.S]
e_bxor [Whylib.Create]
e_call [Formula.Vernacular]
e_call [Fol_gformula.Langage]
e_closed [Fol]
e_cnst [Fol]
e_cond [Formula.S]
e_cond [Whylib.Create]
e_data [Fol]
e_false [Formula.S]
e_false [Fol_gformula.Langage]
e_false [Fol]
e_field [Region.Create]
e_float [Formula.S]
e_float [Fol_gformula.Langage]
e_float [Fol]
e_has_var [Fol]
e_icmp [Formula.S]
e_icmp [Whylib.Create]
e_icst [Formula.S]
e_icst [Fol_gformula.Langage]
e_if [Fol]
e_ineg [Formula.S]
e_ineg [Whylib.Create]
e_int [Formula.S]
e_int [Formula.Vernacular]
e_int [Fol_gformula.Langage]
e_int [Fol]
e_int64 [Formula.S]
e_int64 [Fol_gformula.Langage]
e_int64 [Fol]
e_iop [Formula.S]
e_iop [Whylib.Create]
e_let [Fol]
e_lshift [Formula.S]
e_lshift [Whylib.Create]
e_not [Formula.S]
e_not [Whylib.Create]
e_or [Formula.S]
e_or [Whylib.Create]
e_rcmp [Formula.S]
e_rcmp [Whylib.Create]
e_rcst [Formula.S]
e_rcst [Fol_gformula.Langage]
e_rename [Formula.S]
Requires domain to be disjoint from co-domain
e_rename [Fol_gformula.Predicate]
e_rename [Caveat_fol]
e_rneg [Formula.S]
e_rneg [Whylib.Create]
e_rop [Formula.S]
e_rop [Whylib.Create]
e_rshift [Formula.S]
e_rshift [Whylib.Create]
e_sizeof [Region.Create]
e_subst [Formula.S]
e_subst [Fol_gformula.Predicate]
e_true [Formula.S]
e_true [Fol_gformula.Langage]
e_true [Fol]
e_unfold [Fol_split]
e_var [Fol]
eat [Script]
edge_attributes [Cil2cfg.Printer]
edge_dst [Cil2cfg]
edge_key [Cil2cfg.HE]
edge_src [Cil2cfg]
node and edges relations
edge_type [Cil2cfg]
effect_supported [Mwp.S]
effect_supported [Runtime_mem.Create]
effect_supported [Store_mem.Create]
effect_supported [Hoare_mem.Create]
effect_supported [Funvar_mem.Create]
effect_supported [Caveat_mem.Make.WP]
elements [Set.S]
Return the list of all elements of the given set.
empty [Mdata.S]
empty() returns the polymorphic empty set.
empty [Mcfg.S]
empty [Region.Create]
The empty region
empty [Map.S]
The empty map.
empty [Cfgpropid.Create]
empty [CfgWeakestPrecondition.Create]
empty [Set.S]
The empty set.
empty [Datalib.Create]
empty [Calculus.Cfg.R]
empty_acc [WpAnnot]
empty_alpha [Formula.S]
empty_alpha [Fol_formula]
empty_alpha [Caveat_fol]
encode [Mdata.S]
encode [Datalib.Create]
env_at [Funvar_mem.Create]
env_at [Translate_prop.Create]
env_body [Translate_prop.Create]
env_name [Wpo]
epp_pred_atom [Fol_pretty]
epp_pred_atom [Fol_ergo]
epp_pred_atom [Fol_coq]
epp_pred_named [Fol_pretty]
epp_pred_vbox [Fol_pretty]
epp_pred_vbox [Fol_ergo]
epp_pred_vbox [Fol_coq]
eq_array [Mdata.S]
eq_array [Datalib.Create]
eq_array_definition [Datalib.Create]
eq_data [Caveat_fol]
eq_epath [Caveat_fol]
eq_int [Whylib]
eq_int_bool [Whylib]
eq_nodes [Cil2cfg.WeiMaoZouChenInput]
eq_nodes [Cil2cfg.LoopInfo]
eq_pred [Runtime_mem.Create.Aint]
eq_real [Whylib]
eq_real_bool [Whylib]
eq_record [Mdata.S]
eq_record [Datalib.Create]
eq_record_definition [Datalib.Create]
eq_term [Caveat_fol]
eq_term_opt [Caveat_fol]
eq_terms [Fol]
eq_var [Formula.S]
eq_var [Fol_gformula.Predicate]
eq_var [Caveat_fol]
eq_zone [Runtime_mem.Create.Tint]
equal [Mdata.S]
equal [Mdata.Addr]
equal [Map.S]
equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.
equal [Fol.Var]
equal [Ctypes.AinfoComparable]
equal [Ctypes]
equal [Cil2cfg.VL]
equal [Datalib.Create.LTinfo]
equal [Set.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [Datalib.Create]
equal_pointer_bool [Mdata.S]
equal_pointer_bool p q is the boolean that is true when pointers p and q, that points to elements of type ty, are equal.
equal_pointer_bool [Datalib.Create]
equal_rec [Datalib.Create]
equal_terms [Formula.S]
Returns true when the two terms are syntactically equals
equal_terms [Fol_gformula.Predicate]
eraise [Script]
ergo_normalize [Fol_norm]
error [Script]
escaped [String]
Return a copy of the argument, with special characters represented by escape sequences, following the lexical conventions of Objective Caml.
exists [Mdata.S]
exists [Region.Create.Merge]
exists [Region.Create]
exists [Set.S]
exists p s checks if at least one element of the set satisfies the predicate p.
exists [Datalib.Create]
exit_status [Mlogic.S]
exit_status e returns the variable associates to the function exit status in the environment e.
exit_status [Runtime_mem.Create]
exit_status [Store_mem.Create]
exit_status [Hoare_mem.Create]
exit_status [Funvar_mem.Create]
exit_status [Caveat_mem.Make.WP]
export [Prover]
export [Cil2cfg]
export_data [Fol_why]
export_data [Fol_ergo]
export_data [Fol_coq]
export_decl [Mwp.Export]
export_decl [Mcfg.Export]
export_decl [Fol_why]
export_decl [Fol_ergo.E92]
export_decl [Fol_ergo.E91]
export_decl [Fol_ergo]
export_decl [Fol_coq]
export_decl [Caveat_mem.Make.Export.Create]
export_goal [Mwp.Export]
export_goal [Mcfg.Export]
export_goal [Fol_why]
export_goal [Fol_ergo.E92]
export_goal [Fol_ergo.E91]
export_goal [Fol_ergo]
export_goal [Fol_coq]
export_goal [Caveat_mem.Make.Export.Create]
export_item [Fol_why]
export_item [Fol_ergo]
export_item [Fol_coq]
export_pred [Fol_why]
export_pred [Fol_ergo]
export_pred [Fol_coq]
export_tau [Fol_why]
export_tau [Fol_ergo.E92]
export_tau [Fol_ergo.E91]
export_tau [Fol_ergo]
export_tau [Fol_coq]
export_term [Fol_why]
export_term [Fol_ergo]
export_term [Fol_coq]
export_wpo [CfgProof.Create]
expp [Fol_eval]
expr [Translate_expr.Create]
expr mem e interprets the expressione as a value in memory mem *
expr [CfgWeakestPrecondition.Create]
expr_binop [Translate_expr.Create]
expr_cast [Translate_expr.Create]
expr_cond_cmp [Translate_expr.Create]
expr_cond_cmp_arith [Translate_expr.Create]
expr_cond_cmp_ptr [Translate_expr.Create]
expr_const [Translate_expr.Create]
expr_float [Translate_expr.Create]
expr_float_operator [Translate_expr.Create]
expr_int [Translate_expr.Create]
expr_int_operator [Translate_expr.Create]
expr_rec [Translate_expr.Create]
expr_rec_spec_null [Translate_expr.Create]
expr_unop [Translate_expr.Create]
expt [Fol_eval]
extend [Hook.S]
Add a new function to the hook.
extend [Po_navigator]
extract_from_data [Translate_prop.Create]

F
f_cmp [Mfloat.S]
f_cmp [Mfloat_natural.Create]
f_convert [Mdata.S]
f_convert [Ctypes]
f_convert [Datalib.Create]
f_guard [Mdata.S]
f_guard [Datalib.Create]
f_neg [Mfloat.S]
f_neg [Mfloat_natural.Create]
f_op [Mfloat.S]
f_op [Mfloat_natural.Create]
f_sizeof [Ctypes]
farray_access [Datalib]
farray_update [Datalib]
fcmp_operator [Translate_expr.Create]
fdecl_of_decl [Caveat_mem.Make.Export]
fdx [Ctypes]
field [Mvalues.S]
field [Mvalues.Data]
field [Runtime_mem.Create.Data]
field [Store_mem.Create.Data]
field [Hoare_mem.Create]
field [Funvar_mem.Create]
field [Caveat_mem.Make.WP]
field_access [Hoare_mem.Create]
field_offset [Ctypes]
file [Prover.Tmp]
file_for_body [Wpo]
file_for_ctxt [Wpo]
file_for_env [Wpo]
file_for_goal [Wpo]
file_for_head [Wpo]
file_for_lang [Wpo]
file_for_log [Wpo]
file_for_model [Wpo]
fill [Script]
fill [String]
String.fill s start len c modifies string s in place, replacing len characters by c, starting at start.
filter [State_builder.Dashtbl]
filter [Set.S]
filter p s returns the set of all elements in s that satisfy predicate p.
find [State_builder.Dashtbl]
find [Map.S]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [Cil2cfg.HEsig]
find [State_builder.Hashtbl]
Return the current binding of the given key.
find [Cil2cfg.HE]
find [Hashtbl.S]
find [Calculus.Cfg.R]
find_all [State_builder.Dashtbl]
find_all [Cil2cfg.HEsig]
find_all [State_builder.Hashtbl]
Return the list of all data associated with the given key.
find_all [Cil2cfg.HE]
find_all [Hashtbl.S]
find_all_data [State_builder.Dashtbl]
find_all_local [State_builder.Dashtbl]
find_all_local_data [State_builder.Dashtbl]
find_all_local_states [State_builder.Dashtbl]
find_all_states [State_builder.Dashtbl]
find_data [State_builder.Dashtbl]
find_key [State_builder.Dashtbl]
find_mem_at [Runtime_mem.Create]
find_script_for_goal [Proof]
Retrieve script file for one specific goal.
find_script_for_keywords [Proof]
Retrieve matchable script files for w.r.t provided keywords.
find_state [State_builder.Dashtbl]
fingerprint [Region.Create]
fixpoint [Datalib.Create]
flatten [Fol_split]
float_of_value [Translate_expr.Create]
float_operator [Translate_expr.Create]
flow [Wpo]
flush [Mdata.S]
flush [Fol_eqs]
flush [Datalib.Create]
flush_context [Translate_prop.Create]
fmemo [Ctypes]
fold [State_builder.Dashtbl]
fold [Map.S]
fold f m a computes (f kN dN ... (f k1 d1 a)...), where k1 ... kN are the keys of all bindings in m (in increasing order), and d1 ... dN are the associated data.
fold [State_builder.Hashtbl]
fold [Hashtbl.S]
fold [Set.S]
fold f s a computes (f xN ... (f x2 (f x1 a))...), where x1 ... xN are the elements of s, in increasing order.
fold_alpha [Formula.S]
fold_alpha [Fol_formula]
fold_alpha [Caveat_fol]
fold_data_in_exp [Fol]
fold_data_in_exp do_var do_data acc exp
fold_data_in_pred [Fol]
fold_exp_in_pred [Fol]
TODO: this function is probably not exactly the good one since bounded variables might escape.
fold_key [State_builder.Dashtbl]
fold_nodes [Cil2cfg]
iterators
fold_pred [Cil2cfg]
fold_pred_e [Cil2cfg]
fold_succ [Cil2cfg.WeiMaoZouChenInput]
apply the function on the node successors
fold_succ [Cil2cfg.LoopInfo]
fold_succ [Cil2cfg]
fold_succ_e [Cil2cfg]
for_all [Set.S]
for_all p s checks if all elements of the set satisfy the predicate p.
forall [Mdata.S]
forall [Region.Create.Merge]
forall [Region.Create]
forall [Datalib.Create]
forall_loc [Mvalues.Data]
forall_loc [Runtime_mem.Create.Data]
forall_loc [Store_mem.Create.Data]
format_of_addr [Runtime_mem.Create]
format_of_array [Runtime_mem.Create]
format_of_c_float_type [Runtime_mem.Create]
format_of_c_int_type [Runtime_mem.Create]
format_of_compinfo [Runtime_mem.Create]
format_of_object [Mdata.S]
format_of_object [Datalib.Create]
fp_addr [Region.Create]
fp_base [Region.Create]
fp_map [Region.Create]
fp_offset [Region.Create]
fp_range [Region.Create]
fp_size [Region.Create]
fpp_decl [Fol_pretty]
fpp_decl [Fol_ergo]
fpp_decl [Fol_coq]
fpp_f_let [Fol_ergo]
fpp_f_let [Fol_coq]
fpp_goal [Fol_pretty]
fpp_goal [Fol_ergo]
fpp_goal [Fol_coq]
fpp_header [Fol_pretty]
fpp_header [Fol_ergo]
fpp_header [Fol_coq]
fpp_item [Fol_pretty]
fpp_item [Fol_ergo]
fpp_item [Fol_coq]
fpp_lf_let [Fol_ergo]
fpp_lf_let [Fol_coq]
fpp_pred [Fol_pretty]
fpp_pred [Fol_ergo]
fpp_pred [Fol_coq]
fpp_term [Fol_pretty]
fpp_term [Fol_ergo]
fpp_term [Fol_coq]
fpred_of_pred [Caveat_mem.Make.Export]
fpretty_term [Fol_pretty]
fquantify_at_label [Funvar_mem.Create]
fract_real [Whylib]
free [Runtime_mem.Create.RtLib]
free_vars [Store_mem.Create]
free_vars [Fol_cc]
fresh [Mdata.S]
fresh [Mdata.Addr]
fresh [Formula.S]
fresh [Fol_gformula.Pool]
fresh [Datalib.Create]
fresh [Caveat_fol]
fresh_name [Mdata.S]
fresh_name [Datalib.Create]
fresh_named_var [Fol.Var]
fresh_typed_var [Fol.Var]
fresh_var [Fol_gformula.Pool]
fresh_var [Fol.Var]
fresh_vars [Store_mem.Create]
fresh_vars_in_pred [Fol]
freshen [Formula.S]
freshen [Fol_gformula.Pool]
freshen [Datalib.Create]
freshen [Caveat_fol]
freshen_sigma [Datalib.Create]
from_bits [Runtime_mem.Create.RtLib]
fterm_of_addr [Caveat_mem.Make.Export]
fterm_of_field [Caveat_mem.Make.Export]
fterm_of_field_access [Caveat_mem.Make.Export]
fterm_of_havoc_field [Caveat_mem.Make.Export]
fterm_of_havoc_index [Caveat_mem.Make.Export]
fterm_of_havoc_range [Caveat_mem.Make.Export]
fterm_of_mu_field [Caveat_mem.Make.Export]
fterm_of_mu_index [Caveat_mem.Make.Export]
fterm_of_shift_field [Caveat_mem.Make.Export]
fterm_of_shift_index [Caveat_mem.Make.Export]
fterm_of_shift_pointer [Caveat_mem.Make.Export]
fterm_of_term [Caveat_mem.Make.Export]
fun_load [Funvar_mem.Create]
funvar_offset [Funvar_mem.Create]
funvar_path [Funvar_mem.Create]
fupdate_at_label [Funvar_mem.Create]
fvar_of_cvar [Caveat_fol]
This variable has to be used for the value of v at Here.
fvar_of_cvar_at [Caveat_fol]

G
gaddress_of_cvar [Translate_prop.Create]
gaddress_of_mem [Translate_prop.Create]
gclear [Datalib.Create]
gdummy [Datalib.Create]
get [Wpo.Results]
get [Po_navigator.Prover_Column]
get [String]
String.get s n returns character number n in string s.
get [Cil2cfg]
get [State_builder.Ref]
Get the referenced value.
get_annot_opt [Wp_gui]
get_array_length [Hoare_lib.Create]
build array_length t = sz when we know how to interpet the size sz
get_asgn_goal [WpAnnot]
get_asgn_hyp [WpAnnot]
get_asked_bhv_from_name [WpAnnot]
get_assigns_method [Wp_parameters]
get_axiom [Translate_prop.Create]
get_behav [WpAnnot]
get_behavior_annots [WpAnnot]
get_behavior_names [WpAnnot]
get_behavior_strategies [WpAnnot]
Compute the strategy to prove all the properties of the behavior.
get_behaviors [Wp_parameters]
get_bhv_assumes [WpAnnot]
get_call_out_edges [Cil2cfg]
similar to succ_e g v but gives the edge to VcallOut first and the edge to VcallExit second.
get_cut [WpAnnot]
get_inv only gives the general invariants (not loop invariant)
get_definition [Mdata.S.Registry]
get_definition [Translate_prop.Create]
get_definition [Datalib.Create.Registry]
get_definition [Datalib.Create.Register]
get_edge_labels [Cil2cfg]
get_edge_next_stmt [Cil2cfg]
get_env [Wp_parameters]
get_exit [Store_mem.Create]
get_exit_edges [Cil2cfg]
Find the edges e that goes to the Vexit node inside the statement begining at node n
get_exit_status [Mlogic.S]
get_exit_status [Runtime_mem.Create]
get_exit_status [Store_mem.Create]
get_exit_status [Hoare_mem.Create]
get_exit_status [Funvar_mem.Create]
get_exit_status [Caveat_mem.Make.WP]
get_ext_fct_assigns [WpAnnot]
get_ext_postconditions [WpAnnot]
get_ext_preconditions [WpAnnot]
get_fct_assigns [WpAnnot]
get_fct_post [WpAnnot]
get_frame [Translate_prop.Create]
get_function_strategies [WpAnnot]
Compute the strategies to prove all the properties of the selected function.
get_funvar [Funvar_mem.Create]
get_global_annotations [WpAnnot]
get_goal_only [WpAnnot]
get_hyp_goal [WpAnnot]
the bool in get_cut results says if the property has to be considered as a both goal and hyp (goal=true, or hyp only (goal=false)
get_hyp_only [WpAnnot]
get_id_prop_strategies [WpAnnot]
Compute the strategies to prove the selected property.
get_iloop_header [Cil2cfg.WeiMaoZouChenInput]
get the node innermost loop header if any
get_iloop_header [Cil2cfg.LoopInfo]
get_implicit_fun [WpFroms]
Build the implicit function for the nth assign clause of behavior b in the ki element of function kf.
get_ind [Mdata.S.Indexed]
get_ind [Datalib.Create.Indexed]
get_ind [Datalib.Create.Dindex]
get_induction [WpAnnot]
get_init_linfo [WpFroms]
get_int [Ctypes]
get_internal_edges [Cil2cfg]
Find the edges e of the statement node n postcondition and the set of edges that are inside the statement (e excluded).
get_inv [WpAnnot]
get_linfo [WpFroms]
get_linfo_cpt [WpFroms]
Find the logic_info for the given name and signature.
get_loop_annots [WpAnnot]
get_loop_assigns_for_from [WpAnnot]
get_model [Wp_parameters]
get_models [Wp_parameters]
get_named_bhv [WpAnnot]
get_node [Cil2cfg]
get_norm [Wp_parameters]
get_offset [Funvar_mem.Create.Lookup]
get_only_succ [Calculus.Cfg]
get_output [Wp_parameters]
get_pos [Cil2cfg.WeiMaoZouChenInput]
get the previously stored position of the node or 0 if nothing has been stored
get_pos [Cil2cfg.LoopInfo]
get_pos_if_traversed [Cil2cfg.WeiMaoZouChenInput]
get the previously stored position of the node if any, or None if set_pos hasn't been called already for this node.
get_pos_if_traversed [Cil2cfg.LoopInfo]
get_pred_linfo [WpFroms]
get_prop_strategies [WpAnnot]
Similar to get_id_prop_strategies but with a named property.
get_properties [Wp_parameters]
get_provers [Wp_parameters]
get_range_index [Mdata.S]
get_range_index [Datalib]
get_range_index [Datalib.Create]
get_read_addr [Caveat_mem.Make.WP]
Collect the addresses of locations read by p.
get_result [Wpo]
get_result [Store_mem.Create]
get_results [Wpo]
get_share [Wp_parameters]
get_spec_assigns [WpAnnot]
get_stmt [WpAnnot]
get_stmt_annots [WpAnnot]
get_stmt_node [Cil2cfg]
In some cases (goto for instance) we have to create a node before having processed if through cfg_stmt.
get_strategies [WpAnnot]
get_subgraph [Cil2cfg.Printer]
get_switch_edges [Cil2cfg]
similar to succ_e g v but give the switch cases and the default edge
get_terminates [WpAnnot]
get_test_edges [Cil2cfg]
Get the edges going out a test node with the then branch first
get_user_variable [Translate_prop.Create]
get_var [Hoare_mem.Create]
Get the wp variable of the C variable.
get_var [Caveat_mem.Make.WP]
Get the wp variable of the C variable.
get_var [Caveat_fol]
Get the wp variable of the C variable.
get_var_and_mu [Hoare_mem.Create]
get_var_and_mu [Caveat_mem.Make.WP]
get_variant [WpAnnot]
get_weakest_precondition [Calculus.Cfg]
get_wp_edge [Calculus.Cfg]
gfresh [Datalib.Create]
gid [Wpo]
gindex [Datalib.Create]
gindexref [Datalib.Create]
global_frame [Caveat_mem.Make.WP]
globalhints [Axiomatics]
goal [Prover.Coq]
goal [Prover.Why]
goal_to_select [WpAnnot]
graph_attributes [Cil2cfg.Printer]
gsection [Datalib.Create]
gstartof [Translate_prop.Create]
gstartof_cvar [Translate_prop.Create]
gstartof_mem [Translate_prop.Create]
gstartof_value [Translate_prop.Create]
guard [Mdata.S]
guard [Datalib.Create]
guards_with [Datalib.Create]
gui_provers [Wpo]

H
has_asgn_goal [WpAnnot]
has_exit [Cil2cfg]
wether an exit edge exists or not
has_prefix [Clabels]
has_prop_goal [WpAnnot]
has_reserved_prefix [Datalib]
Returns true iff the string contains '_' and the prefix ending at the first '_' is a reserved prefix.
has_type [Mdata.S]
has_type [Datalib.Create]
has_type_int [Datalib.Create]
has_var [Datalib.Create]
has_vars [Mdata.S]
has_vars [Datalib.Create]
hash [Datatype.Set]
hash [Ctypes.AinfoComparable]
hash [Ctypes]
hash [Cil2cfg.VL]
hash [Datalib.Create.LTinfo]
havoc [Runtime_mem.Create.RtLib]
havoc_field [Hoare_lib.Create.Hlib]
havoc_index [Hoare_lib.Create.Hlib]
havoc_inductive [Mdata.S]
havoc_inductive [Datalib.Create]
havoc_region [CfgWeakestPrecondition.Create]
havoc_static [Mdata.S]
havoc_static [Datalib.Create]
havoc_ufield [Hoare_lib.Create.Hlib]
hint_context [Translate_prop.Create]
hints [Translate_prop.Create]
huge_pred [Formula.S]
huge_pred [Fol_formula]
huge_pred [Fol]
huge_pred [Caveat_fol]
huge_term [Formula.S]
huge_term [Fol_formula]
huge_term [Fol]
huge_term [Caveat_fol]

I
i_bool [Whylib]
i_cmp [Mint.S]
i_cmp [Mint_natural.Create]
i_compare [Fol]
i_compute [Fol]
i_convert [Mdata.S]
i_convert [Ctypes]
i_convert [Datalib.Create]
i_neg [Mint.S]
i_neg [Mint_natural.Create]
i_op [Mint.S]
i_op [Whylib]
i_op [Mint_natural.Create]
i_pred [Whylib]
i_sizeof [Ctypes]
icmp_operator [Translate_expr.Create]
id_of_id_assigns [WpAnnot]
id_of_id_pred [WpAnnot]
id_prop_txt [WpAnnot]
ident [Script]
ident_named_var [Fol.Var]
identifier [Datalib]
identify_loops [Cil2cfg.WeiMaoZouChen]
idents [Script]
idx [Ctypes]
imemo [Ctypes]
in_range [Data_mem.Create]
included [Region.Create]
included [Fol_split]
included_bases [Region.Create]
included_cvars [Region.Create]
included_find [Region.Create]
included_ranges [Region.Create]
included_roots [Region.Create]
included_zone_in_bases [Region.Create]
included_zone_in_cvars [Region.Create]
included_zone_in_roots [Region.Create]
incr [Cil2cfg.LoopInfo]
incr_xi [Cil2cfg.WeiMaoZouChenInput]
the unstructuredness coefficient k can be computed = 1+(xi+yi)/E when E is the number of edge in the graph.
incr_xi [Cil2cfg.LoopInfo]
incr_yi [Cil2cfg.WeiMaoZouChenInput]
incr_yi [Cil2cfg.LoopInfo]
index [Mvalues.S]
index tab tau k computes the location of tab[k], where tab is an array with elements of type tau.
index [Mvalues.Data]
index [Mdata.S.Identifiable]
index [Runtime_mem.Create.Data]
index [Store_mem.Create.Data]
index [Hoare_mem.Create]
index [Region.Create]
index b k is the cell at index k in block k.
index [Funvar_mem.Create]
index [String]
String.index s c returns the character number of the first occurrence of character c in string s.
index [Translate_prop.Create.UserAxiomDefs]
index [Translate_prop.Create.UserDefinition]
index [Datalib.Create.Identifiable]
index [Datalib.Create.LTinfoId]
index [Datalib.Create.Logicvar]
index [Datalib.Create.LTypeinfo]
index [Datalib.Create.Arrayinfo]
index [Datalib.Create.Compinfo]
index [Datalib.Create.Fieldinfo]
index [Datalib.Create.Varinfo]
index [Caveat_mem.Make.WP]
index_from [String]
String.index_from s i c returns the character number of the first occurrence of character c in string s after position i.
indir [Caveat_mem.Make.WP.CavLib]
indir [Caveat_mem.Make.WP]
d should be a data that represent an adddress:
indir [Caveat_fol]
indir_at [Caveat_fol]
indir_here [Caveat_fol]
init [Cil2cfg.WeiMaoZouChenInput]
build a new env from a graph, and also return the entry point of the graph which has to be unique.
init [Cil2cfg.LoopInfo]
init_cfg [Cil2cfg]
init_env [Fol_eqs]
instance_of_hint [Translate_prop.Create]
instantiate [Translate_prop.Create]
int_cmp [Translate_prop.Create]
int_format [Mdata.S]
int_format [Datalib.Create]
int_format_for_hyp [Runtime_mem.Create]
int_of_value [Translate_expr.Create]
int_op [Translate_prop.Create]
int_operator [Translate_expr.Create]
integer_of_data [Translate_prop.Create]
integer_of_real [Formula.S]
integer_of_real [Whylib.Create]
integer_of_real [Whylib]
integer_of_value [Translate_prop.Create]
integer_of_xaddr [Runtime_mem.Create.Tint]
integers [Datalib.Create]
inter [Mdata.S]
inter s0 s1 returns the intersection set of s0 and s1.
inter [Set.S]
Set intersection.
inter [Datalib.Create]
internal_function_behaviors [WpAnnot]
internal_kind [Dashtbl.Graph]
internal_pretty_code [Datatype.Set]
interval [Mdata.S]
range l h returns the integer set s such as { i in s | l <= i <= h }.
interval [Datalib.Create]
ip_complete [WpAnnot]
ip_contract [WpAnnot]
ip_disjoint [WpAnnot]
ip_external [WpAnnot]
is_annot_for_config [WpAnnot]
is_assigns [WpAnnot]
is_atomic [Region.Create]
is_back_edge [Cil2cfg]
is_composed [WpAnnot]
whether a proof needs several lemma to be complete
is_empty [Hook.S]
Is no function already registered in the hook?
is_empty [Region.Create]
is_empty [Map.S]
Test whether a map is empty or not.
is_empty [Set.S]
Test whether a set is empty or not.
is_error [Prover.Log]
is_false [Formula.S]
is_false [Fol_gformula.Predicate]
is_funvar [Vaddr]
is_havoc [Runtime_mem.Create.RtLib]
is_interactive [Wpo]
is_irreducible [Cil2cfg.LoopInfo]
is_local [State_builder.Dashtbl]
is_null [Mdata.S]
Take a term representing an address and returns a term of type bool.
is_null [Datalib.Create]
is_proved [WpAnnot]
wether all partial proofs have been accumulated or not
is_requires [WpAnnot]
is_true [Formula.S]
is_true [Fol_gformula.Predicate]
is_zone [Fol_split]
iter [Mdata.S]
iter [Wpo.Results]
iter [Wpo]
iter [State_builder.Dashtbl]
iter [Map.S]
iter f m applies f to all bindings in map m.
iter [String]
String.iter f s applies function f in turn to all the characters of s.
iter [State_builder.Hashtbl]
iter [Hashtbl.S]
iter [Set.S]
iter f s applies f in turn to all elements of s.
iter [Datalib.Create]
iter_all [Mdata.S]
iter_all [Datalib.Create]
iter_bases [Region.Create]
iter_description [Cfgpropid.Create]
iter_dnodes [Cfgpropid]
iter_edges [Cil2cfg]
iter_edges_e [Cil2cfg.Printer]
iter_key [State_builder.Dashtbl]
iter_nodes [Cil2cfg]
iter_others [Region.Create]
iter_pred_e [Cil2cfg]
iter_succ [Cil2cfg]
iter_vertex [Cil2cfg.Printer]

J
job [Wp_parameters]

K
key [Script]
keywords [Script]
ki_assigns_labels [WpAnnot]
kill [Mdata.S]
kill [Datalib.Create]
kill_context [Translate_prop.Create]
kind [Wprop.Info]
kind [Wprop.Actor]
kind_of [Translate_prop.Create]
kind_of_data [Translate_prop.Create]
kind_of_typ [Translate_prop.Create]
kind_of_var [Formula.S]
kind_of_var [Fol_gformula.Pool]
kind_of_var [Fol.Var]
kind_of_var [Caveat_fol]
kind_order [WpAnnot]
kindex [Wprop]

L
label [Mcfg.S]
label [Clabels]
label [Cfgpropid.Create]
label [CfgWeakestPrecondition.Create]
label_at_closure [Mlogic.S]
label_at_closure [Runtime_mem.Create]
label_at_closure [Store_mem.Create]
label_at_closure [Hoare_mem.Create]
label_at_closure [Funvar_mem.Create]
label_at_closure [Caveat_mem.Make.WP]
label_name [Axiomatics]
label_of_kind [WpAnnot]
label_of_prop_id [WpAnnot]
Short description of the kind of PO
labels_assert_after [NormAtLabels]
labels_assert_before [NormAtLabels]
labels_axiom [NormAtLabels]
labels_empty [NormAtLabels]
labels_fct_assigns [NormAtLabels]
labels_fct_post [NormAtLabels]
labels_fct_pre [NormAtLabels]
labels_loop_assigns [NormAtLabels]
labels_loop_inv [NormAtLabels]
labels_predicate [NormAtLabels]
labels_stmt_assigns [NormAtLabels]
labels_stmt_post [NormAtLabels]
labels_stmt_pre [NormAtLabels]
language_of_name [Wpo]
language_of_prover [Wpo]
le_int [Whylib]
le_int_bool [Whylib]
le_pointer [Mdata.S]
le_pointer p q is the less than or equal comparison of pointers p and q, that points to elements of type ty, ie.
le_pointer [Datalib.Create]
le_pointer_bool [Mdata.S]
le_pointer_bool p q is the less than or equal comparison of pointers p and q, that points to elements of type ty, ie.
le_pointer_bool [Datalib.Create]
le_real [Whylib]
le_real_bool [Whylib]
length [State_builder.Dashtbl]
length [Hook.S]
Number of registered functions.
length [String]
Return the length (number of characters) of the given string.
length [State_builder.Hashtbl]
Length of the table.
length [Hashtbl.S]
let_expansion [Fol_eval]
let_pred [Fol]
Build a predicate equivalent to let v = e in p but may use the substitution in some simple cases (like substitute a variable by another variable for instance).
list_of [Translate_prop.Create]
load [Mvalues.S]
load [Runtime_mem.Create.RtLib]
load [Runtime_mem.Create]
load [Store_mem.Create]
load [Hoare_mem.Create]
load [Funvar_mem.Create]
load [Caveat_mem.Make.WP]
load_mem [Mvalues.Data]
load_mem [Runtime_mem.Create.Data]
Read a data of type te at loc and returns it as a logic value.
load_mem [Store_mem.Create.Data]
load_mem [Store_mem.Create]
load_rec [Store_mem.Create.Data]
load_with [Store_mem.Create]
loaded [Data_mem.Create]
loadscripts [Proof]
Load scripts from -wp-script f.
loc_of_data [Translate_prop.Create]
loc_of_funloc [Funvar_mem.Create]
loc_of_path [Funvar_mem.Create]
loc_of_pointer [Mvalues.Model]
loc_of_pointer [Runtime_mem.Create.Model]
loc_of_pointer [Store_mem.Create.Model]
loc_of_pointer [Hoare_mem.Create.Model]
loc_of_pointer [Funvar_mem.Create.Model]
loc_of_pointer [Datalib.Cvalues]
loc_of_pointer [Caveat_mem.Make.WP.Model]
loc_of_value [Translate_expr.Create]
loc_offset [Translate_prop.Create]
loc_range [Datalib.Create]
local [Wpo]
local_scope [Mwp.S]
local_scope m l transforms the predicate p at the enter-point of a block or function that declares the local variables in the list.
local_scope [Runtime_mem.Create]
local_scope [Store_mem.Create]
local_scope [Hoare_mem.Create]
process local scope : bool=true for allocation, false for free
local_scope [Funvar_mem.Create]
local_scope [Caveat_mem.Make.WP]
location [Mdata.S.Identifiable]
location [Datalib.Create.Identifiable]
location [Datalib.Create.LTinfoId]
location [Datalib.Create.Logicvar]
location [Datalib.Create.LTypeinfo]
location [Datalib.Create.Arrayinfo]
location [Datalib.Create.Compinfo]
location [Datalib.Create.Fieldinfo]
location [Datalib.Create.Varinfo]
locked [Datalib.Create]
logic_data [Caveat_mem.Make.WP]
logic_of_mem [Runtime_mem.Create]
logic_of_value [Mvalues.Values]
logic_of_value [Datalib.Cvalues]
logic_offset [Translate_prop.Create]
lookup [Clabels]
lookup bindings lparam retrieves the actual label for the label in bindings for label parameter lparam.
loop_head_label [Cil2cfg]
loop_node_edges [Cil2cfg]
loop_nodes [Cil2cfg]
loop_stmts [Cil2cfg]
lowercase [String]
Return a copy of the argument, with all uppercase letters translated to lowercase, including accented letters of the ISO Latin-1 (8859-1) character set.
lt_int [Whylib]
lt_int_bool [Whylib]
lt_pointer [Mdata.S]
lt_pointer p q is the less than comparison of pointers p and q, that points to elements of type ty, ie.
lt_pointer [Datalib.Create]
lt_pointer_bool [Mdata.S]
lt_pointer_bool p q is the less than comparison of pointers p and q, that points to elements of type ty, ie.
lt_pointer_bool [Datalib.Create]
lt_real [Whylib]
lt_real_bool [Whylib]
lvar [Translate_prop.Create]
lvar_of_variable [Fol.Var]

M
main [Wp_gui]
main [Register]
make [String]
String.make n c returns a fresh string of length n, filled with the character c.
make_c_float [Ctypes]
make_c_int [Ctypes]
make_goal [Runtime_mem.Create]
make_goal [Cfgpropid.Create]
make_logic_info [WpFroms]
Build a logic_info with fname and the signature given by (out_type, in_types) (see WpFroms.mk_linfo_type) TODO: should be Cil_const.make_logic_info when it be finished.
make_panel [Po_navigator]
malloc_of_mem [Runtime_mem.Create]
map [Map.S]
map f m returns a map with same domain as m, where the associated value a of all bindings of m has been replaced by the result of the application of f to a.
mapi [Map.S]
Same as Map.S.map, but the function receives as arguments both the key and the associated value for each binding of the map.
mark_loops [Cil2cfg]
massigned [Funvar_mem.Create]
max_elt [Set.S]
Same as Set.S.min_elt, but returns the largest element of the given set.
mbits_of_mem [Runtime_mem.Create]
mem [State_builder.Dashtbl]
mem [Map.S]
mem x m returns true if m contains a binding for x, and false otherwise.
mem [State_builder.Hashtbl]
mem [Hashtbl.S]
mem [Set.S]
mem x s tests whether x belongs to the set s.
mem_at [Mlogic.S]
mem_at e l returns the memory associates to the label l in the environment e.
mem_at [Runtime_mem.Create]
mem_at [Store_mem.Create]
mem_at [Hoare_mem.Create]
gives the memory state for that label.
mem_at [Funvar_mem.Create]
mem_at [Caveat_mem.Make.WP]
gives the memory state for that label.
mem_at_env [Translate_prop.Create]
mem_project [Datatype.Set]
memo [State_builder.Dashtbl]
memo [State_builder.Hashtbl]
Memoization.
memory_offset [Translate_prop.Create]
merge [Mcfg.S]
merge [Cfgpropid.Create]
merge [Translate_prop.Create]
merge [CfgWeakestPrecondition.Create]
merge_acc [WpAnnot]
merge_assigns [WpAnnot]
merge_assigns [CfgWeakestPrecondition.Create]
merge_property [CfgWeakestPrecondition.Create]
merge_with [CfgWeakestPrecondition.Create]
min_elt [Set.S]
Return the smallest element of the given set (with respect to the Ord.compare ordering), or raise Not_found if the set is empty.
minus_pointer [Mdata.S]
minus_pointer ty p q is the arithmetics difference of pointers p and q, that points to elements of type ty, ie.
minus_pointer [Datalib.Create]
missing_rte [WpAnnot]
mk_access_ufield [Datalib]
mk_annot_id [WpAnnot]
mk_array_format [Datalib]
mk_assign_annots_for_froms [WpAnnot]
mk_assign_post [WpFroms]
Build P(output)
mk_assign_pre [WpFroms]
Build xi = Init (i) /\ ... forall inputs.
mk_assign_strategy_for_froms [WpAnnot]
mk_axiom_id [WpAnnot]
mk_code_annot_id [WpAnnot]
mk_compl_bhv_id [WpAnnot]
mk_decrease_id [WpAnnot]
mk_def [Fol_cc]
mk_disj_bhv_id [WpAnnot]
mk_empty [Datalib]
mk_eq_array [Datalib]
mk_eq_array_bool [Datalib]
mk_eq_record [Datalib]
mk_eq_record_bool [Datalib]
mk_eq_urecord [Datalib]
mk_eq_urecord_bool [Datalib]
mk_equal_pointer_bool [Datalib]
mk_establish_id [WpAnnot]
mk_exit_assigns_id [WpAnnot]
mk_fct_post_id [WpAnnot]
mk_fformat [Datalib]
mk_fguard [Datalib]
mk_fout_assigns_id [WpAnnot]
mk_iformat [Datalib]
mk_iguard [Datalib]
mk_imodulo [Datalib]
mk_int_format [Datalib]
mk_integers [Datalib]
mk_inter [Datalib]
mk_inv_hyp_id [WpAnnot]
mk_is_null [Datalib]
mk_le_pointer [Datalib]
mk_le_pointer_bool [Datalib]
mk_let [Caveat_fol]
mk_linfo_type [WpFroms]
Build the logic type of the function that takes parameters of in_types and return an out_type result (None for a predicate)
mk_logic_label [Cil2cfg]
create a virtual label to a statement (it can have no label)
mk_loop_assigns_id [WpAnnot]
mk_lt_pointer [Datalib]
mk_lt_pointer_bool [Datalib]
mk_lvar_variable [Fol.Var]
mk_minus_pointer [Datalib]
mk_mu [Hoare_mem.Create]
compute m_0 where : mu_i = mu (obj_(i-1), d_i -> mu_(i+1)) and at the last step (n), mu_(n+1) = exp.
mk_mu [Caveat_mem.Make.WP]
mk_mu [Caveat_fol]
mk_mu_range [Caveat_fol]
mk_mu_range_indir [Caveat_fol]
mk_mu_sh_indir [Caveat_fol]
mk_null [Datalib]
mk_pointer_format [Datalib]
mk_pre_id [WpAnnot]
mk_predicate_id [WpAnnot]
mk_preserve_id [WpAnnot]
mk_prop [WpAnnot]
mk_radd [Datalib]
mk_range [Datalib]
mk_range_inf [Datalib]
mk_range_sup [Datalib]
mk_real_format [Datalib]
mk_record_format [Datalib]
mk_remove [Datalib]
mk_rmult [Datalib]
mk_rneg [Datalib]
mk_round [Datalib]
mk_singleton [Datalib]
mk_stmt_assigns_id [WpAnnot]
mk_stmt_post_id [WpAnnot]
mk_union [Datalib]
mk_update_ufield [Datalib]
mk_urecord_format [Datalib]
mk_v_array_length [Hoare_lib.Create]
mk_var_decr_id [WpAnnot]
mk_var_pos_id [WpAnnot]
mk_variant_properties [WpAnnot]
mk_xzone [Runtime_mem.Create.Tint]
mloc_of_loc [Funvar_mem.Create]
mloc_of_path [Funvar_mem.Create.Lookup]
mod_int [Whylib]
model_access [Store_mem.Create]
model_access_range [Store_mem.Create]
model_addr [Store_mem.Create]
model_addr_of_pointer [Store_mem.Create]
model_addr_shift [Store_mem.Create]
model_alloc [Store_mem.Create]
model_base [Store_mem.Create]
model_block [Store_mem.Create]
model_free [Store_mem.Create]
model_included [Store_mem.Create]
model_isfresh [Store_mem.Create]
model_ishavoc [Store_mem.Create]
model_names [Wp_parameters]
model_of_name [Wp_parameters]
model_offset [Store_mem.Create]
model_offset_of_pointer [Store_mem.Create]
model_pointer_of_addr [Store_mem.Create]
model_separated [Store_mem.Create]
model_update [Store_mem.Create]
model_update_havoc [Store_mem.Create]
model_update_range [Store_mem.Create]
model_valid [Store_mem.Create]
model_zempty [Store_mem.Create]
model_zrange [Store_mem.Create]
model_zrange_of_addr_range [Store_mem.Create]
model_zunion [Store_mem.Create]
modulo [Mdata.S]
modulo [Datalib.Create]
most_suitable [Proof]
mu_indir [Caveat_mem.Make.WP.CavLib]
mu_range_indir [Caveat_mem.Make.WP.CavLib]
similat to D1.set_range_index but for pointer
mul [Store_mem.Create]
mul_int [Whylib]
mul_real [Whylib]
mult [Runtime_mem.Create.Aint]
mult_set [Mdata.S]
mult_set [Datalib.Create]
mvalue_of_value [Funvar_mem.Create]

N
n_size [Store_mem.Create]
name [Wprop.Actor]
name [Wp_error]
name [Datatype.Set]
name [CfgProof.Description]
Public name for user feedback
name_of_field [Runtime_mem.Create]
name_of_var [Formula.S]
name_of_var [Runtime_mem.Create]
name_of_var [Fol_gformula.Pool]
name_of_var [Caveat_fol]
names_at [Clabels]
ne_int [Whylib]
ne_int_bool [Whylib]
ne_real [Whylib]
ne_real_bool [Whylib]
needback [Proof]
needsave [Proof]
neg_int [Whylib]
neg_interval [Translate_prop.Create]
neg_real [Whylib]
neg_set [Mdata.S]
neg_set [Datalib.Create]
new_cfg_env [Cil2cfg]
new_env [Mcfg.S]
new_env [Wpo]
Generates a fresh environment name.
new_env [Cfgpropid.Create]
new_env [CfgWeakestPrecondition.Create]
new_fname [Fol_eval]
new_frame [Mlogic.S]
new_frame [Runtime_mem.Create]
new_frame [Store_mem.Create]
new_frame [Hoare_mem.Create]
new_frame [Funvar_mem.Create]
new_frame [Caveat_mem.Make.WP]
new_fun_frame [Funvar_mem.Create]
new_loop_computation [WpAnnot]
new_loops [WpAnnot]
new_mem [Runtime_mem.Create]
new_mem [Hoare_mem.Create]
new_name [Fol_eqs]
new_name [Fol_cc]
newline [Script]
next_edge [Cil2cfg]
no_quantif_do_exp [Fol]
node_after [Cil2cfg]
Find the node that follows the input node statement.
node_id [Cil2cfg]
node_stmt_exn [Cil2cfg]
node_stmt_opt [Cil2cfg]
node_type [Cil2cfg]
node_type_id [Cil2cfg]
gives a identifier to each CFG node in order to hash them
normalize [Fol_norm]
not_of_float [Translate_expr.Create]
not_of_int [Translate_expr.Create]
not_of_integer [Translate_expr.Create]
not_of_ptr [Translate_expr.Create]
not_of_value [Translate_expr.Create]
not_yet_implemented [Wp_error]
notexists_vars [Store_mem.Create]
null [Mdata.S]
null return the special location of the memory model designing the null pointer.
null [Datalib.Create]
null [Caveat_mem.Make.WP]
null [Caveat_fol]

O
object_of [Ctypes]
object_of_pointed [Ctypes]
c_objects of elements pointed to by pointer or array.
object_of_pointed [Translate_prop.Create]
occur_check [Datalib.Create]
of_int [Runtime_mem.Create.Aint]
of_int64 [Runtime_mem.Create.Aint]
of_name [Prover.SMT]
of_term [Runtime_mem.Create.Aint]
offset [Store_mem.Create.Data]
offset [Store_mem.Create.Model]
offset_of_field [Store_mem.Create]
on_all_functions [Register]
on_array [Data_mem.Create.Compound]
on_clear [Mdata.S]
on_clear [Datalib.Create]
on_context [CfgWeakestPrecondition.Create]
on_definition [Mdata.S.Registry]
on_definition [Register]
on_definition [Datalib.Create.Registry]
on_definition [Datalib.Create.Register]
on_function [Register]
on_function_names [Register]
on_record [Data_mem.Create.Compound]
on_reset [Wp_parameters]
once [Prover.Coq]
one [Store_mem.Create]
open_file [Script]
opt_env [Funvar_mem.Create]
opt_mem [Funvar_mem.Create]
option [Register]
output [Prover.Log]

P
p_alpha_cv [Formula.S]
easier to use when doing a simple alpha conversion.
p_alpha_cv [Fol_formula]
p_alpha_cv [Fol]
p_alpha_cv [Caveat_fol]
p_and [Formula.S]
p_and [Fol_gformula.Predicate]
p_and [Fol]
p_app [Fol]
p_app0 [Mdata.S]
p_app0 [Datalib.Create]
p_app1 [Mdata.S]
p_app1 [Datalib.Create]
p_app2 [Mdata.S]
p_app2 [Datalib.Create]
p_app3 [Mdata.S]
p_app3 [Datalib.Create]
p_app4 [Mdata.S]
p_app4 [Datalib.Create]
p_app5 [Mdata.S]
p_app5 [Datalib.Create]
p_block [Region.Create]
p_bool [Formula.S]
p_bool [Fol_gformula.Predicate]
p_call [Formula.Vernacular]
p_call [Fol_gformula.Langage]
p_closed [Fol]
p_cond [Formula.S]
p_cond [Fol_gformula.Predicate]
p_conj [Formula.S]
p_conj [Fol_gformula.Predicate]
p_conj [Fol]
p_disj [Formula.S]
p_disj [Fol_gformula.Predicate]
p_disj [Fol]
p_eq [Formula.S]
p_eq [Fol_gformula.Predicate]
p_eq [Fol]
p_exists [Formula.S]
p_exists [Fol_gformula.Predicate]
p_exists [Fol]
p_exists [Caveat_fol]
p_exists_vars [Fol]
p_false [Formula.S]
p_false [Fol_gformula.Predicate]
p_field [Region.Create]
p_forall [Formula.S]
p_forall [Fol_gformula.Predicate]
p_forall [Fol]
p_forall [Caveat_fol]
p_forall_vars [Fol]
p_has_var [Fol]
p_icmp [Formula.S]
p_icmp [Whylib.Create]
p_if [Fol]
p_iff [Formula.S]
p_iff [Fol_gformula.Predicate]
p_iff [Fol]
p_implies [Formula.S]
p_implies [Fol_gformula.Predicate]
p_implies [Fol]
p_index [Region.Create]
p_interval [Region.Create]
p_let [Fol]
p_more_alpha_cv [Formula.S]
alpha', p' = p_more_alpha_cv alpha p build p' from p by renaming all the variable v into v' according to the mapping alpha.
p_more_alpha_cv [Fol_formula]
p_more_alpha_cv [Caveat_fol]
p_named [Formula.S]
p_named [Fol_gformula.Predicate]
p_named [Fol]
p_neq [Formula.S]
p_neq [Fol_gformula.Predicate]
p_neq [Fol]
p_not [Formula.S]
p_not [Fol_gformula.Predicate]
p_not [Fol]
p_or [Formula.S]
p_or [Fol_gformula.Predicate]
p_or [Fol]
p_range [Region.Create]
p_rcmp [Formula.S]
p_rcmp [Whylib.Create]
p_subst [Formula.S]
p_subst [Fol_gformula.Predicate]
p_subst [Caveat_fol]
p_true [Formula.S]
p_true [Fol_gformula.Predicate]
p_unfold [Fol_split]
p_xor [Formula.S]
p_xor [Fol_gformula.Predicate]
p_xor [Fol]
packed_descr [Datatype.Set]
parse_coqproof [Proof]
parse_coqproof f parses a coq-file f and fetch the first proof.
parse_scripts [Proof]
parse_scripts f parses all scripts from file f and put them in the database.
part_of_item [Datalib.Create]
partition [Set.S]
partition p s returns a pair of sets (s1, s2), where s1 is the set of all the elements of s that satisfy the predicate p, and s2 is the set of all the elements of s that do not satisfy p.
path [Region.Create]
path_has_var [Caveat_fol]
pcmp_operator [Translate_expr.Create]
pcmp_rel [Translate_expr.Create]
pid_for_function [WpAnnot]
pint_cmp [Translate_prop.Create]
plus [Translate_prop.Create]
plus_interval [Translate_prop.Create]
plus_interval_interval [Translate_prop.Create]
pointer_format [Mdata.S]
pointer_format [Datalib.Create]
pointer_of_loc [Mvalues.Model]
pointer_of_loc [Runtime_mem.Create.Model]
pointer_of_loc [Store_mem.Create.Model]
pointer_of_loc [Hoare_mem.Create.Model]
pointer_of_loc [Funvar_mem.Create.Model]
pointer_of_loc [Datalib.Cvalues]
pointer_of_loc [Caveat_mem.Make.WP.Model]
pointer_of_xaddr [Runtime_mem.Create.Tint]
Notice that pointer_of_loc and loc_of_pointer are abstract operations to switch between generic part and model part.
pool [Mdata.S]
pool [Formula.S]
pool [Fol_gformula.Pool]
pool [Datalib.Create]
pool [Caveat_fol]
pop [Mdata.S]
pop [Datalib.Collector]
pop [Datalib.Create]
pop_instances [Translate_prop.Create]
post_of_assigns_in_spec [WpFroms]
For each behavior of the specification, return a predicate which is a conjonction of out_i = implicit_fun_i (inputs) for each out_i \from inputs assigns property of the behavior.
pp_addr [Mdata.Addr]
pp_addr [Runtime_mem.Create.Tint]
pp_annots [WpAnnot]
pp_args [Fol_ergo]
pp_args [Fol_coq]
pp_asked_prop [WpAnnot]
pp_assign [Wp_error]
pp_assigns [Wp_error]
pp_assigns_mode [WpAnnot]
pp_axiomdef_descr [Translate_prop.Create.UserAxiomDefs]
pp_axiomdef_title [Translate_prop.Create.UserAxiomDefs]
pp_binding [Datalib.Create]
pp_bindings [Datalib.Create]
pp_block [Fol_pretty]
pp_block [Fol_ergo]
pp_block [Fol_coq]
pp_closure [Mlogic.S]
pp_closure [Runtime_mem.Create]
pp_closure [Store_mem.Create]
pp_closure [Hoare_mem.Create]
pp_closure [Funvar_mem.Create]
pp_closure [Caveat_mem.Make.WP]
pp_closures [Translate_prop.Create]
pp_command [Prover.Log]
pp_ctype [Datalib.Create]
pp_current [Prover.Log]
pp_data [Translate_prop.Create]
pp_data [Caveat_fol.Data]
pp_data [Caveat_fol]
pp_decl [Formula.S]
pp_decl [Fol_pretty.Create]
pp_dependency [Wpo]
pp_descr [Mdata.S.Identifiable]
pp_descr [Cfgpropid.Create]
pp_descr [Datalib.Create.Identifiable]
pp_descr [Datalib.Create.LTinfoId]
pp_descr [Datalib.Create.Logicvar]
pp_descr [Datalib.Create.LTypeinfo]
pp_descr [Datalib.Create.Arrayinfo]
pp_descr [Datalib.Create.Compinfo]
pp_descr [Datalib.Create.Fieldinfo]
pp_descr [Datalib.Create.Varinfo]
pp_dim [Datalib.Create]
pp_dnode [Cfgpropid]
pp_edge [Cil2cfg]
pp_environment [Wpo]
pp_epath [Hoare_mem.Create.Model]
pp_epath [Caveat_fol]
pp_float [Ctypes]
pp_flow [Fol_pretty]
pp_flow [Fol_ergo]
pp_flow [Fol_coq]
pp_formals [Translate_prop.Create]
pp_function [Wpo]
pp_goal [Formula.S]
pp_goal [Wpo]
pp_goal [Fol_pretty.Create]
pp_goal [Cfgpropid.Create]
pp_goal_flow [Wpo]
pp_goalx [Cfgpropid.Create]
pp_hint [Axiomatics]
pp_id [WpAnnot]
pp_int [Ctypes]
pp_interval [Mdata.S]
pp_interval [Datalib.Create]
pp_kind [Mdata.S]
pp_kind [Translate_prop.Create]
pp_kind [Datalib.Create]
pp_labels [Axiomatics]
pp_language [Wpo]
pp_list [Fol_pretty]
pp_list [Fol_ergo]
pp_list [Fol_coq]
pp_list [Cfgpropid]
pp_loc [Mvalues.Model]
pp_loc [Runtime_mem.Create.Model]
pp_loc [Store_mem.Create.Model]
pp_loc [Hoare_mem.Create.Model]
pp_loc [Funvar_mem.Create.Model]
pp_loc [Datalib.Cvalues]
pp_loc [Caveat_mem.Make.WP.Model]
pp_logic_label [Wp_error]
pp_names [WpAnnot]
pp_node [Cil2cfg]
pp_node_type [Cil2cfg]
pp_object [Ctypes]
pp_partial [Translate_prop.Create]
pp_path [Funvar_mem.Create.Lookup]
pp_pred [Formula.S]
pp_pred [Fol_pretty.Create]
pp_pred_atom [Fol_why]
pp_pred_atom [Fol_pretty.Create]
pp_pred_atom [Fol_ergo]
pp_pred_atom [Fol_coq]
pp_pred_debug [Fol_pretty.Create]
pp_pred_vbox [Fol_pretty.Create]
pp_prehint [Axiomatics]
pp_presigma [Axiomatics]
pp_prover [Wpo]
pp_range [Region.Create]
pp_region [Mwp.S]
pp_region [Runtime_mem.Create]
pp_region [Store_mem.Create]
pp_region [Hoare_mem.Create]
pp_region [Region.Create]
pp_region [Funvar_mem.Create]
pp_region [Caveat_mem.Make.WP]
pp_result [Wpo]
pp_sigma [Datalib.Create]
pp_sigma [Axiomatics]
pp_status [Prover.Log]
pp_strategy_info [WpAnnot]
pp_string_list [Wp_error]
pp_tau [Fol_pretty.Create]
pp_tau [Datalib.Tau]
pp_term [Formula.S]
pp_term [Fol_pretty.Create]
pp_term [Caveat_fol.Data]
pp_term [Caveat_fol]
pp_term_opt [Caveat_fol]
pp_title [Mdata.S.Identifiable]
pp_title [Datalib.Create.Identifiable]
pp_title [Datalib.Create.LTinfoId]
pp_title [Datalib.Create.Logicvar]
pp_title [Datalib.Create.LTypeinfo]
pp_title [Datalib.Create.Arrayinfo]
pp_title [Datalib.Create.Compinfo]
pp_title [Datalib.Create.Fieldinfo]
pp_title [Datalib.Create.Varaddr]
pp_title [Datalib.Create.Varinfo]
pp_token [Script]
pp_typelist [Fol_coq]
pp_userdef_descr [Translate_prop.Create.UserDefinition]
pp_userdef_title [Translate_prop.Create.UserDefinition]
pp_value [Mvalues.Values]
pp_value [Datalib.Cvalues]
pp_var [Formula.S]
pp_var [Fol_pretty]
pp_var [Fol_formula]
pp_var [Fol_ergo]
pp_var [Fol_coq]
pp_var [Caveat_fol]
pp_vars [CfgWeakestPrecondition.Create]
pp_vkind [Datalib.Create]
pp_warning [Wpo]
pp_xzone [Runtime_mem.Create.Tint]
preal_cmp [Translate_prop.Create]
pred_alpha_cv [Fol]
pred_alpha_c data_alpha alpha p -> alpha', p'
pred_closed [Formula.S]
pred_closed [Fol_formula]
pred_closed [Caveat_fol]
pred_cmp [Translate_prop.Create]
pred_e [Cil2cfg]
pred_has_var [Formula.S]
pred_has_var [Fol_formula]
pred_has_var [Caveat_fol]
pred_replace [Fol]
predicate [CfgWeakestPrecondition.Create]
predicate_kind_txt [WpAnnot]
predop [Whylib.Create]
prefix [Mdata.S.Identifiable]
prefix [Datalib.Create.Identifiable]
prefix [Datalib.Create.LTinfoId]
prefix [Datalib.Create.Logicvar]
prefix [Datalib.Create.LTypeinfo]
prefix [Datalib.Create.Arrayinfo]
prefix [Datalib.Create.Compinfo]
prefix [Datalib.Create.Fieldinfo]
prefix [Datalib.Create.Varaddr]
prefix [Datalib.Create.Varinfo]
prepare_annot [WpAnnot]
prepare_behaviors_spec [WpAnnot]
prepare_fct_post [WpAnnot]
prepare_guard [Caveat_mem.Make.WP]
prepare_inv_establish [WpAnnot]
prepare_inv_fixpoint [WpAnnot]
prepare_inv_preserve [WpAnnot]
prepare_pre [WpAnnot]
prepare_pre_pred [WpAnnot]
prepare_stmt_spec_post [WpAnnot]
prepare_var_decr [WpAnnot]
prepare_var_pos [WpAnnot]
preproc_annot [NormAtLabels]
preproc_assigns [NormAtLabels]
preproc_label [NormAtLabels]
pretty [Mcfg.S]
pretty [Datatype.Set]
pretty [Ctypes]
pretty [Clabels]
pretty [Cil2cfg.EL]
pretty [Cil2cfg.VL]
pretty [Cfgpropid.Create]
pretty [CfgWeakestPrecondition.Create]
pretty_code [Datatype.Set]
pretty_node [Cil2cfg.WeiMaoZouChenInput]
pretty_node [Cil2cfg.LoopInfo]
pretty_raw_stmt [Cil2cfg.Printer]
process_global_init [Calculus.Cfg]
WP of global initialisations.
process_unreached_annots [WpAnnot]
Get the not yet proved properties of unreachable CFG nodes.
proj [Caveat_fol]
promote [Ctypes]
proof [Script]
prop [Translate_prop.Create]
prop e p interprets an ACSL predicate as a logic predicats in memory model environment e.
prop [Translate_expr.Create]
prop mem e interprets the expressione as a predicate in memory mem *
prop_binop [Translate_expr.Create]
prop_body [Translate_prop.Create]
prop_cast [Translate_expr.Create]
prop_cmp [Translate_expr.Create]
prop_cmp_ptr [Translate_expr.Create]
prop_const [Translate_expr.Create]
prop_icmp [Translate_expr.Create]
prop_main [WpAnnot]
prop_of_float [Translate_expr.Create]
prop_of_int [Translate_expr.Create]
prop_of_integer [Translate_expr.Create]
prop_of_ptr [Translate_expr.Create]
prop_of_value [Translate_expr.Create]
prop_rcmp [Translate_expr.Create]
prop_rec [Translate_expr.Create]
prop_txt [WpAnnot]
generates an unique name for a given PO.
prop_unop [Translate_expr.Create]
property [Wprop.Indexed]
property [Wprop.Indexed2]
property_of_id [WpAnnot]
returns the annotation which lead to the given PO.
protect [Wp_error]
protect_map [Wp_error]
protect_translation [Wp_error]
protect_translation3 [Wp_error]
protect_translation4 [Wp_error]
protect_translation5 [Wp_error]
protect_warning [Wp_error]
prove [Prover.Coqide]
prove [Prover.Coq]
prove [Prover.AltErgo]
prove [Prover.SMT]
prove [Prover]
proved [WpAnnot]
prover_names [Wp_parameters]
prover_of_name [Wpo]
ptr [Caveat_mem.Make.WP.CavLib]
Used to specify the pointer data in which we can safely ignore muI.
ptr_cmp [Translate_prop.Create]
ptr_rel [Translate_prop.Create]
push [Mdata.S]
push [Datalib.Collector]
push [Datalib.Create]
push_context [Translate_prop.Create]
push_instances [Translate_prop.Create]

Q
quant_env [Translate_prop.Create]
quantify_at_label [Mwp.S]
quantify_at_label frame l p quantifies the free variables in p representing the state at label l to the current memory.
quantify_at_label [Runtime_mem.Create]
quantify_at_label [Store_mem.Create]
quantify_at_label [Hoare_mem.Create]
quantify_at_label [Funvar_mem.Create]
quantify_at_label [Caveat_mem.Make.WP]

R
r_bool [Whylib]
r_op [Whylib]
r_pred [Whylib]
range [Region.Create]
range b k n builds a region of length n starting at offset k in the block of base b.
range_disjoint [Region.Create]
range_empty [Region.Create]
range_inf [Datalib.Create]
range_subset [Region.Create]
range_sup [Datalib.Create]
rcontains_from [String]
String.rcontains_from s stop c tests if character c appears in s before position stop+1.
real_cmp [Translate_prop.Create]
real_format [Mdata.S]
real_format [Datalib.Create]
real_from_bits [Runtime_mem.Create]
real_of_data [Translate_prop.Create]
real_of_integer [Formula.S]
real_of_integer [Whylib.Create]
real_of_integer [Whylib]
real_of_value [Translate_prop.Create]
real_op [Translate_prop.Create]
rec_apply_function [Translate_prop.Create]
rec_apply_predicate [Translate_prop.Create]
record_format [Mdata.S]
record_format [Data_mem.Create]
record_format [Datalib.Create]
record_of_data [Translate_prop.Create]
region [Store_mem.Create]
region_assigned [Mwp.S]
region_assigned [Runtime_mem.Create]
region_assigned [Store_mem.Create]
region_assigned [Hoare_mem.Create]
region_assigned [Funvar_mem.Create]
region_assigned [Caveat_mem.Make.WP]
region_assigns [CfgWeakestPrecondition.Create]
region_empty [Mwp.S]
region_empty [Runtime_mem.Create]
region_empty [Store_mem.Create]
region_empty [Hoare_mem.Create]
region_empty [Funvar_mem.Create]
region_empty [Caveat_mem.Make.WP]
region_fingerprint [Mwp.S]
region_fingerprint [Runtime_mem.Create]
region_fingerprint [Store_mem.Create]
region_fingerprint [Hoare_mem.Create]
region_fingerprint [Funvar_mem.Create]
region_fingerprint [Caveat_mem.Make.WP]
region_included [Mwp.S]
region_included [Runtime_mem.Create]
region_included [Store_mem.Create]
region_included [Hoare_mem.Create]
region_included [Funvar_mem.Create]
region_included [CfgWeakestPrecondition.Create]
region_included [Caveat_mem.Make.WP]
region_of_loc [Store_mem.Create]
region_range [Store_mem.Create]
region_separated [Mwp.S]
region_separated [Runtime_mem.Create]
region_separated [Store_mem.Create]
region_separated [Hoare_mem.Create]
region_separated [Funvar_mem.Create]
region_separated [Caveat_mem.Make.WP]
region_supported [Mwp.S]
region_supported [Runtime_mem.Create]
region_supported [Store_mem.Create]
region_supported [Hoare_mem.Create]
region_supported [Funvar_mem.Create]
region_supported [Caveat_mem.Make.WP]
region_union [Mwp.S]
region_union [Runtime_mem.Create]
region_union [Store_mem.Create]
region_union [Hoare_mem.Create]
region_union [Funvar_mem.Create]
region_union [Caveat_mem.Make.WP]
register [Wpo]
register [Po_navigator.Prover_Column]
register_prefix [Datalib]
register_script [Proof]
rel_op [Translate_prop.Create]
release_env [Wpo]
Releases the last generated environment name.
remove [Mdata.S]
remove s0 s1 returns a set s' such as {b in s' | b in s0 and !(b in s1) }.
remove [Wpo.Results]
remove [State_builder.Dashtbl]
remove [Map.S]
remove x m returns a map containing the same bindings as m, except for x which is unbound in the returned map.
remove [State_builder.Hashtbl]
remove [Hashtbl.S]
remove [Set.S]
remove x s returns a set containing all elements of s, except x.
remove [Datalib.Create]
remove_all [State_builder.Dashtbl]
remove_state [Dashtbl.Graph]
rename [Datalib.Create]
replace [Wpo.Results]
replace [State_builder.Dashtbl]
replace [Cil2cfg.HEsig]
replace [State_builder.Hashtbl]
Add a new binding.
replace [Cil2cfg.HE]
replace [Hashtbl.S]
reprs [Datatype.Set]
require_env [Prover.Coq]
require_model [Prover.Coq]
require_wp [Prover.Coq]
reserved_prefix_tbl [Datalib]
reset [Wp_parameters]
reset_pos [Cil2cfg.WeiMaoZouChenInput]
reset the position (set the position to 0), but should keep the information that the node has been seen already.
reset_pos [Cil2cfg.LoopInfo]
resetdemon [Wp_parameters]
result [Mlogic.S]
result e returns the variable associates to the function result in the environment e.
result [Runtime_mem.Create]
result [Store_mem.Create]
result [Prover]
result [Hoare_mem.Create]
result [Funvar_mem.Create]
result [Caveat_mem.Make.WP]
result_compile [Prover.Coq]
return [Mcfg.S]
return [Cfgpropid.Create]
return [CfgWeakestPrecondition.Create]
reverse [Datalib.Create]
revert_on_error [Prover.Coq]
rindex [String]
String.rindex s c returns the character number of the last occurrence of character c in string s.
rindex_from [String]
String.rindex_from s i c returns the character number of the last occurrence of character c in string s before position i+1.
root [Region.Create]
Create a fresh root, separated from base address of all variables.
roots [Region.Create]
round [Mdata.S]
round [Datalib.Create]
rt_fformat [Runtime_mem.Create.RtLib]
rt_format_of_ctype [Runtime_mem.Create]
rt_global [Runtime_mem.Create.RtLib]
rt_gsize [Runtime_mem.Create.RtLib]
rt_vformat [Runtime_mem.Create.RtLib]
rte_generated [WpAnnot]
rte_wp [WpAnnot]
run [Register]
Use options to know what to do
run_and_prove [Wp_gui]
run_coqide [Prover.Coqide]

S
s_index [Datalib.Create]
saturate [Translate_prop.Create]
savescripts [Proof]
If necessary, dump the scripts database into the file specified by -wp-script f.
scope [Mcfg.S]
scope [Cfgpropid.Create]
scope [CfgWeakestPrecondition.Create]
script_for [Prover.Coq]
scriptbase [Proof]
scriptfile [Proof]
section [Mdata.S.Declarator]
section [Datalib.Create.Declarator]
selector [Wp_gui]
self [Dashtbl.Graph]
separated [Mlogic.S]
separated [Runtime_mem.Create]
separated [Store_mem.Create]
separated [Hoare_mem.Create]
separated [Region.Create]
separated [Funvar_mem.Create]
separated [Hoare_lib.Create.Hlib]
separated [Caveat_mem.Make.WP]
separated_bases [Region.Create]
separated_bases_others [Region.Create]
separated_cvars [Region.Create]
separated_find [Region.Create]
separated_others_bases [Region.Create]
separated_ranges [Region.Create]
separated_roots [Region.Create]
server [Prover]
set [String]
String.set s n c modifies string s in place, replacing the character number n by c.
set [Properties_status.Make_updater]
Set the status of an annotation.
set [State_builder.Ref]
Change the referenced value.
set [Calculus.Cfg.R]
store the result p for the computation of the edge e.
set_addr_taken [Vaddr]
set_back_edge [Cil2cfg]
set_checked [Wprop.Updater]
set_exit_status [Mlogic.S]
set_exit_status [Runtime_mem.Create]
set_exit_status [Store_mem.Create]
set_exit_status [Hoare_mem.Create]
set_exit_status [Funvar_mem.Create]
set_exit_status [Caveat_mem.Make.WP]
set_iloop_header [Cil2cfg.WeiMaoZouChenInput]
set_iloop_header env b h store h as the innermost loop header for b.
set_iloop_header [Cil2cfg.LoopInfo]
set_model [Wp_error]
set_of [Translate_prop.Create]
set_of_list [Mdata.S]
set_of_list [Datalib.Create]
set_po_result [Wpo]
set_pos [Cil2cfg.WeiMaoZouChenInput]
store the position for the node and also the fact that the node has been seen
set_pos [Cil2cfg.LoopInfo]
set_proxy [Wprop.Indexed]
set_range_index [Mdata.S]
set_range_index [Datalib]
set_range_index [Datalib.Create]
set_result [Wpo]
set_unknown [Wprop.Updater]
set_unreachable [WpAnnot]
shared [CfgProof.Description]
Shared resource basename for the model
shift [Mvalues.S]
shift ptr tau k computes the location of ptr+k, where ptr is a pointer to a value of type tau.
shift [Runtime_mem.Create.Data]
shift [Store_mem.Create.Data]
shift [Hoare_mem.Create]
shift [Funvar_mem.Create]
shift [Caveat_mem.Make.WP]
shift_epath [Caveat_fol]
shift_field [Runtime_mem.Create.Tint]
shift_field [Hoare_lib.Create.Hlib]
shift_field [Caveat_fol]
shift_index [Hoare_lib.Create.Hlib]
shift_index [Caveat_fol]
shift_loc [Translate_expr.Create]
shift_n_elem [Runtime_mem.Create.Tint]
shift_pointer [Hoare_lib.Create.Hlib]
shift_pointer [Caveat_fol]
shift_ufield [Hoare_lib.Create.Hlib]
show_cfg [Wp_gui]
signed [Ctypes]
true if ikind is signed
simpl [Fol]
simplify [Prover.SMT]
singleton [Mdata.S]
singleton a returns the singleton set containning a.
singleton [Set.S]
singleton x returns the one-element set containing only x.
singleton [Datalib.Create]
size [Wprop.Info]
size_of_int [Runtime_mem.Create.Tint]
size_of_int64 [Runtime_mem.Create.Tint]
sizeof [Store_mem.Create]
sizeof [Region.Create]
sizeof_c_object [Runtime_mem.Create]
sizeof_object [Ctypes]
skip [Script]
some_alpha [Datalib.Create]
split [Mcfg.Splitter]
split [WpAnnot]
split [Fol_split]
First, unfold zones when method is effect-assigns.
split [Caveat_mem.Make.Splitter]
split [Set.S]
split x s returns a triple (l, present, r), where l is the set of elements of s that are strictly less than x; r is the set of elements of s that are strictly greater than x; present is false if s contains no element equal to x, or true if s contains an element equal to x.
stack [Datalib.Collector]
start_edge [Cil2cfg]
get the starting edges
start_stmt_of_node [Cil2cfg]
startof [Mvalues.S]
startof return a pointer to the first element of an array
startof [Runtime_mem.Create]
startof [Store_mem.Create]
startof [Hoare_mem.Create]
startof [Funvar_mem.Create]
startof [Translate_expr.Create]
startof [Caveat_mem.Make.WP]
state [Wprop.Indexed]
state [Wprop.Indexed2]
state_name [Wprop.Info]
state_proxy [Wprop.Info]
status [Prover.Log]
store [Runtime_mem.Create.RtLib]
store [Runtime_mem.Create]
store [Funvar_mem.Create]
store_mem [Mvalues.Data]
store_mem [Runtime_mem.Create.Data]
store_mem [Store_mem.Create.Data]
store_mem [Store_mem.Create]
store_rec [Store_mem.Create.Data]
store_with [Store_mem.Create]
stored [Data_mem.Create]
string_of_termination_kind [WpAnnot]
sub [Runtime_mem.Create.Aint]
sub [Store_mem.Create]
sub [String]
String.sub s start len returns a fresh string of length len, containing the substring of s that starts at position start and has length len.
sub [Datalib.Create]
sub_c_float [Ctypes]
sub_c_int [Ctypes]
sub_int [Whylib]
sub_real [Whylib]
subproof_idx [WpAnnot]
subproofs [WpAnnot]
subset [Set.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subst [Mdata.S]
subst [Hoare_mem.Create]
subst [Datalib.Create]
subst [Caveat_mem.Make.WP]
subst_data_in_pred [Caveat_fol]
subst_havoc [Mwp.S]
Binds the free variables in the wp representing the memory locations that live in zone.
subst_havoc [Runtime_mem.Create]
subst_havoc [Store_mem.Create]
subst_havoc [Hoare_mem.Create]
Compute the WP for the predicate p of something that modifies only the assigned locations out_locs.
subst_havoc [Funvar_mem.Create]
subst_havoc [Caveat_mem.Make.WP]
subst_in_bindings [Datalib.Create]
subst_in_pred [Fol]
Specialized version of subst_vars_in_pred to substitute one variable v by and expression exp in a predicate p.
subst_lval [Mwp.S]
subst_lval frame l te v p binds in p the free variables representing the value at location l in the current memory to the actual value v.
subst_lval [Runtime_mem.Create]
subst_lval [Store_mem.Create]
subst_lval [Hoare_mem.Create]
subst_lval [Funvar_mem.Create]
subst_lval [Caveat_mem.Make.WP]
subst_result [Mwp.S]
subst_result frame v p bind the free variable representing \result in to an actual value.
subst_result [Runtime_mem.Create]
subst_result [Store_mem.Create]
subst_result [Hoare_mem.Create]
subst_result [Funvar_mem.Create]
subst_result [Caveat_mem.Make.WP]
subst_vars_in_pred [Fol]
Similar to change_vars_in_exp but on predicates.
succ_e [Cil2cfg]
suitable [Proof]
switch [Mcfg.S]
switch [Cfgpropid.Create]
merge the switch branches :
switch [CfgWeakestPrecondition.Create]
system [Wpo]

T
t_alloc [Runtime_mem.Create]
t_alloc [Store_mem.Create]
t_mbits [Runtime_mem.Create]
t_mem [Runtime_mem.Create]
t_memory [Store_mem.Create]
t_of_l [Caveat_mem.Make.Export]
target [WpAnnot]
task_for [Prover]
tau_of_ctype [Mdata.S]
tau_of_ctype [Datalib.Create]
tau_of_dzone [Mwp.S]
tau_of_dzone [Runtime_mem.Create]
tau_of_dzone [Store_mem.Create]
tau_of_dzone [Hoare_mem.Create]
tau_of_dzone [Funvar_mem.Create]
tau_of_dzone [Caveat_mem.Make.WP]
tau_of_logic_ctype [Datalib.Tau]
tau_of_logic_type [Mdata.S]
tau_of_logic_type [Datalib.Create]
tau_of_mem [Mvalues.Data]
tau_of_mem [Runtime_mem.Create.Data]
tau_of_mem [Store_mem.Create.Data]
tau_of_object [Mdata.S]
tau_of_object [Datalib.Create]
tau_of_var [Formula.S]
tau_of_var [Fol_gformula.Pool]
tau_of_var [Caveat_fol]
tbits_of_var [Runtime_mem.Create]
tcomp_of_comp [Runtime_mem.Create]
term [Translate_prop.Create]
term e t interprets the C terms t in memory model environment e as a logic term.*
term_alpha_cv [Fol]
term_closed [Formula.S]
term_closed [Fol_formula]
term_closed [Caveat_fol]
term_has_var [Formula.S]
term_has_var [Fol_formula]
term_has_var [Caveat_fol]
term_load [Hoare_mem.Create]
term_of_data [Translate_prop.Create]
term_of_data [Caveat_fol]
term_of_var [Caveat_fol]
term_of_xaddr [Runtime_mem.Create.Tint]
term_of_xsize [Runtime_mem.Create.Tint]
term_of_xzone [Runtime_mem.Create.Tint]
term_opt_has_var [Caveat_fol]
term_replace [Fol]
This one doesn't know how to substitute in data, so it builds a let if needed.
term_such_that [Mdata.S]
term_such_that [Datalib.Create]
terms_alpha_cv [Fol]
test [Mcfg.S]
test [Cfgpropid.Create]
test [CfgWeakestPrecondition.Create]
tmp [Prover.Tmp]
tmp_dir [Wp_parameters]
to_bits [Runtime_mem.Create.RtLib]
to_term [Runtime_mem.Create.Aint]
toffset_of_field [Runtime_mem.Create.Tint]
token [Script]
top_loc_term [Caveat_mem.Make.WP]
translate [Prover.SMT]
translate_assigned [CfgWeakestPrecondition.Create]
translate_assigned_targets [CfgWeakestPrecondition.Create]
translate_data_in_pred [Fol]
translate_data_in_pred do_data pred
translate_data_in_term [Fol]
translate_data_in_term do_data exp
translate_pred_in_decl [Fol]
translate_pred_in_decl do_pred item
translate_pred_in_item [Fol]
translate_pred_in_item do_pred item
tsize_of_field [Runtime_mem.Create.Tint]
ty [Datatype.Set]
typ_of_elements [Translate_prop.Create]
typeOf_array_elem [Translate_expr.Create]

U
uncapitalize [String]
Return a copy of the argument, with the first character set to lowercase.
union [Mdata.S]
union s0 s1 returns the union set of s0 and s1.
union [Region.Create.Merge]
union [Region.Create]
Union of arbitrary regions
union [Set.S]
Set union.
union [Datalib.Create]
union_data [Translate_prop.Create]
union_map [Translate_prop.Create]
union_range [Region.Create]
unions [Mdata.S]
unions [Datalib.Create]
unlet [Fol_cc]
unlet_pred [Fol_cc]
unlet_term [Fol_cc]
unop [Whylib.Create]
unstructuredness [Cil2cfg.LoopInfo]
unsupported [Wp_error]
unsupported [Runtime_mem]
unsupported [Store_mem.Create]
unsupported [Hoare_mem.Create]
unsupported [Caveat_mem]
unsupported [Caveat_fol]
unwrap [Formula.Vernacular]
unwrap [Fol_gformula.Langage]
upd_field [Mdata.S]
Takes a record term of type (tau_of F.fcomp) and a new term of type (tau_of F) for its field 'F' and return the updated record.
upd_field [Datalib.Create]
upd_index [Mdata.S]
upd_index [Datalib.Create]
update [Funvar_mem.Create]
update [Properties_status.Make_updater]
Update the status of a given annotation according to the old status.
update_at_label [Mwp.S]
update_at_label frame l p binds free variables in p representing the state at label l to the current memory.
update_at_label [Runtime_mem.Create]
update_at_label [Store_mem.Create]
update_at_label [Hoare_mem.Create]
update_at_label [Funvar_mem.Create]
update_at_label [Caveat_mem.Make.WP]
Substitute the variables that represent values at label by the variables that represent values at Here.
updater [CfgProof.Description]
Unique name for the internal updater
updaters [Wpo]
uppercase [String]
Return a copy of the argument, with all lowercase letters translated to uppercase, including accented letters of the ISO Latin-1 (8859-1) character set.
urecord_format [Mdata.S]
urecord_format [Datalib.Create]
urecord_of_data [Translate_prop.Create]
use_assigns [Mcfg.S]
use_assigns [Cfgpropid.Create]
use_assigns [CfgWeakestPrecondition.Create]
user_axiomdefs [Translate_prop.Create]
user_axioms [Translate_prop.Create]
user_definitions [Translate_prop.Create]
user_env [Translate_prop.Create]
user_prop_names [WpAnnot]
user_variables [Translate_prop.Create]
userdef_closure [Mlogic.S]
userdef_closure [Runtime_mem.Create]
userdef_closure [Store_mem.Create]
userdef_closure [Hoare_mem.Create]
userdef_closure [Funvar_mem.Create]
userdef_closure [Caveat_mem.Make.WP]
userdef_frame [Mlogic.S]
userdef_frame [Runtime_mem.Create]
userdef_frame [Store_mem.Create]
userdef_frame [Hoare_mem.Create]
userdef_frame [Funvar_mem.Create]
userdef_frame [Caveat_mem.Make.WP]
userdef_fun_closure [Funvar_mem.Create]
userdef_fun_signature [Funvar_mem.Create]
userdef_signature [Mlogic.S]
userdef_signature [Runtime_mem.Create]
userdef_signature [Store_mem.Create]
userdef_signature [Hoare_mem.Create]
userdef_signature [Funvar_mem.Create]
userdef_signature [Caveat_mem.Make.WP]
uterm_of_data [Caveat_mem.Make.Export]

V
val_of [Fol]
valid [Mlogic.S]
valid [Runtime_mem.Create.RtLib]
valid [Runtime_mem.Create]
valid [Store_mem.Create]
valid [Prover.AltErgo]
valid [Hoare_mem.Create]
valid [Funvar_mem.Create]
valid [Caveat_mem.Make.WP]
valid_pointer [Hoare_lib.Create.Hlib]
valid_range [Hoare_lib.Create.Hlib]
valloc_of_mem [Runtime_mem.Create]
value_of_bits [Runtime_mem.Create.Data]
value_of_bits [Runtime_mem.Create]
Compute the logic value from bits interpreted with type t.
value_of_boolean [Translate_expr.Create]
value_of_integer [Translate_expr.Create]
value_of_logic [Mvalues.Values]
value_of_logic [Datalib.Cvalues]
value_of_mvalue [Funvar_mem.Create]
var [Formula.S]
var [Fol_gformula.Pool]
var [Caveat_fol]
for Formula signature
var_counter [Fol.Var]
var_data [Caveat_mem.Make.WP]
var_data_term [Caveat_mem.Make.WP]
var_name [Fol.Var]
var_type [Fol.Var]
varinfo_of_xaddr [Runtime_mem.Create.Tint]
varmem_at [Store_mem.Create]
varname [Datatype.Set]
vbits_of_mem [Runtime_mem.Create]
vertex_attributes [Cil2cfg.Printer]
vertex_name [Cil2cfg.Printer]
visit_data_in_pred [Caveat_fol]
use to collect things about data: call do_data on each data node of e and recursively inside the data.
visit_exp_in_data [Caveat_fol]
do_sub_data is a function applied to each sub-data of d (NOT on d).
visit_path [Caveat_fol]
vkind_of_var [Mdata.S]
vkind_of_var [Datalib.Create]

W
warning [Wp_parameters]
whydp [Prover.SMT]
wp_call [Calculus.Cfg]
wp_cfg_dot [Register]
wp_compute [Register]
wp_dir [Wp_gui]
wp_generation [Wp_parameters]
wp_loop [Calculus.Cfg.R]
Compute the result for edge e which goes to the loop node nloop.
wp_model [Register]
wp_model [Wp_parameters]
wp_model_menu [Wp_gui]
wp_panel [Wp_gui]
wp_po [Wp_parameters]
wp_prover [Wp_parameters]
wp_prover_get [Wp_gui]
wp_prover_menu [Wp_gui]
wp_prover_set [Wp_gui]
wp_scope [Calculus.Cfg]
wp_script [Wp_gui]
wp_stmt [Calculus.Cfg]
wp_strategy [Wp_parameters]
wrap [Formula.Vernacular]
wrap [Fol_gformula.Langage]

X
xaddr_of_gvar [Runtime_mem.Create.Tint]
xaddr_of_integer [Runtime_mem.Create.Tint]
xaddr_of_pointer [Runtime_mem.Create.Tint]
xaddr_of_var [Runtime_mem.Create.Tint]
xsize_of_range [Runtime_mem.Create.Tint]
xvar_of_varinfo [Translate_prop.Create]
xzone_assigned [Runtime_mem.Create]
xzone_disj [Runtime_mem.Create.Tint]
xzone_of_var [Runtime_mem.Create.Tint]

Y
yices [Prover.SMT]

Z
z3 [Prover.SMT]
z_from_bits [Runtime_mem.Create]
zenon [Prover.SMT]
zero [Store_mem.Create]
zip [CfgWeakestPrecondition.Create]
zone [Region.Create]
zone_of_assignable [Store_mem.Create]
zrange [Store_mem.Create]
zs_empty [Runtime_mem.Create.RtLib]
zs_incl [Runtime_mem.Create.RtLib]
zs_singleton [Runtime_mem.Create.RtLib]
zs_union [Runtime_mem.Create.RtLib]
zunion [Fol_split]