Index of values


(&&&) [Register]
__ocaml_lex_comment_rec [Script]
__ocaml_lex_proof_rec [Script]
__ocaml_lex_tables [Script]
__ocaml_lex_token_rec [Script]

A
a_false [LogicLang]
a_false [Fol_formula]
a_of_data [Store_mem.Create]
a_true [LogicLang]
a_true [Fol_formula]
acc_field [Formula.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 [Fol_formula]
acc_index [Formula.S]
Takes term of type 'a farray and returns the 'a at index i.
acc_index [Fol_formula]
access [LogicHavoc]
access [Funvar_mem.Create.Lookup]
access_poffset [Funvar_mem.Create.Lookup]
active_lgg [CfgProof.Create]
add [Runtime_mem.Create.Aint]
add [Map.S]
add x y m returns a map containing the same bindings as m, plus a binding of x to y.
add [Hashtbl.S]
add [Wpo]
add [Cil2cfg.HEsig]
add [Cil2cfg.HE]
add [Set.S]
add x s returns a set containing all elements of s, plus x.
add [State_builder.Hashtbl]
Add a new binding.
add_all_axioms [WpStrategy]
add_array_reference_arg [Variables_analysis]
add_array_reference_param [Variables_analysis]
add_assigns [Mcfg.S]
add_assigns [CfgWeakestPrecondition.Create]
add_assigns [Cfgpropid.Create]
add_assigns [WpStrategy]
generic function to add an assigns property.
add_assigns_any [WpStrategy]
generic function to add a WriteAny assigns property.
add_assigns_goal [Calculus.Cfg]
add_assigns_hyp [Calculus.Cfg]
add_axiom [Mcfg.S]
add_axiom [CfgWeakestPrecondition.Create]
add_axiom [Cfgpropid.Create]
add_axiom [Calculus.Cfg]
add_axiom [Translate_prop.Create]
Compile an axiom and add it to the list of global declarations.
add_axiom [Data_mem.Create.Compound]
add_axiom [WpStrategy]
add_behaviors_props [WpAnnot]
add_call_assigns_hyp [WpFroms]
add_call_assigns_hyp [WpStrategy]
shortcut to add a call assigns property as an hypothesis.
add_call_hyp [Calculus.Cfg]
add_called_post [WpAnnot]
add_called_pre [WpAnnot]
add_complete_behaviors_props [WpAnnot]
add_cycle [LogicDef.Cofix]
add_declaration [Formula.S]
add_declaration [Fol_formula]
add_depend [Datalib.Collector]
add_depend_field [LogicDef]
add_depend_pred [LogicLang]
add_depend_tau [LogicLang]
add_depend_term [LogicLang]
add_depend_var [LogicDef]
add_dependencies [CfgWeakestPrecondition.Create]
add_disjoint_behaviors_props [WpAnnot]
add_edge [Cil2cfg]
add_edges_before [Cil2cfg]
add_effect_assigns [CfgWeakestPrecondition.Create]
add_fct_assigns_goal [WpAnnot]
add_fct_bhv_assigns_hyp [WpStrategy]
add_fct_pre [WpAnnot]
add_field [Funvar_mem.Create]
add_file [Prover.Logs]
add_global_annotations [WpAnnot]
add_goal [Mcfg.S]
add_goal [CfgProof.Create]
add_goal [CfgWeakestPrecondition.Create]
add_goal [Cfgpropid.Create]
add_goal [Calculus.Cfg]
add_hook [Wprop.Indexed2]
add_hook [Wprop.Indexed]
add_hyp [Mcfg.S]
add_hyp [CfgWeakestPrecondition.Create]
add_hyp [Cfgpropid.Create]
add_hyp [Calculus.Cfg]
add_index [Funvar_mem.Create]
add_int [Fol_decl]
add_int_format_hyp [Runtime_mem.Create]
add_integer [Translate_prop.Create]
add_irreducible [Cil2cfg.WeiMaoZouChenInput]
store the node as an irreducible loop header.
add_irreducible [Cil2cfg.LoopInfo]
add_logic_vars [Translate_prop.Create]
add_logics_value [Variables_analysis]
add_loop_annots [WpStrategy]
add_loop_assigns_goal [WpAnnot]
add_loop_assigns_hyp [WpFroms]
add_loop_assigns_hyp [WpStrategy]
shortcut to add a loop assigns property as an hypothesis.
add_loop_header [Cil2cfg.WeiMaoZouChenInput]
store the node as a loop header.
add_loop_header [Cil2cfg.LoopInfo]
add_loop_invariant_annot [WpAnnot]
add_memo [Calculus.Cfg.R]
add_node [Cil2cfg]
add_node_annots [WpStrategy]
add_node_annots cfg annots v (before, (after, exits)) add the annotations for the node :
add_normal_assigns [CfgWeakestPrecondition.Create]
add_oblig [Calculus.Cfg.R]
add_offset [Hoare_mem.Create]
add_offset [Store_mem.Create]
add_on_edges [WpStrategy]
add_proof [WpAnnot]
accumulate int the proof the partial proof for this prop_id
add_prop [WpStrategy]
generic function to add a predicate property after normalisation.
add_prop_assert [WpStrategy]
add_prop_call_post [WpStrategy]
Add a postcondition of a called function.
add_prop_call_pre [WpStrategy]
add_prop_fct_bhv_pre [WpStrategy]
Add the preconditions of the behavior : if impl_assumes, add b_assumes => b_requires else add both the b_requires and the b_assumes
add_prop_fct_post [WpStrategy]
add_prop_fct_pre [WpStrategy]
Add the predicate as a function precondition.
add_prop_inv_establish [WpAnnot]
add_prop_inv_fixpoint [WpAnnot]
add_prop_inv_preserve [WpAnnot]
add_prop_loop_inv [WpStrategy]
add_prop_stmt_bhv_requires [WpStrategy]
Add all the b_requires.
add_prop_stmt_post [WpStrategy]
Add the predicate as a stmt precondition.
add_prop_stmt_pre [WpStrategy]
Add the predicate as a stmt precondition.
add_prop_stmt_spec_pre [WpStrategy]
Process the stmt spec precondition as an hypothesis for external properties.
add_ptr_reference_arg [Variables_analysis]
add_ptr_reference_param [Variables_analysis]
add_real [Fol_decl]
add_reentry_edge [Cil2cfg.WeiMaoZouChenInput]
store the edge between the two nodes (n1, n2) as a reentry edge.
add_reentry_edge [Cil2cfg.LoopInfo]
add_requires [Variables_analysis]
add_rte_menu [Wp_gui]
add_script [Proof]
new_script goal keys proof registers the script proof for goal goal and keywords keys
add_set [Formula.S]
add_set [Fol_formula]
add_spec_annots [WpFroms]
add_stmt_assigns_goal [WpAnnot]
add_stmt_bhv_as_goal [WpAnnot]
we want to prove this behavior: add the requires as preconditions to both prove and use as hyp,, add the assumes as hypotheses,, add the postconditions as goals.
add_stmt_invariant_annot [WpAnnot]
add_stmt_spec_annots [WpAnnot]
add_stmt_spec_assigns_hyp [WpFroms]
add_stmt_spec_assigns_hyp [WpStrategy]
shortcut to add a stmt spec assigns property as an hypothesis.
add_stmt_spec_post_as_hyp [WpAnnot]
Add the post condition of the whole spec as hypothesis.
add_terminates [WpAnnot]
add_variant [WpAnnot]
add_variant_annot [WpAnnot]
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 [CfgWeakestPrecondition.Create]
addr [Translate_expr.Create]
addr mem lv interprets the left value lv as an address (memory location) in the memory mem.*
addr [Store_mem.Create.Model]
addr_of_assignable [Store_mem.Create]
addr_of_data [Store_mem.Create]
addr_of_ref [Translate_prop.Create]
adt_decl [Formula.S]
adt_decl [Fol_formula]
all_filter [Translate_prop.Create]
all_stable [LogicDef.Cofix]
alloc [Hoare_mem.Create]
alloc [Runtime_mem.Create.RtLib]
alloc_vars [Hoare_mem.Create]
alloc_vars [Store_mem.Create]
allocator [LogicId]
alpha [Formula.Logic]
alpha [LogicId]
User-friendly name sorting.
alpha [Fol_eqs]
alpha [Fol_let]
alpha [Datalib.Create]
alpha_bound_var [Fol]
alpha_unbound [Fol]
altergo [Prover.SMT]
annot_for_asked_bhv [WpFroms]
apply [Hook.S]
Apply all the functions of the hook on the given parameter.
apply [Formula.Logic]
apply [Fol_formula]
apply [Datalib.Create]
apply_alpha [Fol]
apply_formals [Translate_prop.Create]
apply_function [Translate_prop.Create]
apply_labels [LogicPretty]
apply_predicate [Translate_prop.Create]
apply_references [Translate_prop.Create]
array [LogicHavoc]
array_dim [Ctypes]
array_format [Data_mem.Create]
array_of [Funvar_mem.Create]
array_of_data [Translate_prop.Create]
array_reference [Variables_analysis]
as_int [Fol]
as_int_format [Fol]
assign [Mcfg.S]
assign [CfgWeakestPrecondition.Create]
assign [Cfgpropid.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_goal [Mwp.S]
assigns_goal [Hoare_mem.Create]
assigns_goal [Store_mem.Create]
assigns_goal [Runtime_mem.Create]
assigns_goal [Funvar_mem.Create]
assigns_info_id [WpPropId]
assigns_method [Mcfg.S]
assigns_method [CfgProof.Create]
assigns_method [CfgWeakestPrecondition.Create]
assigns_method [Cfgpropid.Create]
assigns_supported [Mwp.S]
assigns_supported [Hoare_mem.Create]
assigns_supported [Store_mem.Create]
assigns_supported [Runtime_mem.Create]
assigns_supported [Funvar_mem.Create]
assigns_upper_bound [WpStrategy]
associative [LogicPretty]
axiom_env [Translate_prop.Create]

B
bar [Wpo]
base [Hoare_mem.Create.Model]
base [Store_mem.Create.Model]
base [Runtime_mem.Create.Tint]
base_address [Mlogic.S]
base_address m l return the base address of l.
base_address [Hoare_mem.Create]
base_address [Store_mem.Create]
base_address [Runtime_mem.Create]
base_address [Funvar_mem.Create]
basename [Formula.S.Identifiable]
basename [LogicLib]
basename [LogicRaw.VAR]
basename [LogicId]
basename [Fol_formula.Identifiable]
basename [Fol_formula.LTinfoId]
basename [Fol_formula.ArrayDim]
basename [Fol_formula.Cobject]
basename [Fol_formula.Logicvar]
basename [Fol_formula.LTypeinfo]
basename [Fol_formula.Arrayinfo]
basename [Fol_formula.Compinfo]
basename [Fol_formula.Fieldinfo]
basename [Fol_formula.Varinfo]
basename [Fol.Var]
basename [Ctypes]
basename_of_var [Formula.S]
basename_of_var [Fol_formula]
basetype [Ctypes]
behavior_name_of_config [WpAnnot]
behavior_name_of_strategy [WpStrategy]
bhv_from_hyps [WpFroms]
bind [Fol_let]
bind_formals [Translate_prop.Create]
bind_fresh [Translate_prop.Create]
bind_lvar [Translate_prop.Create]
bind_lvars [Translate_prop.Create]
bindings [Map.S]
Return the list of all bindings of the given map.
binop [LogicLang]
binop [Fol_formula]
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_length [Mlogic.S]
block_length m l t return the block_length of the location l.
block_length [Hoare_mem.Create]
block_length [Store_mem.Create]
block_length [Runtime_mem.Create.RtLib]
block_length [Runtime_mem.Create]
block_length [Funvar_mem.Create]
blocks_closed_by_edge [Cil2cfg]
bool_and [Fol_decl]
bool_not [Fol_decl]
bool_of_option [Translate_prop.Create]
bool_or [Fol_decl]
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_loc [Translate_expr.Create]
boolean_of_value [Translate_expr.Create]
bracket_exp [Variables_analysis]
bracket_term [Variables_analysis]
brackets_and_stars_lv_typ [Funvar_mem.Create]
brackets_and_stars_lv_typ [Variables_analysis]
brackets_and_stars_typ [Funvar_mem.Create]
brackets_and_stars_typ [Variables_analysis]
brackets_and_stars_var_type_typ [Variables_analysis]
brackets_lv_typ [Variables_analysis]
brackets_off [Variables_analysis]
brackets_toff [Variables_analysis]
brackets_typ [Variables_analysis]
brackets_typ typ returns the numbre of brackets of the type typ.
brackets_var_type_typ [Variables_analysis]
build_bhv_strategy [WpAnnot]
build_configs [WpAnnot]
build_elem [WpFroms]
see build_elem_opt above.
build_elem_opt [WpFroms]
Build the lvalue \at (mlab, * (\at (addrlab, & elem))) .
build_fimpl_eq [WpFroms]
Build out = f_n (inputs).
build_post_output [WpFroms]
Build the left part of a contract assigns property Process \result and \exit_status according to termination_kind.
build_prop_of_from [Mcfg.S]
build p => alpha(p) for functional dependencies verification.
build_prop_of_from [CfgWeakestPrecondition.Create]
build_prop_of_from [Cfgpropid.Create]
build_wpos [CfgProof.Create]
by_array_reference [Variables_analysis]
by_array_reference_pattern [Variables_analysis]
by_array_reference_pattern_term [Variables_analysis]
by_array_reference_usage [Variables_analysis]
by_array_reference_usage_term [Variables_analysis]
by_pointer_reference_pattern [Variables_analysis]
by_pointer_reference_pattern_term [Variables_analysis]
by_pointer_reference_usage [Variables_analysis]
by_pointer_reference_usage_term [Variables_analysis]
by_ptr_reference [Variables_analysis]

C
c_bool [Fol]
c_bool [Ctypes]
Returns the type of int
c_char [Ctypes]
Returns the type of char
c_float [Fol]
c_float [Ctypes]
Conforms to
c_float_of_str [Fol]
c_int [Fol]
c_int [Ctypes]
Conforms to
c_int_all [Ctypes]
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_ptr [Ctypes]
Returns the type of pointers
call [Mcfg.S]
call [CfgWeakestPrecondition.Create]
call [Cfgpropid.Create]
call_exit [Translate_prop.Create]
call_exit_only [CfgWeakestPrecondition.Create]
call_goal_precond [Mcfg.S]
call_goal_precond [CfgWeakestPrecondition.Create]
call_goal_precond [Cfgpropid.Create]
call_normal_only [CfgWeakestPrecondition.Create]
call_post [Translate_prop.Create]
call_pre [Translate_prop.Create]
callenv [CfgWeakestPrecondition.Create]
calls_collection_computed [Variables_analysis]
capitalize [String]
Return a copy of the argument, with the first character set to uppercase.
cardinal [Hoare_mem.Create]
cardinal [Store_mem.Create]
cardinal [Map.S]
Return the number of bindings of a map.
cardinal [Set.S]
Return the number of elements of a set.
case_of [Fol]
case_of_exp [CfgWeakestPrecondition.Create]
case_of_optimization [Variables_analysis]
cast [CfgWeakestPrecondition.Create]
cast [Translate_prop.Create]
cast_int_to_loc [Mvalues.Model]
cast_int_to_loc [Hoare_mem.Create.Model]
cast_int_to_loc [Store_mem.Create.Model]
cast_int_to_loc [Runtime_mem.Create.Model]
cast_int_to_loc [Funvar_mem.Create.Model]
cast_int_to_loc [Datalib.Cvalues]
cast_loc_to_int [Mvalues.Model]
cast_loc_to_int [Hoare_mem.Create.Model]
cast_loc_to_int [Store_mem.Create.Model]
cast_loc_to_int [Runtime_mem.Create.Model]
cast_loc_to_int [Funvar_mem.Create.Model]
cast_loc_to_int [Datalib.Cvalues]
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 [Hoare_mem.Create]
cast_loc_to_loc [Store_mem.Create]
cast_loc_to_loc [Runtime_mem.Create]
cast_loc_to_loc [Funvar_mem.Create]
cat [Prover]
catch_label_error [NormAtLabels]
cfg_block [Cil2cfg]
cfg_dot [Cil2cfg]
cfg_from_definition [Cil2cfg]
cfg_from_proto [Cil2cfg]
cfg_graph [Cil2cfg]
cfg_kf [Cil2cfg]
cfg_of_strategy [WpStrategy]
cfg_spec_only [Cil2cfg]
returns true is this CFG is degenerated (no code available)
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_exp_in_pred [Fol]
apply do_exp on each sub expression of the predicate.
change_in_exp [Fol]
Apply do_var in term subexpressions.
change_mode_if_needed [Calculus.Cfg.R]
If needed, clear wp table to compute Pass2.
char [Ctypes]
check [Prover.Coq]
check [Prover.AltErgo]
check [Prover.SMT]
check [Prover]
check_assigns [CfgWeakestPrecondition.Create]
check_by [Prover]
check_cpt [Fol.Var]
check_names [Wp_parameters]
check_pred [Fol]
check_term [Fol]
choose [Map.S]
Return one binding of the given map, or raise Not_found if the map is empty.
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 [Prover.Logs]
clean_graph [Cil2cfg]
clear [Hook.S]
Clear the hook.
clear [Formula.S.Declarator]
clear [Formula.S]
clear [LogicId]
clear [Fol_formula.Declarator]
clear [Fol_formula]
clear [Wpo.Results]
clear [Hashtbl.S]
clear [Wpo]
clear [Proof]
clear [Cil2cfg.HEsig]
clear [Cil2cfg.HE]
clear [State_builder.Hashtbl]
Clear the table.
clear [State_builder.Ref]
Reset the reference to its default value.
close [Formula.Logic]
close [Mcfg.S]
close [CfgWeakestPrecondition.Create]
close [Cfgpropid.Create]
close [Datalib.Create]
close [Prover.Logs]
close [Script]
close_out [Prover.Logs]
close_property [CfgWeakestPrecondition.Create]
closed [Formula.Logic]
closed [Datalib.Create]
cmdline_run [Register]
cnst_mult [Runtime_mem.Create.Aint]
cnst_mult_size [Runtime_mem.Create.Tint]
code_annot_names [WpPropId]
coerce_arr [Store_mem.Create]
coerce_comp [Store_mem.Create]
coercion [Fol]
cofix [LogicDef.Cofix]
collect_and [LogicPretty]
collect_and [Fol_coq]
collect_and [Fol_ergo]
collect_and [Fol_pretty]
collect_apps [Variables_analysis]
collect_apps_builtin [Variables_analysis]
collect_apps_rec [Variables_analysis]
collect_arg_array_call [Variables_analysis]
collect_arg_ptr_call [Variables_analysis]
collect_assoc [Fol_coq]
collect_assoc [Fol_ergo]
collect_assoc [Fol_pretty]
collect_calls [Variables_analysis]
collect_calls_rec [Variables_analysis]
collect_exists [LogicPretty]
collect_forall [LogicPretty]
collect_formal_array_call [Variables_analysis]
collect_formal_ptr_call [Variables_analysis]
collect_iff [Fol_coq]
collect_iff [Fol_ergo]
collect_iff [Fol_pretty]
collect_implies [LogicPretty]
collect_imply [Fol_coq]
collect_imply [Fol_ergo]
collect_imply [Fol_pretty]
collect_labels [LogicPretty]
collect_logic_vars [Translate_prop.Create]
to be used to retreive variable add through add_logic_vars.
collect_or [LogicPretty]
collect_or [Fol_coq]
collect_or [Fol_ergo]
collect_or [Fol_pretty]
collect_refparams [Variables_analysis]
collect_scripts [Proof]
collect_sepstars [Variables_analysis]
collect_signature [Translate_prop.Create]
column_tbl [Po_navigator.Prover_Column]
command [Prover.Logs]
comment [Script]
comp_compare [Fol_formula]
compare [LogicRaw.VAR]
compare [LogicId.S]
compare [Fol_formula.LTinfo]
compare [Fol.Var]
compare [Map.S]
Total ordering between maps.
compare [Wpo.WPO]
compare [Set.S]
Total ordering between sets.
compare [Cil2cfg.EL]
compare [Cil2cfg.VL]
compare [Ctypes.AinfoComparable]
compare [Ctypes]
compare [String]
The comparison function for strings, with the same specification as Pervasives.compare.
compare_c_float [Ctypes]
compare_c_int [Ctypes]
compare_edge_type [Cil2cfg.EL]
compare_field [LogicTau]
compare_item [Fol_formula]
compare_prop_id [WpPropId]
compare_sig [LogicTau]
compare_tau [LogicTau]
compare_token [LogicId]
compatible [LogicDef.Cofix]
compatible_signature [LogicDef.Cofix]
compile [ACSL.Compiler]
compile [Fol_norm]
compile [Fol_eqs]
compile [Fol_let]
compile_and_define [Translate_prop.Create]
compile_def [Fol_let]
compile_function [Translate_prop.Create]
compile_let_decl [Fol_formula]
compile_let_item [Fol_formula]
compile_predicate [Translate_prop.Create]
compile_user_axiom [Translate_prop.Create]
compile_user_axiom_labels [Translate_prop.Create]
compiled [Prover.Coq]
compute [Calculus.Cfg]
compute [LogicDef.Cofix]
compute [Variables_analysis]
compute_calls_collection [Variables_analysis]
compute_init_loc [CfgWeakestPrecondition.Create]
compute_init_value [CfgWeakestPrecondition.Create]
compute_int_mode [Runtime_mem.Create]
compute_logic_params [Variables_analysis]
compute_parameters_usage [Variables_analysis]
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 [CfgWeakestPrecondition.Create]
cond [Translate_expr.Create]
cond mem e interprets e as a boolean in memory mem.
cond_binop [Translate_expr.Create]
cond_rec [Translate_expr.Create]
cond_unop [Translate_expr.Create]
constant [Fol_coq]
constant [Fol_ergo]
constant [Fol_pretty]
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
convert [Kreal]
copy [LogicId]
Duplicates a name space.
copy [Hashtbl.S]
copy [String]
Return a copy of the given string.
copy [Datatype.S]
Deep copy: no possible sharing between x and copy x.
copy [Datatype.Set]
coq_for_env [Wpo]
coq_for_model [Wpo]
coqc [Prover.Coq]
coqc_for_model [Wpo]
coqidelock [Prover.Coqide]
create [CfgProof.Create]
create [LogicId]
Create a new fresh identifier with the given basename
create [Prover.Logs]
create [Wpo.Results]
create [Hashtbl.S]
create [Cil2cfg.HEsig]
create [Cil2cfg.HE]
create [Cil2cfg]
create [String]
String.create n returns a fresh string of length n.
create_proof [WpAnnot]
to be used only once for one of the related prop_id
create_tbl [WpStrategy]
cur_fct_default_bhv [WpAnnot]
current [LogicDef.Cofix]
current [Wp_error]
current_model [LogicDef]
cut [LogicRaw.PRED]
cut [Fol]
cvar [Mvalues.S]
cvar [Hoare_mem.Create]
cvar [Store_mem.Create.Data]
cvar [Runtime_mem.Create.Data]
cvar [Funvar_mem.Create]
cvar_of_var [Store_mem.Create.Data]
cvc3 [Prover.SMT]

D
darray_name [ACSL]
darray_of_arrayinfo [ACSL]
data_binop [Translate_prop.Create]
data_cmp [Translate_prop.Create]
data_const [Translate_prop.Create]
data_field [Translate_prop.Create]
data_index [Translate_prop.Create]
data_index_range [Translate_prop.Create]
data_load [Translate_prop.Create]
data_of_a [Store_mem.Create]
data_of_addr [Store_mem.Create]
data_of_assignable [Translate_prop.Create]
data_of_boolean [Translate_prop.Create]
data_of_float [Store_mem.Create]
data_of_int [Store_mem.Create]
data_of_integer [Translate_prop.Create]
data_of_real [Translate_prop.Create]
data_of_s [Store_mem.Create]
data_of_term [Translate_prop.Create]
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]
debug [Calculus.Cfg]
debug [Translate_prop]
debug [Translate_expr]
debug [Funvar_mem]
debug [Variables_analysis]
debug [WpAnnot]
debug [WpStrategy]
debug [Cil2cfg]
debug2 [Cil2cfg]
declarations [LogicDef]
declare [Formula.S.Declarator]
declare [LogicDef]
Simple declaration.
declare [Fol_formula.Declarator]
decode [Store_mem.Create]
decr_addr_taken [Variables_analysis]
decr_addr_taken_bool [Variables_analysis]
def [Fol_let]
default [LogicDef.Cofix]
default [LogicDef]
default [Prover.Coq]
default [Cil2cfg.EL]
default_edge_attributes [Cil2cfg.Printer]
default_vertex_attributes [Cil2cfg.Printer]
define [Formula.S.Registry]
define [Translate_prop.Create.UserAxiomDefs]
define [Translate_prop.Create.UserDefinition]
define [LogicDef.Cofix]
define [Fol_formula.Registry]
define [Fol_formula.DRegister]
define [Data_mem.Create.Compound]
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]
delta_array [Variables_analysis]
delta_array_term [Variables_analysis]
delta_ptr [Variables_analysis]
delta_ptr_term [Variables_analysis]
depend [LogicRaw.PRED]
depend [LogicRaw.TERM]
depend [LogicTau]
dependencies [LogicDef]
dependencies [WpAnnot]
deq_ctype [ACSL]
deref [Variables_analysis]
descr [Datatype.Set]
dhas_ctype [ACSL]
diff [Set.S]
Set difference.
different [LogicRaw.TERM]
different [LogicRaw.VAR]
dimension [Ctypes]
dispatch [Register]
dispatch [Fol_split]
dispatch_cvar [Variables_analysis]
dispatch_cvar v returns the var_kind associated to the C variable v according the current optimisations activated.
dispatch_lvar [Variables_analysis]
dispatch_lvar v returns the var_kind associated to the logic variable v according the current optimisations activated.
dispatch_var [Variables_analysis]
div_int [Fol_decl]
dkey [CfgProof]
dkey [Calculus.Cfg]
dkey [Translate_expr]
dkey [LogicPretty]
dkey [LogicRaw]
dkey [Fol_split]
dkey [Runtime_mem]
dkey [Variables_analysis]
dkey [WpAnnot]
dkey [WpFroms]
dkey [WpStrategy]
dkey [Cil2cfg]
dnode_cpt [Cfgpropid.Create]
do_check_feedback [Register]
do_compute [Register]
do_export [Fol_formula]
do_finally [Register]
do_hypothesis [CfgWeakestPrecondition.Create]
do_labels [Calculus.Cfg]
Before storing something at a program point, we have to process the label at that point.
do_prop [CfgWeakestPrecondition.Create]
do_properties [CfgWeakestPrecondition.Create]
do_return [CfgWeakestPrecondition.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]
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
dtau_ctype [ACSL]
dummy [Formula.S]
dummy [LogicId]
Only usable for represent in projectified definitions
dummy [Fol_formula]
dump_scripts [Proof]
dump_scripts f saves all scripts from the database into file f.
dzone_assigned [Mwp.S]
dzone_assigned [Hoare_mem.Create]
dzone_assigned [Store_mem.Create]
dzone_assigned [Runtime_mem.Create]
dzone_assigned [Funvar_mem.Create]
dzone_empty [Mwp.S]
dzone_empty [Hoare_mem.Create]
dzone_empty [Store_mem.Create]
dzone_empty [Runtime_mem.Create]
dzone_empty [Funvar_mem.Create]
dzone_subset [Mwp.S]
dzone_subset [Hoare_mem.Create]
dzone_subset [Store_mem.Create]
dzone_subset [Runtime_mem.Create]
dzone_subset [Funvar_mem.Create]
dzone_union [Mwp.S]
dzone_union [Hoare_mem.Create]
dzone_union [Store_mem.Create]
dzone_union [Runtime_mem.Create]
dzone_union [Funvar_mem.Create]

E
e_access [Formula.S]
e_access [LogicLang]
e_access [LogicRaw.TERM]
e_access [Fol_formula]
e_access [Fol]
e_and [Formula.S]
e_and [LogicLang]
e_and [LogicRaw.TERM]
e_and [Fol_formula]
e_app [Fol]
e_app0 [Formula.S]
e_app0 [Fol_formula]
e_app1 [Formula.S]
e_app1 [Fol_formula]
e_app2 [Formula.S]
e_app2 [Fol_formula]
e_app3 [Formula.S]
e_app3 [Fol_formula]
e_app4 [Formula.S]
e_app4 [Fol_formula]
e_app5 [Formula.S]
e_app5 [Fol_formula]
e_band [Formula.S]
e_band [LogicLang]
e_band [Fol_formula]
e_bigint [LogicLang]
e_bind [LogicRaw.SUBST]
e_bnot [Formula.S]
e_bnot [LogicLang]
e_bnot [Fol_formula]
e_bool [Formula.S]
e_bool [LogicLang]
e_bool [Fol_formula]
e_bor [Formula.S]
e_bor [LogicLang]
e_bor [Fol_formula]
e_bxor [Formula.S]
e_bxor [LogicLang]
e_bxor [Fol_formula]
e_call [Formula.S]
e_call [LogicLang]
e_call [LogicRaw.TERM]
e_call [Fol_formula]
e_closed [Fol]
e_cnst [Fol]
e_cond [Formula.S]
e_cond [LogicLang]
e_cond [LogicRaw.TERM]
e_cond [Fol_formula]
e_false [Formula.S]
e_false [LogicLang]
e_false [Fol_formula]
e_false [Fol]
e_float [Formula.S]
e_float [LogicLang]
e_float [Fol_formula]
e_float [Fol]
e_getfield [Formula.S]
e_getfield [LogicLang]
e_getfield [LogicRaw.TERM]
e_getfield [Fol_formula]
e_getfield [Fol]
e_has_var [Fol]
e_hasvar [LogicRaw.TERM]
e_icmp [Formula.S]
e_icmp [LogicLang]
e_icmp [Fol_formula]
e_icst [Formula.S]
e_icst [LogicLang]
e_icst [Fol_formula]
e_if [Fol]
e_ineg [Formula.S]
e_ineg [LogicLang]
e_ineg [Fol_formula]
e_int [Formula.S]
e_int [LogicLang]
e_int [LogicRaw.TERM]
e_int [Fol_formula]
e_int [Fol]
e_int64 [Formula.S]
e_int64 [Fol_formula]
e_int64 [Fol]
e_int_of_real [LogicLang]
e_iop [Formula.S]
e_iop [LogicLang]
e_iop [Fol_formula]
e_let [LogicLang]
e_let [LogicRaw.SUBST]
e_let [Fol]
e_lshift [Formula.S]
e_lshift [LogicLang]
e_lshift [Fol_formula]
e_not [Formula.S]
e_not [LogicLang]
e_not [LogicRaw.TERM]
e_not [Fol_formula]
e_or [Formula.S]
e_or [LogicLang]
e_or [LogicRaw.TERM]
e_or [Fol_formula]
e_prim [LogicRaw.TERM]
e_rcmp [Formula.S]
e_rcmp [LogicLang]
e_rcmp [Fol_formula]
e_rcst [Formula.S]
e_rcst [LogicLang]
e_rcst [Fol_formula]
e_real_of_int [LogicLang]
e_rename [Formula.S]
Requires domain to be disjoint from co-domain
e_rename [Fol_formula]
e_rneg [Formula.S]
e_rneg [LogicLang]
e_rneg [Fol_formula]
e_rop [Formula.S]
e_rop [LogicLang]
e_rop [Fol_formula]
e_rshift [Formula.S]
e_rshift [LogicLang]
e_rshift [Fol_formula]
e_setfield [Formula.S]
e_setfield [LogicLang]
e_setfield [LogicRaw.TERM]
e_setfield [Fol_formula]
e_setfield [Fol]
e_shared [LogicLib]
e_subst [Formula.S]
e_subst [Fol_formula]
e_true [Formula.S]
e_true [LogicLang]
e_true [Fol_formula]
e_true [Fol]
e_unfold [Fol_split]
e_update [Formula.S]
e_update [LogicLang]
e_update [LogicRaw.TERM]
e_update [Fol_formula]
e_update [Fol]
e_var [LogicLang]
e_var [Fol]
e_zero [LogicLang]
e_zero [LogicRaw.TERM]
eat [Script]
edge_attributes [Cil2cfg.Printer]
edge_dst [Cil2cfg]
edge_key [Cil2cfg.HE]
edge_key [Cil2cfg]
edge_src [Cil2cfg]
node and edges relations
edge_type [Cil2cfg]
effect_supported [Mwp.S]
effect_supported [Hoare_mem.Create]
effect_supported [Store_mem.Create]
effect_supported [Runtime_mem.Create]
effect_supported [Funvar_mem.Create]
elements [Set.S]
Return the list of all elements of the given set.
elet_expansion [Fol_eval]
empty [Formula.S]
empty() returns the polymorphic empty set.
empty [Mcfg.S]
empty [CfgWeakestPrecondition.Create]
empty [Cfgpropid.Create]
empty [Calculus.Cfg.R]
empty [LogicHavoc]
empty [Fol_formula]
empty [Fol_let]
empty [Map.S]
The empty map.
empty [Set.S]
The empty set.
empty_acc [WpStrategy]
empty_alpha [Formula.S]
empty_alpha [Fol_formula]
empty_assigns_info [WpPropId]
encode [Store_mem.Create]
env [Translate_prop.Create]
env_at [Translate_prop.Create]
env_name [Wpo]
epp_pred_atom [Fol_coq]
epp_pred_atom [Fol_ergo]
epp_pred_atom [Fol_pretty]
epp_pred_named [Fol_pretty]
epp_pred_vbox [Fol_coq]
epp_pred_vbox [Fol_ergo]
epp_pred_vbox [Fol_pretty]
eq_array [Mvalues.Values]
eq_array [Datalib.Cvalues]
eq_array_definition [Datalib.Cvalues]
eq_ctype [ACSL]
eq_int [Fol_decl]
eq_int_bool [Fol_decl]
eq_logic_type [ACSL]
eq_nodes [Cil2cfg.WeiMaoZouChenInput]
eq_nodes [Cil2cfg.LoopInfo]
eq_object [ACSL]
eq_pred [Runtime_mem.Create.Aint]
eq_preds [Fol]
(partial) structural equality
eq_real [Fol_decl]
eq_real_bool [Fol_decl]
eq_record [Mvalues.Values]
eq_record [Datalib.Cvalues]
eq_record_definition [Datalib.Cvalues]
2 struct or union objects are equal when all the fields are equal.
eq_tarray [ACSL]
eq_terms [Fol]
structural equality
eq_var [Formula.S]
eq_var [Fol_formula]
eq_zone [Runtime_mem.Create.Tint]
equal [Mvalues.Values]
equal [LogicRaw.TERM]
equal [LogicRaw.VAR]
equal [LogicId.S]
equal [Fol_formula.LTinfo]
equal [Fol_formula.HC_ArrayDim]
equal [Fol_formula.HC_object]
equal [Fol.Var]
equal [Datalib.Cvalues]
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 [Wpo.WPO]
equal [Set.S]
equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
equal [Cil2cfg.VL]
equal [Ctypes.AinfoComparable]
equal [Ctypes]
equal_loc [Mvalues.Model]
equal_loc [Hoare_mem.Create.Model]
equal_loc [Store_mem.Create.Model]
equal_loc [Runtime_mem.Create.Model]
equal_loc [Funvar_mem.Create.Model]
equal_loc [Datalib.Cvalues]
equal_loc_bool [Mvalues.Model]
equal_loc_bool p q is the boolean that is true when locs p and q, that points to elements of type ty, are equal.
equal_loc_bool [Hoare_mem.Create.Model]
equal_loc_bool [Store_mem.Create.Model]
equal_loc_bool [Runtime_mem.Create.Model]
equal_loc_bool [Funvar_mem.Create.Model]
equal_loc_bool [Datalib.Cvalues]
equal_rec [Datalib.Cvalues]
equal_terms [Formula.S]
Returns true when the two terms are syntactically equals
equal_terms [Fol_formula]
eraise [Script]
error [Kreal]
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 [Formula.Logic]
exists [Datalib.Create]
exists [Map.S]
exists p m checks if at least one binding of the map satisfy the predicate p.
exists [Set.S]
exists p s checks if at least one element of the set satisfies the predicate p.
exit_status [Translate_prop.Create]
export [LogicDef]
export [Prover]
export [Cil2cfg]
export_decl [Mwp.Export]
export_decl [Mcfg.Export]
export_decl [Fol_coq.ECoq]
export_decl [Fol_ergo.Make]
export_decl [Fol_ergo]
export_decl [Fol_why.EWhy]
export_depends_for_item [Fol_formula]
export_depends_for_name [Fol_formula]
export_depends_for_pred [Fol_formula]
export_depends_for_term [Fol_formula]
export_generated_axiomatics [Fol_ergo]
export_generated_axiomatics [Fol_pretty]
export_get_set_field [Fol_ergo]
export_get_set_field [Fol_pretty]
export_get_set_other [Fol_ergo]
export_get_set_other [Fol_pretty]
export_goal [Mwp.Export]
export_goal [Mcfg.Export]
export_goal [LogicDef]
export_goal [Fol_coq.ECoq]
export_goal [Fol_ergo.Make]
export_goal [Fol_ergo]
export_goal [Fol_why.EWhy]
export_item [Fol_coq.ECoq]
export_item [Fol_ergo]
export_item [Fol_why.EWhy]
export_items [LogicDef]
export_pred [Fol_coq.ECoq]
export_pred [Fol_ergo]
export_pred [Fol_why.EWhy]
export_section [Mcfg.Export]
export_section [Fol_coq.ECoq]
export_section [Fol_ergo.Make]
export_section [Fol_why.EWhy]
export_tau [Fol_coq.ECoq]
export_tau [Fol_ergo.Make]
export_tau [Fol_ergo]
export_tau [Fol_why.EWhy]
export_term [Fol_coq.ECoq]
export_term [Fol_ergo]
export_term [Fol_why.EWhy]
export_wpo [CfgProof.Create]
exported_macros [Fol_formula]
expp [Fol_eval]
expr [CfgWeakestPrecondition.Create]
expr [Translate_expr.Create]
expr mem e interprets the expressione as a value in memory mem *
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]
extend [LogicId]
extern [LogicId]
extract_from_data [Translate_prop.Create]

F
f_cmp [Mfloat.S]
f_cmp [Mfloat_natural.Create]
f_convert [Ctypes]
f_format [Runtime_mem.Create]
f_neg [Mfloat.S]
f_neg [Mfloat_natural.Create]
f_op [Mfloat.S]
f_op [Mfloat_natural.Create]
f_sizeof [Ctypes]
f_suffixe [Fol_pretty]
fcmp_operator [Translate_expr.Create]
fdx [Ctypes]
field [Mvalues.S]
field [Mvalues.Data]
field [LogicHavoc]
field fs f r is empty for all fs except f for which it is r
field [Fol_coq]
field [Hoare_mem.Create]
field [Store_mem.Create.Data]
field [Runtime_mem.Create.Data]
Even if union field has 0 offset, we have to use on operation because the size of the location to be consider might change from one field to another.
field [Funvar_mem.Create]
field_of [ACSL]
field_offset [Ctypes]
fields [LogicHavoc]
file_for_body [Wpo]
Dynamically exported.
file_for_ctxt [Wpo]
file_for_env [Wpo]
file_for_goal [Wpo]
file_for_head [Wpo]
file_for_lang [Wpo]
file_for_log_check [Wpo]
file_for_log_proof [Wpo]
file_for_log_proof_ [Wpo]
file_for_model [Wpo]
file_for_po [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 [Map.S]
filter p m returns the map with all the bindings in m that satisfy predicate p.
filter [Set.S]
filter p s returns the set of all elements in s that satisfy predicate p.
filter_both [WpStrategy]
filter_precond [WpAnnot]
filter_scope [Store_mem.Create]
filter_status [WpAnnot]
find [Calculus.Cfg.R]
find [Map.S]
find x m returns the current binding of x in m, or raises Not_found if no such binding exists.
find [Hashtbl.S]
find [Cil2cfg.HEsig]
find [Cil2cfg.HE]
find [State_builder.Hashtbl]
Return the current binding of the given key.
find_all [Hashtbl.S]
find_all [Cil2cfg.HEsig]
find_all [Cil2cfg.HE]
find_all [State_builder.Hashtbl]
Return the list of all data associated with the given key.
find_behaviors [WpAnnot]
empty bhv_names means all (whatever ki is)
find_mem [Translate_prop.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_stmt_node [Cil2cfg]
fixpoint [LogicDef.Cofix]
fixpoint [LogicDef]
Retrieve the definition of f if already defined.
flatten [Fol_split.SplitZoneInclusion]
flatten_formals [Translate_prop.Create]
flatten_references [Translate_prop.Create]
float_of_data [Store_mem.Create]
float_of_value [Translate_expr.Create]
float_operator [Translate_expr.Create]
flow [Wpo]
flush [Formula.Logic]
flush [Fol_eqs]
flush [Datalib.Create]
flush_context [Translate_prop.Create]
fmemo [Ctypes]
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 [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 [State_builder.Hashtbl]
fold_alpha [Formula.S]
fold_alpha [Fol_formula]
fold_and [LogicPretty]
fold_assoc [LogicPretty]
fold_bhv_post_cond [WpStrategy]
apply f_normal on the Normal postconditions, f_exits on the Exits postconditions, and warn on the others.
fold_hyp [LogicPretty]
fold_implies [LogicPretty]
fold_nodes [Cil2cfg]
iterators
fold_or [LogicPretty]
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 [Map.S]
for_all p m checks if all the bindings of the map satisfy the predicate p.
for_all [Set.S]
for_all p s checks if all elements of the set satisfy the predicate p.
forall [Formula.Logic]
forall [LogicHavoc]
forall [Datalib.Create]
forall_loc [Mvalues.Data]
forall_loc [Store_mem.Create.Data]
forall_loc [Runtime_mem.Create.Data]
format_of_addr [Runtime_mem.Create]
format_of_array [Runtime_mem.Create]
format_of_compinfo [Runtime_mem.Create]
fpp_decl [Fol_coq]
fpp_decl [Fol_ergo]
fpp_decl [Fol_pretty]
fpp_f_let [Fol_coq]
fpp_f_let [Fol_ergo]
fpp_fields [Fol_coq]
fpp_goal [Fol_coq]
fpp_goal [Fol_ergo]
fpp_goal [Fol_pretty]
fpp_header [Fol_coq]
fpp_header [Fol_ergo]
fpp_header [Fol_pretty]
fpp_item [Fol_coq]
fpp_item [Fol_ergo]
fpp_item [Fol_pretty]
fpp_lf_let [Fol_coq]
fpp_lf_let [Fol_ergo]
fpp_pred [Fol_coq]
fpp_pred [Fol_ergo]
fpp_pred [Fol_pretty]
fpp_term [Fol_coq]
fpp_term [Fol_ergo]
fpp_term [Fol_pretty]
fpretty_term [Fol_pretty]
fract_real [Fol_decl]
free [Hoare_mem.Create]
free [Runtime_mem.Create.RtLib]
free_pred [Fol_formula]
free_term [Fol_formula]
free_vars [Fol_cc]
free_vars [Hoare_mem.Create]
free_vars [Store_mem.Create]
freevars [Formula.S]
freevars [Fol_formula]
fresh [Formula.Logic]
fresh [LogicLib]
fresh [LogicLang]
fresh [LogicRaw.VAR]
fresh [Fol_eqs]
fresh [Fol_let]
fresh [Datalib.Create]
fresh_addr [Translate_prop.Create]
fresh_local [Translate_prop.Create]
fresh_logic_var [Translate_prop.Create]
fresh_name [Formula.S]
fresh_name [Fol_formula]
fresh_named_var [Fol.Var]
fresh_params [Fol_let]
fresh_var [Fol_formula]
fresh_var [Fol.Var]
fresh_vars [Store_mem.Create]
fresh_vars_in_pred [Fol]
freshen [LogicRaw.VAR]
from_bits [Runtime_mem.Create.RtLib]
fsort [LogicHavoc]
full [LogicHavoc]
fun_load [Funvar_mem.Create]

G
gaddress_of_cvar [Translate_prop.Create]
gaddress_of_mem [Translate_prop.Create]
gaddress_of_ref [Translate_prop.Create]
gclear [Fol_formula]
gdummy [Fol_formula]
generic_compute [Register]
get [Po_navigator.Prover_Column]
get [Wpo.Results]
get [Cil2cfg]
get [String]
String.get s n returns character number n in string s.
get [State_builder.Ref]
Get the referenced value.
get_and_init [WpFroms.Vars]
get_annots [WpStrategy]
get_asgn_goal [WpStrategy]
get_asgn_hyp [WpStrategy]
get_assigns_method [Wp_parameters]
get_behav [WpAnnot]
Select in bhv_list the behavior that has to be processed according to config and ki current statement.
get_behavior_annots [WpAnnot]
Builds tables that give hypotheses and goals relative to b behavior for edges of the cfg to consider during wp computation.
get_behavior_strategies [WpAnnot]
Compute the strategy to prove all the properties of the behavior.
get_bhv_assumes [WpAnnot]
get_bhv_pre [WpFroms]
get_both_hyp_goals [WpStrategy]
get_c_funvar [Funvar_mem.Create]
get_call_annots [WpAnnot]
get_call_asgn [WpStrategy]
get_call_hyp [WpFroms]
get_call_hyp [WpStrategy]
To be used as hypotheses arround a call, (the pre are in get_call_pre_goal)
get_call_out_edges [Cil2cfg]
similar to succ_e g v but gives the edge to VcallOut first and the edge to Vexit second.
get_call_pre [WpStrategy]
Preconditions of a called function to be considered as hyp and goal (similar to get_both_hyp_goals).
get_call_pre_strategies [WpAnnot]
get_called_assigns [WpAnnot]
Properties for assigns of kf
get_called_exit_conditions [WpAnnot]
get_called_kf [WpStrategy]
get_called_post [WpFroms]
Collect the \from hypotheses of the function spectication.
get_called_post_conditions [WpAnnot]
get_called_postconds [WpAnnot]
get_called_preconditions_at [WpAnnot]
get_cfg [WpAnnot]
get_cut [WpStrategy]
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_cycle [LogicDef.Cofix]
get_declaration [LogicDef]
Raise Not_found if the symbol is undefined.
get_definition [Formula.S.Registry]
get_definition [Translate_prop.Create]
get_definition [Fol_formula.Registry]
get_definition [Fol_formula.DRegister]
get_description [LogicDef]
Raise Not_found if the symbol is undefined.
get_edge_labels [Cil2cfg]
get_edge_next_stmt [Cil2cfg]
get_env [Wp_parameters]
get_exit_edges [Cil2cfg]
Find the edges e that goes to the Vexit node inside the statement begining at node n
get_fct_bhv_from_annots [WpFroms]
Collect all the annotations to be used to prove one \from property of the function behavior *
get_fct_post_annots [WpAnnot]
get_fct_pre_annots [WpAnnot]
get_field [Fol_ergo]
get_field [Fol_pretty]
get_function_strategies [WpAnnot]
Compute the strategies to prove all the properties of the selected function.
get_funvar [Funvar_mem.Create]
get_gid [Wpo]
Dynamically exported
get_goal_only [WpStrategy]
get_hyp_only [WpStrategy]
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 [Formula.S.Indexed]
get_ind [Fol_formula.Indexed]
get_ind [Fol_formula.Dindex]
get_induction [WpPropId]
Quite don't understand what is going on here...
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_item [LogicDef]
Raise Not_found if the symbol is undefined.
get_kind_for_tk [WpPropId]
get_linfo [WpFroms]
Find the logic_info for the given name and signature.
get_local_depends [LogicDef]
get_logic_funvar [Funvar_mem.Create]
get_loop_annots [WpAnnot]
Returns the annotations for the three edges of the loop node: loop_entry : goals for the edge entering in the loop, loop_back : goals for the edge looping to the entry point, loop_core : fix-point hypothesis for the edge starting the loop core
get_loop_assigns_for_froms [WpFroms]
get_loop_stmt [WpPropId]
find the outer loop in which the stmt is.
get_model [Wp_parameters]
get_models [Wp_parameters]
get_named_bhv [WpAnnot]
find the behavior named name in the list
get_node [Cil2cfg]
get_norm [Wp_parameters]
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_post_edges [Cil2cfg]
Find the edges where the postconditions of the node statement have to be checked.
get_post_logic_label [Cil2cfg]
Get the label to be used for the Post state of the node contract if any.
get_pre_edges [Cil2cfg]
Find the edges where the precondition of the node statement have to be checked.
get_precond_strategies [WpAnnot]
get_pred_linfo [WpFroms]
get_prop_id [Wpo]
get_prop_strategies [WpAnnot]
Similar to get_id_prop_strategies but with a named property.
get_provers [Wp_parameters]
get_result [Wpo]
Dynamically exported.
get_results [Wpo]
get_share [Wp_parameters]
get_stmt_annots [WpAnnot]
get_stmt_hyp [WpFroms]
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_strategies_for_froms [WpFroms]
Build strategies to prove the from properties of the function.
get_strategy [Wp_gui]
get_strategy_for_from [WpFroms]
get_subgraph [Cil2cfg.Printer]
get_switch_edges [Cil2cfg]
similar to succ_e g v but give the switch cases and the default edge
get_test_edges [Cil2cfg]
Get the edges going out a test node with the then branch first
get_ufield [Fol_coq]
get_value [ACSL.Register]
get_var [Hoare_mem.Create]
Get the wp variable of the C variable.
get_weakest_precondition [Calculus.Cfg]
get_wp_edge [Calculus.Cfg]
get_zrange_opt [Store_mem.Create]
gfresh [Fol_formula]
gid [Wpo]
gindex [Fol_formula]
gindexref [Fol_formula]
global [Mvalues.S]
global [Hoare_mem.Create]
global [Store_mem.Create.Data]
global [Runtime_mem.Create.Data]
global [Funvar_mem.Create]
global_axioms [WpStrategy]
global_scope [Mwp.S]
global_scope [Hoare_mem.Create]
global_scope [Store_mem.Create]
global_scope [Runtime_mem.Create]
global_scope [Funvar_mem.Create]
goal_to_select [WpAnnot]
graph_attributes [Cil2cfg.Printer]
gsection [Fol_formula]
gstartof [Translate_prop.Create]
gstartof_cvar [Translate_prop.Create]
gstartof_mem [Translate_prop.Create]
gstartof_value [Translate_prop.Create]
gtoc [Fol_formula]
guard [Formula.S]
guard [Fol_formula]
gui_provers [Wpo]

H
has_context_vars [Formula.Logic]
has_context_vars [Datalib.Create]
has_ctype [ACSL]
has_declaration [Formula.S]
has_declaration [Fol_formula]
has_exit [Cil2cfg]
wether an exit edge exists or not
has_ind [Formula.S.Indexed]
has_ind [Fol_formula.Indexed]
has_ind [Fol_formula.Dindex]
has_object [ACSL]
has_prefix [Clabels]
has_reserved_prefix [Fol_decl]
has_type [Formula.Logic]
has_type [Datalib.Create]
hash [LogicRaw.VAR]
hash [LogicId.S]
hash [Fol_formula.LTinfo]
hash [Fol_formula.HC_ArrayDim]
hash [Fol_formula.HC_object]
hash [Wpo.WPO]
hash [Cil2cfg.VL]
hash [Ctypes.AinfoComparable]
hash [Ctypes]
hash [Datatype.Set]
havoc [Runtime_mem.Create.RtLib]
havoc_inductive [Formula.Logic]
havoc_inductive [Datalib.Create]
havoc_region [CfgWeakestPrecondition.Create]
havoc_static [Formula.Logic]
havoc_static [Datalib.Create]
help_array_reference_pattern_term [Variables_analysis]
help_by_array_reference_pattern [Variables_analysis]
hooks [Wprop.Indexed]
huge_pred [Formula.S]
huge_pred [Fol_formula]
huge_pred [Fol]
huge_term [Formula.S]
huge_term [Fol_formula]
huge_term [Fol]

I
i_add [Formula.S]
i_add [Fol_formula]
i_apply [Fol]
i_bool [LogicLang]
i_bool [Fol_formula]
i_cmp [Mint.S]
i_cmp [Mint_natural.Create]
i_compare [LogicRaw.PRED]
i_compare [LogicRaw.TERM]
i_compare [Fol]
i_compute [LogicRaw.TERM]
i_compute [Fol]
i_convert [Formula.S]
i_convert [Fol_formula]
i_convert [Ctypes]
i_format [Runtime_mem.Create]
i_mult [Formula.S]
i_mult [Fol_formula]
i_neg [Mint.S]
i_neg [Mint_natural.Create]
i_one [Formula.S]
i_one [Fol_formula]
i_op [Mint.S]
i_op [LogicLang]
i_op [Fol_formula]
i_op [Mint_natural.Create]
i_pred [LogicLang]
i_pred [Fol_formula]
i_sizeof [Ctypes]
All sizes are in bits
i_sub [Formula.S]
i_sub [Fol_formula]
i_zero [Formula.S]
i_zero [Fol_formula]
icmp_operator [Translate_expr.Create]
id_prop_txt [WpPropId]
TODO: this one should be in Properties_status.
ident [Script]
ident_named_var [Fol.Var]
identifier [Fol_decl]
identify_loops [Cil2cfg.WeiMaoZouChen]
idents [Script]
idfree [LogicId]
idref [LogicId]
idx [Ctypes]
imemo [Ctypes]
in_range [ACSL]
in_range [LogicHavoc]
in_range [Data_mem.Create]
included [Fol_split.SplitZoneInclusion]
incr [Cil2cfg.LoopInfo]
incr_addr_taken [Variables_analysis]
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 [Formula.S.Identifiable]
index [LogicHavoc]
index [Fol_formula.Identifiable]
index [Fol_formula.LTinfoId]
index [Fol_formula.ArrayDim]
index [Fol_formula.Cobject]
index [Fol_formula.Logicvar]
index [Fol_formula.LTypeinfo]
index [Fol_formula.Arrayinfo]
index [Fol_formula.Compinfo]
index [Fol_formula.Fieldinfo]
index [Fol_formula.Varinfo]
index [Hoare_mem.Create]
index [Store_mem.Create.Data]
index [Runtime_mem.Create.Data]
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_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.
indice [LogicId]
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_global_variable [Calculus.Cfg]
init_range [Mcfg.S]
init_range env lv t_elt a b wp : put default values of type t_elt in lvk with a <= k < b
init_range [CfgWeakestPrecondition.Create]
init_range [Cfgpropid.Create]
init_value [Mcfg.S]
init_value env lv t v_opt wp: put value of type t (or default if None) in lv
init_value [CfgWeakestPrecondition.Create]
init_value [Cfgpropid.Create]
init_value_term [Datalib.Cvalues]
init_value_term_rec [Datalib.Cvalues]
inner_loc [Mlogic.S]
inner_loc l returns the location corresponding to l in the inner memory model in funvar.
inner_loc [Hoare_mem.Create]
inner_loc [Store_mem.Create.Data]
inner_loc [Runtime_mem.Create.Data]
inner_loc [Funvar_mem.Create]
insert_loop_node [Cil2cfg]
int64_max [Ctypes]
int_cmp [Translate_prop.Create]
int_format [Runtime_mem.Create]
int_format_for_hyp [Runtime_mem.Create]
int_of_data [Store_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 [Fol_formula]
integer_of_real [Fol_decl]
integer_of_value [Translate_prop.Create]
integer_of_xaddr [Runtime_mem.Create.Tint]
integers [Fol_formula]
inter [Formula.S]
inter s0 s1 returns the intersection set of s0 and s1.
inter [Fol_formula]
inter [Set.S]
Set intersection.
internal_function_behaviors [WpAnnot]
internal_pretty_code [Datatype.Set]
interval [Formula.S]
range l h returns the integer set s such as { i in s | l <= i <= h }.
interval [Fol_formula]
inv_of_loop_from [WpFroms]
Build the from hyp for the loop assigns
ip_complete [WpAnnot]
ip_disjoint [WpAnnot]
isHoare [Register.HCriteria]
isHoare [Register.MCriteria]
isHoare [Funvar_mem.Criteria]
isVarTypePointerType [Variables_analysis]
is_annot_for_config [WpAnnot]
(see test_behav_res above).
is_array [Formula.Logic]
is_array [Datalib.Create]
is_assigns [WpPropId]
is_atomic [LogicLang]
is_atomic [LogicRaw.SUBST]
is_back_edge [Cil2cfg]
is_comp [Formula.Logic]
is_comp [Datalib.Create]
is_composed [WpAnnot]
whether a proof needs several lemma to be complete
is_darray [ACSL]
is_defined [Translate_prop.Create.UserAxiomDefs]
is_empty [Hook.S]
Is no function already registered in the hook?
is_empty [CfgWeakestPrecondition.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.Logs]
is_false [Formula.S]
is_false [Fol_formula]
is_false [Fol]
is_formal_var_type [Variables_analysis]
is_havoc [LogicHavoc]
is_havoc [Runtime_mem.Create.RtLib]
is_incl_comp [Fol_formula]
is_int [ACSL]
is_interactive [Wpo]
is_irreducible [Cil2cfg.LoopInfo]
is_lformal [Variables_analysis]
is_macro [Fol_formula]
is_macro_section [Fol_formula]
is_main_init [WpStrategy]
The function is the main entry point AND it is not a lib entry
is_memvar [Variables_analysis]
is_null [Mvalues.Model]
Take a term representing an address and returns a term of type bool.
is_null [Hoare_mem.Create.Model]
is_null [Store_mem.Create.Model]
is_null [Runtime_mem.Create.Model]
is_null [Funvar_mem.Create.Model]
is_null [Datalib.Cvalues]
is_out [Wp_parameters]
is_pass1 [Calculus.Cfg.R]
is_proved [WpAnnot]
wether all partial proofs have been accumulated or not
is_pure_logic [Variables_analysis]
is_ref [Variables_analysis]
is_requires [WpPropId]
is_rte_generated [Wp_gui]
is_rte_precond [Wp_gui]
is_simple [Fol_let]
is_stable [LogicDef.Cofix]
is_to_scope [Variables_analysis]
is_to_scope v returns true if v has to been scoped into the inner memory model : cvar of ref
is_true [Formula.S]
is_true [Fol_formula]
is_true [Fol]
is_user_formal_in_builtin [Variables_analysis]
is_user_formal_in_builtins lv tests if the address of the by-reference formal lv of user definition is an argument of (one or more) ACSL builtin predicate(s) or function : valid and family, separated, block_length, initialized
is_valid [Wpo]
true if the result is valid.
is_void [Ctypes]
is_zone [Fol_split]
iter [LogicRaw.PRED]
iter [LogicRaw.TERM]
iter [LogicId]
iter [Map.S]
iter f m applies f to all bindings in map m.
iter [Wpo.Results]
iter [Hashtbl.S]
iter [Wpo]
iter [Set.S]
iter f s applies f in turn to all elements of s.
iter [String]
String.iter f s applies function f in turn to all the characters of s.
iter [State_builder.Hashtbl]
iter_all [Formula.S]
iter_all [Fol_formula]
iter_description [Cfgpropid.Create]
iter_dnodes [Cfgpropid]
iter_edges [Cil2cfg]
iter_edges_e [Cil2cfg.Printer]
iter_nodes [Cil2cfg]
iter_on_goals [Wpo]
Dynamically exported.
iter_pred_e [Cil2cfg]
iter_succ [LogicDef.Components.G]
iter_succ [Cil2cfg]
iter_succ_e [Cil2cfg]
iter_vertex [Cil2cfg.Printer]

J
job [Wp_parameters]

K
kernel_functions_separation_hyps [Variables_analysis]
key [Script]
keywords [Script]
kill [Formula.Logic]
kill [Datalib.Create]
kill_context [Translate_prop.Create]
kind_equal [Translate_prop.Create]
kind_of [Translate_prop.Create]
kind_of_data [Translate_prop.Create]
kind_of_formal [Variables_analysis]
kind_of_property [Wp_gui]
kind_of_typ [Translate_prop.Create]
kind_of_var [Formula.S]
kind_of_var [Fol_formula]
kind_of_var [Fol.Var]
kind_order [WpPropId]
kind_to_select [WpAnnot]

L
label [Mcfg.S]
label [CfgWeakestPrecondition.Create]
label [Cfgpropid.Create]
label [Clabels]
label_of_kind [WpPropId]
label_of_prop_id [WpPropId]
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]
Dynamically exported.
language_of_prover [Wpo]
language_of_prover_name [Wpo]
le_int [Fol_decl]
le_int_bool [Fol_decl]
le_loc [Mvalues.Model]
le_loc p q is the less than or equal comparison of locs p and q, that points to elements of type ty, ie.
le_loc [Hoare_mem.Create.Model]
le_loc [Store_mem.Create.Model]
le_loc [Runtime_mem.Create.Model]
le_loc [Funvar_mem.Create.Model]
le_loc [Datalib.Cvalues]
le_loc_bool [Mvalues.Model]
le_loc_bool p q is the less than or equal comparison of locs p and q, that points to elements of type ty, ie.
le_loc_bool [Hoare_mem.Create.Model]
le_loc_bool [Store_mem.Create.Model]
le_loc_bool [Runtime_mem.Create.Model]
le_loc_bool [Funvar_mem.Create.Model]
le_loc_bool [Datalib.Cvalues]
le_real [Fol_decl]
le_real_bool [Fol_decl]
length [Hook.S]
Number of registered functions.
length [Hashtbl.S]
length [String]
Return the length (number of characters) of the given string.
length [State_builder.Hashtbl]
Length of the table.
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).
letter [LogicId]
lib_is_int [ACSL]
lib_to_int [ACSL]
library [LogicId]
Returns an id for an external symbol
link [LogicId]
Link the identifier to some absolute name.
list_of [Translate_prop.Create]
load [Mvalues.S]
load [Hoare_mem.Create]
load [Store_mem.Create]
load [Runtime_mem.Create.RtLib]
load [Runtime_mem.Create]
load [Funvar_mem.Create]
load_mem [Mvalues.Data]
load_mem [Store_mem.Create.Data]
load_mem [Store_mem.Create]
load_mem [Runtime_mem.Create.Data]
Read a data of type te at loc and returns it as a logic value.
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_term [Mvalues.Model]
loc_of_term [Hoare_mem.Create.Model]
loc_of_term [Store_mem.Create.Model]
loc_of_term [Runtime_mem.Create.Model]
loc_of_term [Funvar_mem.Create.Model]
loc_of_term [Datalib.Cvalues]
loc_of_value [Translate_expr.Create]
loc_offset [Translate_prop.Create]
loc_range [Fol_formula]
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 [Hoare_mem.Create]
local_scope [Store_mem.Create]
local_scope [Runtime_mem.Create]
local_scope [Funvar_mem.Create]
location [Formula.S.Identifiable]
location [Fol_formula.Identifiable]
location [Fol_formula.LTinfoId]
location [Fol_formula.ArrayDim]
location [Fol_formula.Cobject]
location [Fol_formula.Logicvar]
location [Fol_formula.LTypeinfo]
location [Fol_formula.Arrayinfo]
location [Fol_formula.Compinfo]
location [Fol_formula.Fieldinfo]
location [Fol_formula.Varinfo]
lock [Translate_prop.Create.UserDefinition]
lock [LogicDef]
locked [Fol_formula]
log_status [Prover.Logs]
logic_of_value [Mvalues.Values]
logic_of_value [Datalib.Cvalues]
logic_offset [Translate_prop.Create]
logic_param_memory_info [Variables_analysis]
lookup [LogicDef.Cofix]
lookup [LogicDef]
lookup [Clabels]
lookup bindings lparam retrieves the actual label for the label in bindings for label parameter lparam.
lookup_called_preconditions_at [WpAnnot]
loop_head_label [Clabels]
loop_nodes [Cil2cfg]
loop_with_cut [Calculus.Cfg]
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 [Fol_decl]
lt_int_bool [Fol_decl]
lt_loc [Mvalues.Model]
lt_loc p q is the less than comparison of locs p and q, that points to elements of type ty, ie.
lt_loc [Hoare_mem.Create.Model]
lt_loc [Store_mem.Create.Model]
lt_loc [Runtime_mem.Create.Model]
lt_loc [Funvar_mem.Create.Model]
lt_loc [Datalib.Cvalues]
lt_loc_bool [Mvalues.Model]
lt_loc_bool p q is the less than comparison of locs p and q, that points to elements of type ty, ie.
lt_loc_bool [Hoare_mem.Create.Model]
lt_loc_bool [Store_mem.Create.Model]
lt_loc_bool [Runtime_mem.Create.Model]
lt_loc_bool [Funvar_mem.Create.Model]
lt_loc_bool [Datalib.Cvalues]
lt_real [Fol_decl]
lt_real_bool [Fol_decl]
lvar [Mlogic.S]
lvar m lv p returns a location associated to the location variable lv with variable root name x.
lvar [Translate_prop.Create]
lvar [Hoare_mem.Create]
lvar [Store_mem.Create.Data]
lvar [Runtime_mem.Create.Data]
lvar [Funvar_mem.Create]

M
main [Wp_gui]
main [Register]
make [Prover.PO]
make [String]
String.make n c returns a fresh string of length n, filled with the character c.
make_array [Funvar_mem.Create]
make_c_float [Ctypes]
make_c_int [Ctypes]
make_goal [Cfgpropid.Create]
make_gui_dir [Wp_parameters]
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_output_dir [Wp_parameters]
make_panel [Po_navigator]
make_tmp_dir [Wp_parameters]
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 [LogicId]
mark_history [LogicDef]
mark_loops [Cil2cfg]
massigned [Funvar_mem.Create]
matrix [LogicHavoc]
max_binding [Map.S]
Same as Map.S.min_binding, but returns the largest binding of the given map.
max_elt [Set.S]
Same as Set.S.min_elt, but returns the largest element of the given set.
mcvar [Funvar_mem.Create.Lookup]
mem [Mvalues.S]
mem [Hoare_mem.Create]
mem [Store_mem.Create.Data]
mem [Runtime_mem.Create]
mem [Funvar_mem.Create]
mem [Map.S]
mem x m returns true if m contains a binding for x, and false otherwise.
mem [Hashtbl.S]
mem [Set.S]
mem x s tests whether x belongs to the set s.
mem [Wprop.Indexed2]
mem [State_builder.Hashtbl]
mem [Wprop.Indexed]
mem_at [Translate_prop.Create]
mem_at_env [Translate_prop.Create]
mem_project [Datatype.Set]
memo [Datatype.Hashtbl]
memo tbl k f returns the binding of k in tbl.
memo [State_builder.Hashtbl]
Memoization.
memory_offset [Translate_prop.Create]
merge [Mcfg.S]
merge [CfgWeakestPrecondition.Create]
merge [Cfgpropid.Create]
merge [LogicHavoc]
merge [Map.S]
merge f m1 m2 computes a map whose keys is a subset of keys of m1 and of m2.
merge_acc [WpStrategy]
merge_assign_info [WpPropId]
merge_assigns [CfgWeakestPrecondition.Create]
merge_fields [LogicHavoc]
merge_property [CfgWeakestPrecondition.Create]
merge_signature [LogicHavoc]
merge_with [CfgWeakestPrecondition.Create]
min_binding [Map.S]
Return the smallest binding of the given map (with respect to the Ord.compare ordering), or raise Not_found if the map is empty.
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_loc [Mvalues.Model]
minus_loc ty p q is the arithmetics difference of locs p and q, that points to elements of type ty, ie.
minus_loc [Hoare_mem.Create.Model]
minus_loc [Store_mem.Create.Model]
minus_loc [Runtime_mem.Create.Model]
minus_loc [Funvar_mem.Create.Model]
minus_loc [Datalib.Cvalues]
missing_rte [WpAnnot]
mk [Fol.Var]
mk_annot_id [WpPropId]
mk_aref [Funvar_mem.Create]
mk_assert_id [WpPropId]
mk_assign_post [WpFroms]
Build P(out) where out is the left part of the assigns property.
mk_assign_pre [WpFroms]
Build xi = Init (i) /\ ... forall inputs part of the assigns property.
mk_assigns_info [WpPropId]
mk_axiom_id [WpPropId]
axiom identification
mk_axiom_info [WpPropId]
mk_bhv_from_id [WpPropId]
\from property of function or statement behavior assigns
mk_bhv_implicit_fun_name [WpFroms]
mk_call_pre_id [WpAnnot]
mk_call_pre_id [WpPropId]
mk_call_pre_id called_kf s_call called_pre
mk_code_annot_id [WpPropId]
mk_compl_bhv_id [WpPropId]
complete behaviors property.
mk_decrease_id [WpPropId]
mk_def [Fol_cc]
mk_disj_bhv_id [WpPropId]
disjoint behaviors property.
mk_empty [Fol_decl]
mk_establish_id [WpPropId]
Invariant establishment
mk_fct_assigns_id [WpPropId]
function assigns
mk_fct_from_id [WpPropId]
mk_fct_post_id [WpPropId]
mk_fformat [Runtime_mem.Create]
mk_fguard [Fol_decl]
mk_iformat [Runtime_mem.Create]
mk_iguard [Fol_decl]
mk_imodulo [Fol_decl]
mk_integers [Fol_decl]
mk_inter [Fol_decl]
mk_inv_hyp_id [WpPropId]
Invariant used as hypothesis
mk_kf_any_assigns_info [WpPropId]
mk_kf_assigns_desc [WpPropId]
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 [Clabels]
create a virtual label to a statement (it can have no label)
mk_loop_any_assigns_info [WpPropId]
mk_loop_assigns_desc [WpPropId]
mk_loop_assigns_id [WpPropId]
mk_loop_from_id [WpPropId]
\from property of loop assigns
mk_loop_implicit_fun_name [WpFroms]
mk_loop_label [Clabels]
mk_name [WpFroms]
Build a full qualified name for logic_info about the nth from in the b behavior of the kf function.
mk_new [WpFroms.Vars]
mk_part [WpPropId]
mk_part pid (k, n) build the identification for the k/n part of pid.
mk_path [Funvar_mem.Create]
mk_pre_id [WpPropId]
mk_pred_info [WpPropId]
mk_pref [Funvar_mem.Create]
mk_preserve_id [WpPropId]
Invariant preservation
mk_prop [WpPropId]
mk_radd [Fol_decl]
mk_range [Fol_decl]
mk_range_inf [Fol_decl]
mk_range_sup [Fol_decl]
mk_remove [Fol_decl]
mk_rmult [Fol_decl]
mk_rneg [Fol_decl]
mk_singleton [Fol_decl]
mk_stmt_any_assigns_info [WpPropId]
mk_stmt_assigns_desc [WpPropId]
mk_stmt_assigns_id [WpPropId]
mk_stmt_label [Clabels]
mk_stmt_post_id [WpPropId]
mk_strategy [WpStrategy]
mk_strategy_for_fct_from [WpFroms]
mk_union [Fol_decl]
mk_var_decr_id [WpPropId]
Variant decrease
mk_var_pos_id [WpPropId]
Variant positive
mk_variant_properties [WpStrategy]
mk_xzone [Runtime_mem.Create.Tint]
mloc_of_loc [Funvar_mem.Create.Model]
mloc_of_path [Funvar_mem.Create.Lookup]
mod_int [Fol_decl]
model_access_range [Store_mem.Create]
model_addr [Store_mem.Create]
model_addr_shift [Store_mem.Create]
model_age [LogicDef]
model_alloc [Store_mem.Create]
model_base [Hoare_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 [Hoare_mem.Create]
model_offset [Store_mem.Create]
model_ptr [Hoare_mem.Create]
model_range [Hoare_mem.Create]
model_range_of_ptr [Hoare_mem.Create]
model_range_of_ptr_range [Hoare_mem.Create]
model_rbase [Hoare_mem.Create]
model_roffset [Hoare_mem.Create]
model_separated [Hoare_mem.Create]
model_separated [Store_mem.Create]
model_shift [Hoare_mem.Create]
model_update_havoc [Store_mem.Create]
model_update_range [Store_mem.Create]
model_valid [Hoare_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 [Formula.S]
modulo [Fol_formula]
most_suitable [Proof]
mul_int [Fol_decl]
mul_real [Fol_decl]
mult [Runtime_mem.Create.Aint]
mult_set [Formula.S]
mult_set [Fol_formula]
mvalue_of_value [Funvar_mem.Create]

N
n_size [Hoare_mem.Create]
n_size [Store_mem.Create]
name [CfgProof.Description]
Public name for user feedback
name [ACSL.Compiler]
name [LogicId]
Assigns a unique string to an identifier in the space.
name [Wp_error]
name [Datatype.Set]
name_of_adt [Fol_decl.Tau]
name_of_asked_bhv [WpAnnot]
name_of_field [Runtime_mem.Create]
name_of_prop_id [WpPropId]
Short description of the PO
name_of_var [Formula.S]
name_of_var [Fol_formula]
name_of_var [Runtime_mem.Create]
names_at [Clabels]
ne_int [Fol_decl]
ne_int_bool [Fol_decl]
ne_real [Fol_decl]
ne_real_bool [Fol_decl]
needback [Proof]
needsave [Proof]
neg_int [Fol_decl]
neg_interval [Translate_prop.Create]
neg_real [Fol_decl]
neg_set [Formula.S]
neg_set [Fol_formula]
new_cfg_env [Cil2cfg]
new_env [Mcfg.S]
optionally init env with user logic variables
new_env [CfgWeakestPrecondition.Create]
new_env [Cfgpropid.Create]
new_env [Wpo]
Generates a fresh environment name.
new_fname [Fol_eval]
new_frame [Translate_prop.Create]
new_loop_computation [WpStrategy]
new_name [Fol_cc]
new_vars [WpFroms.Vars]
newline [Script]
next_edge [Cil2cfg]
no_infinite_array [Ctypes]
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
not_arg_computed [Variables_analysis]
not_computed [Variables_analysis]
not_half_computed [Variables_analysis]
not_of_float [Translate_expr.Create]
not_of_int [Translate_expr.Create]
not_of_integer [Translate_expr.Create]
not_of_loc [Translate_expr.Create]
not_of_value [Translate_expr.Create]
not_param_computed [Variables_analysis]
not_yet_implemented [Wp_error]
notexists_vars [Hoare_mem.Create]
notexists_vars [Store_mem.Create]
null [Mvalues.Model]
null return the special location of the memory model designing the null loc.
null [Hoare_mem.Create.Model]
null [Store_mem.Create.Model]
null [Runtime_mem.Create.Model]
null [Funvar_mem.Create.Model]
null [Datalib.Cvalues]
num_of_bhv_from [WpPropId]

O
object_array_of_root [Funvar_mem.Create.Lookup]
object_of [Ctypes]
object_of_array_elem [Ctypes]
Utilities
object_of_loc [Store_mem.Create.Model]
object_of_n_pointed [Funvar_mem.Create.Lookup]
object_of_n_pointed_opt [Funvar_mem.Create.Lookup]
object_of_pointed [Translate_prop.Create]
object_of_pointed [Ctypes]
c_objects of elements pointed to by pointer or array.
object_of_pointed_opt [Funvar_mem.Create.Lookup]
object_of_root [Funvar_mem.Create.Lookup]
obtain [ACSL.Register]
Projectified and memoized C.compile.
obtain [LogicDef.Cofix]
of_int [Runtime_mem.Create.Aint]
of_int64 [Runtime_mem.Create.Aint]
of_name [Prover.SMT]
of_term [Runtime_mem.Create.Aint]
offset [Hoare_mem.Create.Model]
offset [Hoare_mem.Create]
offset [Store_mem.Create.Data]
offset [Store_mem.Create.Model]
offset_of_field [Hoare_mem.Create]
offset_of_field [Store_mem.Create]
ok_array_term [Variables_analysis]
ok_array_term_arg [Variables_analysis]
ok_array_term_formal [Variables_analysis]
ok_pointer_term [Variables_analysis]
ok_ptr_term_arg [Variables_analysis]
ok_ptr_term_formal [Variables_analysis]
on_all_functions [Register]
on_array [Data_mem.Create.Compound]
on_clear [Formula.S]
on_clear [Fol_formula]
on_context [CfgWeakestPrecondition.Create]
on_definition [Formula.S.Registry]
on_definition [Register]
on_definition [Fol_formula.Registry]
on_definition [Fol_formula.DRegister]
on_function [Register]
on_function_names [Register]
on_model [LogicDef]
on_record [Data_mem.Create.Compound]
on_reset [Wp_parameters]
once [Prover.Coq]
only_one_region [LogicHavoc]
op_loc [Funvar_mem.Create.Model]
open_file [Script]
operator_atomic [LogicPretty]
option [Register]
oracle [Funvar_mem]
oracle [Variables_analysis]
output [Prover.Logs]
output_dir [Wp_parameters]

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_and [Formula.S]
p_and [LogicLang]
p_and [LogicRaw.PRED]
p_and [Fol_formula]
p_and [Fol]
p_app [Fol]
p_app0 [Formula.S]
p_app0 [Fol_formula]
p_app1 [Formula.S]
p_app1 [Fol_formula]
p_app2 [Formula.S]
p_app2 [Fol_formula]
p_app3 [Formula.S]
p_app3 [Fol_formula]
p_app4 [Formula.S]
p_app4 [Fol_formula]
p_app5 [Formula.S]
p_app5 [Fol_formula]
p_bind [LogicRaw.SUBST]
p_bool [Formula.S]
p_bool [LogicLang]
p_bool [LogicRaw.PRED]
p_bool [Fol_formula]
p_call [Formula.S]
p_call [LogicLang]
p_call [LogicRaw.PRED]
p_call [Fol_formula]
p_closed [Fol]
p_cond [Formula.S]
p_cond [LogicLang]
p_cond [LogicRaw.PRED]
p_cond [Fol_formula]
p_conj [Formula.S]
p_conj [LogicLang]
p_conj [Fol_formula]
p_conj [Fol]
p_disj [Formula.S]
p_disj [LogicLang]
p_disj [Fol_formula]
p_disj [Fol]
p_eq [Formula.S]
p_eq [Fol_formula]
p_eq [Fol]
p_equal [LogicLang]
p_exists [Formula.S]
p_exists [LogicLang]
p_exists [LogicRaw.PRED]
p_exists [Fol_formula]
p_exists [Fol]
p_exists_vars [Fol]
p_false [Formula.S]
p_false [LogicLang]
p_false [Fol_formula]
p_forall [Formula.S]
p_forall [LogicLang]
p_forall [LogicRaw.PRED]
p_forall [Fol_formula]
p_forall [Fol]
p_forall_vars [Fol]
p_fresh [Formula.S]
p_fresh [Fol_formula]
p_freshen [Formula.S]
p_freshen [Fol_formula]
p_goal [LogicLang]
p_has_var [Fol]
p_hasvar [LogicRaw.PRED]
p_hide [LogicLang]
p_icmp [Formula.S]
p_icmp [LogicLang]
p_icmp [Fol_formula]
p_if [Fol]
p_iff [Formula.S]
p_iff [LogicLang]
p_iff [LogicRaw.PRED]
p_iff [Fol_formula]
p_iff [Fol]
p_implies [Formula.S]
p_implies [LogicLang]
p_implies [LogicRaw.PRED]
p_implies [Fol_formula]
p_implies [Fol]
p_let [LogicLang]
p_let [LogicRaw.SUBST]
p_let [LogicRaw.PRED]
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_named [Formula.S]
p_named [LogicLang]
p_named [Fol_formula]
p_named [Fol]
p_neq [Formula.S]
p_neq [LogicLang]
p_neq [Fol_formula]
p_neq [Fol]
p_not [Formula.S]
p_not [LogicLang]
p_not [LogicRaw.PRED]
p_not [Fol_formula]
p_not [Fol]
p_or [Formula.S]
p_or [LogicLang]
p_or [LogicRaw.PRED]
p_or [Fol_formula]
p_or [Fol]
p_prim [LogicRaw.PRED]
p_rcmp [Formula.S]
p_rcmp [LogicLang]
p_rcmp [Fol_formula]
p_shared [LogicLib]
p_subst [Formula.S]
p_subst [Fol_formula]
p_true [Formula.S]
p_true [LogicLang]
p_true [Fol_formula]
p_unfold [Fol_split]
p_xor [Formula.S]
p_xor [LogicLang]
p_xor [LogicRaw.PRED]
p_xor [Fol_formula]
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 [Fol_formula]
partition [Map.S]
partition p m returns a pair of maps (m1, m2), where m1 contains all the bindings of s that satisfy the predicate p, and m2 is the map with all the bindings of s that do not satisfy p.
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.
parts_of_id [WpPropId]
get the 'part' infomation.
pcmp_operator [Translate_expr.Create]
pcmp_rel [Translate_expr.Create]
pint_cmp [Translate_prop.Create]
plet_expansion [Fol_eval]
plus [Translate_prop.Create]
plus_interval [Translate_prop.Create]
plus_interval_interval [Translate_prop.Create]
pointed_of_arity [Funvar_mem.Create]
pointed_of_n_path [Funvar_mem.Create.Lookup]
pointed_of_path [Funvar_mem.Create.Lookup]
pool [Formula.Logic]
pool [Formula.S]
pool [LogicLang]
pool [LogicRaw.VAR]
pool [Fol_formula]
pool [Datalib.Create]
pop [Formula.Logic]
pop [LogicDef.Cofix]
pop [LogicId]
pop [Datalib.Create]
pop [Datalib.Collector]
post_of_spec_assigns [WpFroms]
For each behavior of the specification, and for each \from in the behavior, return a predicate which is assumes => out_i = implicit_fun_i (inputs).
pp_addr [Runtime_mem.Create.Tint]
pp_annots [WpStrategy]
pp_apply_call [LogicPretty]
Printts "(f x1 ... xn)" of "f" for empty list.
pp_args [Fol_coq]
pp_args [Fol_ergo]
pp_asked_prop [WpAnnot]
pp_assign_info [WpPropId]
pp_assigns [Wp_error]
pp_assigns_desc [WpPropId]
pp_assigns_id [WpPropId]
pp_assigns_mode [WpAnnot]
pp_assoc [LogicPretty]
pp_assoc "0" "+" produces "x1 + x2 + ... + xn" and "0" for empty list
pp_axiom_info [WpPropId]
pp_axiomdef_descr [Translate_prop.Create.UserAxiomDefs]
pp_axiomdef_title [Translate_prop.Create.UserAxiomDefs]
pp_bkind [Cil2cfg]
pp_block [Fol_coq]
pp_block [Fol_ergo]
pp_block [Fol_pretty]
pp_block_implies [Fol_pretty]
pp_call [Variables_analysis]
pp_call_style [LogicPretty]
pp_chaincall [Variables_analysis]
pp_closure [Mlogic.S]
pp_closure [Hoare_mem.Create]
pp_closure [Store_mem.Create]
pp_closure [Runtime_mem.Create]
pp_closure [Funvar_mem.Create]
pp_closures [Translate_prop.Create]
pp_coma [LogicPretty]
pp_coma "," produces "x1, x2, ... xn"
pp_command [Prover.Logs]
pp_ctype [Fol_formula]
pp_current [Prover.Logs]
pp_data [Translate_prop.Create]
pp_decl [Formula.S]
pp_decl [Fol_formula]
pp_depend [Wpo]
pp_dependency [Wpo]
pp_descr [Formula.S.Identifiable]
pp_descr [Cfgpropid.Create]
pp_descr [Fol_formula.Identifiable]
pp_descr [Fol_formula.LTinfoId]
pp_descr [Fol_formula.ArrayDim]
pp_descr [Fol_formula.Cobject]
pp_descr [Fol_formula.Logicvar]
pp_descr [Fol_formula.LTypeinfo]
pp_descr [Fol_formula.Arrayinfo]
pp_descr [Fol_formula.Compinfo]
pp_descr [Fol_formula.Fieldinfo]
pp_descr [Fol_formula.Varinfo]
pp_dim [Fol_formula]
pp_dnode [Cfgpropid]
pp_edge [Cil2cfg]
pp_environment [Wpo]
pp_err [WpFroms]
pp_float [Ctypes]
pp_flow [Fol_coq]
pp_flow [Fol_ergo]
pp_flow [Fol_pretty]
pp_fold_apply [LogicPretty]
pp_fold_apply "e" "f" prints "(f x (f...(f y z)))" or "e".
pp_fold_call [LogicPretty]
pp_fold_call "e" "f" prints "f(x,f(...,f(y,z)))" or "e".
pp_fold_op [LogicPretty]
pp_fold_op "0" "+" prints "x+(...(y+z))" or "0".
pp_formal [Mlogic.S]
pp_formal [Hoare_mem.Create]
pp_formal [Store_mem.Create]
pp_formal [Runtime_mem.Create]
pp_formal [Funvar_mem.Create]
pp_formal_simple [Funvar_mem.Create]
pp_formals [Translate_prop.Create]
pp_formals [Variables_analysis]
pp_function [Wpo]
pp_goal [Formula.S]
pp_goal [Cfgpropid.Create]
pp_goal [Fol_formula]
pp_goal [Wpo]
pp_goal_flow [Wpo]
pp_goal_kind [WpPropId]
pp_goal_part [WpPropId]
pp_goalx [Cfgpropid.Create]
pp_id [LogicId]
Combines name and Format.
pp_id_name [WpPropId]
pp_info_of_strategy [WpStrategy]
pp_int [Ctypes]
pp_interval [Formula.S]
pp_interval [Fol_formula]
pp_kind [Translate_prop.Create]
pp_labels [Translate_prop.Create.UserAxiomDefs]
pp_language [Wpo]
pp_list [Cfgpropid]
pp_list [Fol_coq]
pp_list [Fol_ergo]
pp_list [Fol_pretty]
pp_loc [Mvalues.Model]
pp_loc [Hoare_mem.Create.Model]
pp_loc [Store_mem.Create.Model]
pp_loc [Runtime_mem.Create.Model]
pp_loc [Funvar_mem.Create.Model]
pp_loc [Datalib.Cvalues]
pp_logic_label [Wp_error]
pp_names [WpPropId]
pp_node [Cil2cfg]
pp_node_type [Cil2cfg]
pp_object [Ctypes]
pp_param [Fol_coq]
pp_param [Fol_ergo]
pp_param [Fol_pretty]
pp_path [Funvar_mem.Create.Lookup]
pp_pred [Formula.S]
pp_pred [LogicLang]
pp_pred [Fol_formula]
pp_pred_atom [Fol_formula]
pp_pred_atom [Fol_coq.ECoq]
pp_pred_atom [Fol_ergo]
pp_pred_atom [Fol_why.EWhy]
pp_pred_debug [Fol_formula]
pp_pred_info [WpPropId]
pp_pred_of_pred_info [WpPropId]
pp_pred_vbox [Fol_formula]
pp_prover [Wpo]
pp_ref [Funvar_mem.Create.Model]
pp_result [Wpo]
pp_root [Funvar_mem.Create.Lookup]
pp_section [Formula.S]
pp_section [Fol_formula]
pp_section [Fol_pretty]
pp_status [Prover.Logs]
pp_strategy_info [WpAnnot]
pp_string [LogicPretty]
The %t printer that print the string
pp_string_list [Wp_error]
pp_tau [Mvalues.Values]
pp_tau [Formula.S]
Be careful, this one is only used for debuging message! Do not use for extraction
pp_tau [LogicLang]
pp_tau [Fol_formula]
pp_tau [Fol_pretty]
pp_tau [Fol_decl.Tau]
pp_tau [Datalib.Cvalues]
pp_term [Formula.S]
pp_term [LogicLang]
pp_term [Fol_formula]
pp_term [Fol]
pp_title [Formula.S.Identifiable]
pp_title [Fol_formula.Identifiable]
pp_title [Fol_formula.LTinfoId]
pp_title [Fol_formula.ArrayDim]
pp_title [Fol_formula.Cobject]
pp_title [Fol_formula.Logicvar]
pp_title [Fol_formula.LTypeinfo]
pp_title [Fol_formula.Arrayinfo]
pp_title [Fol_formula.Compinfo]
pp_title [Fol_formula.Fieldinfo]
pp_title [Fol_formula.Varaddr]
pp_title [Fol_formula.Varinfo]
pp_token [Script]
pp_tuple [LogicPretty]
pp_tuple produces "(x1, x2, ... )" and "()" for empty list
pp_tuple_call [LogicPretty]
Prints "f(x1,...,xn)" and "f()" for empty list.
pp_typelist [Fol_coq]
pp_userdef_descr [Translate_prop.Create.UserDefinition]
pp_userdef_title [Translate_prop.Create.UserDefinition]
pp_userformals [Translate_prop.Create.UserDefinition]
pp_value [Mvalues.Values]
pp_value [Datalib.Cvalues]
pp_var [Formula.S]
pp_var [Fol_formula]
pp_var [Fol_coq]
pp_var [Fol_ergo]
pp_var [Fol_pretty]
pp_var_type [Variables_analysis]
pp_vars [CfgWeakestPrecondition.Create]
pp_vkind [Formula.S]
pp_vkind [Fol_formula]
pp_warning [Wpo]
pp_xzone [Runtime_mem.Create.Tint]
pre_cond_id [WpAnnot]
preal_cmp [Translate_prop.Create]
precondition_compute [Variables_analysis]
precondition_compute () adds warnings and precondition suitable to the current optimisations which are activated
pred [Fol_eqs]
pred [Fol_let]
pred_alpha_cv [Fol]
pred_alpha_c data_alpha alpha p -> alpha', p'
pred_calls [Formula.S]
pred_calls [Fol_formula]
pred_calls [Fol]
pred_closed [Formula.S]
pred_closed [Fol_formula]
pred_cmp [Translate_prop.Create]
pred_e [Cil2cfg]
pred_filter [Translate_prop.Create]
pred_has_var [Formula.S]
pred_has_var [Fol_formula]
pred_info_id [WpPropId]
pred_replace [Fol]
predicate [CfgWeakestPrecondition.Create]
predicate_kind_txt [WpPropId]
predop [LogicLang]
predop [Fol_formula]
prefix [Formula.S.Identifiable]
prefix [Fol_formula.Identifiable]
prefix [Fol_formula.LTinfoId]
prefix [Fol_formula.ArrayDim]
prefix [Fol_formula.Cobject]
prefix [Fol_formula.Logicvar]
prefix [Fol_formula.LTypeinfo]
prefix [Fol_formula.Arrayinfo]
prefix [Fol_formula.Compinfo]
prefix [Fol_formula.Fieldinfo]
prefix [Fol_formula.Varaddr]
prefix [Fol_formula.Varinfo]
preproc_annot [NormAtLabels]
preproc_assigns [NormAtLabels]
preproc_label [NormAtLabels]
pretty [Mcfg.S]
pretty [CfgWeakestPrecondition.Create]
pretty [Cfgpropid.Create]
pretty [LogicLang]
pretty [LogicRaw.VAR]
pretty [LogicId.S]
pretty [WpPropId]
pretty [Cil2cfg.EL]
pretty [Cil2cfg.VL]
pretty [Clabels]
pretty [Ctypes]
pretty [Datatype.Set]
pretty_code [Datatype.Set]
pretty_context [WpPropId]
pretty_node [Cil2cfg.WeiMaoZouChenInput]
pretty_node [Cil2cfg.LoopInfo]
pretty_raw_stmt [Cil2cfg.Printer]
process_global_init [Calculus.Cfg]
process_unreached_annots [WpAnnot]
promote [Ctypes]
proof [Prover.Coq]
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_id_name [WpPropId]
prop_of_float [Translate_expr.Create]
prop_of_int [Translate_expr.Create]
prop_of_integer [Translate_expr.Create]
prop_of_loc [Translate_expr.Create]
prop_of_value [Translate_expr.Create]
prop_rcmp [Translate_expr.Create]
prop_rec [Translate_expr.Create]
prop_unop [Translate_expr.Create]
property [Wprop.Info]
property [Wprop.Indexed2]
property [Wprop.Indexed]
property_of_id [Register]
property_of_id [WpPropId]
returns the annotation which lead to the given PO.
protect [Wp_error]
protect_function [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]
protected [Wp_error]
prove [Prover.Coqide]
prove [Prover.Coq]
prove [Prover.AltErgo]
prove [Prover.SMT]
prove [Prover]
prover_names [Wp_parameters]
prover_of_name [Wpo]
ptr [Hoare_mem.Create.Model]
ptr_cmp [Translate_prop.Create]
ptr_reference [Variables_analysis]
ptr_rel [Translate_prop.Create]
push [Formula.Logic]
push [LogicDef.Cofix]
push [LogicId]
push [Datalib.Create]
push [Datalib.Collector]
push_context [Translate_prop.Create]

Q
quantify [Mwp.S]
quantify [Hoare_mem.Create]
quantify [Store_mem.Create]
quantify [Runtime_mem.Create]
quantify [Funvar_mem.Create]

R
r_bool [LogicLang]
r_bool [Fol_formula]
r_op [LogicLang]
r_op [Fol_formula]
r_pred [LogicLang]
r_pred [Fol_formula]
r_zero [Formula.S]
r_zero [Fol_formula]
range [LogicHavoc]
range_inf [Fol_formula]
range_of_assignable [Hoare_mem.Create]
range_sup [Fol_formula]
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 [Runtime_mem.Create]
real_from_bits [Runtime_mem.Create]
real_of_data [Translate_prop.Create]
real_of_integer [Formula.S]
real_of_integer [Fol_formula]
real_of_integer [Fol_decl]
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 [Data_mem.Create]
record_of [ACSL]
record_of_data [Translate_prop.Create]
recursive [LogicDef.Cofix]
redef [Fol_let]
reference_parameter_usage [Variables_analysis]
reference_parameter_usage_lval [Variables_analysis]
reference_parameter_usage_term [Variables_analysis]
refresh_current_wpo [Po_navigator]
refresh_panel [Po_navigator]
To be called when the set of POs has changed
refresh_panel_callback [Po_navigator]
refresh_status [Po_navigator]
To be called when the status of POs has changed
refresh_status_callback [Po_navigator]
region [Store_mem.Create]
register [Po_navigator.Prover_Column]
register [LogicDef]
register_prefix [Fol_decl]
register_script [Proof]
rel_op [Translate_prop.Create]
release_env [Wpo]
Releases the last generated environment name.
remove [Formula.S]
remove s0 s1 returns a set s' such as {b in s' | b in s0 and !(b in s1) }.
remove [Fol_formula]
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 [Wpo.Results]
remove [Hashtbl.S]
remove [Cil2cfg.HEsig]
remove [Cil2cfg.HE]
remove [Set.S]
remove x s returns a set containing all elements of s, except x.
remove [State_builder.Hashtbl]
remove_array_reference_arg [Variables_analysis]
remove_array_reference_param [Variables_analysis]
remove_edge [Cil2cfg]
remove_ptr_reference_arg [Variables_analysis]
remove_ptr_reference_param [Variables_analysis]
replace [Wpo.Results]
replace [Hashtbl.S]
replace [Cil2cfg.HEsig]
replace [Cil2cfg.HE]
replace [State_builder.Hashtbl]
Add a new binding.
reprs [ACSL.Compiler]
reprs [Datatype.Set]
require_env [Prover.Coq]
require_model [Prover.Coq]
require_wp [Prover.Coq]
reserve1 [LogicId]
reserved [LogicId]
Reserves the given names to avoid clash with generated ones.
reserved_prefix_tbl [Fol_decl]
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]
resolve_addr_taken [Variables_analysis]
resolved_call_chain_arg [Variables_analysis]
resolved_call_chain_param [Variables_analysis]
result [Translate_prop.Create]
result [Prover]
result_compile [Prover.Coq]
result_type [Translate_prop.Create]
return [Mcfg.S]
return [CfgWeakestPrecondition.Create]
return [Cfgpropid.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_equal [Funvar_mem.Create.Model]
rt_format_of_ctype [Runtime_mem.Create]
rt_global [Runtime_mem.Create.RtLib]
rt_vsize [Runtime_mem.Create.RtLib]
rte_divMod_status [WpAnnot]
rte_downCast_status [WpAnnot]
rte_find [WpAnnot]
rte_generated [WpAnnot]
rte_memAccess_status [WpAnnot]
rte_precond_status [WpAnnot]
rte_signedOv_status [WpAnnot]
rte_unsignedOv_status [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 [Fol_formula]
s_of_data [Store_mem.Create]
same_edge [Cil2cfg]
same_node [Cil2cfg]
savescripts [Proof]
If necessary, dump the scripts database into the file specified by -wp-script f.
scc_roots [LogicDef.Components]
scope [Mcfg.S]
scope [CfgWeakestPrecondition.Create]
scope [Cfgpropid.Create]
script_for [Prover.Coq]
scriptbase [Proof]
scriptfile [Proof]
section [Formula.S.Declarator]
section [Fol_formula.Declarator]
seed [Fol_formula]
select_by_name [WpPropId]
test if the prop_id has to be selected for the asked name.
select_call_pre [WpPropId]
test if the prop_id has to be selected when we want to select the call precondition the the stmt call (None means all the call preconditions).
separated [Mlogic.S]
separated [Hoare_mem.Create]
separated [Store_mem.Create]
separated [Runtime_mem.Create]
separated [Funvar_mem.Create]
server [Prover]
set [Calculus.Cfg.R]
store the result p for the computation of the edge e.
set [String]
String.set s n c modifies string s in place, replacing the character number n by c.
set [State_builder.Ref]
Change the referenced value.
set_back_edge [Cil2cfg]
set_field [Fol_ergo]
set_field [Fol_pretty]
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 [Formula.S]
set_of_list [Fol_formula]
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_range_index [Formula.S]
set_range_index [Fol_formula]
set_range_index [Fol_decl]
set_result [Wpo]
set_stable [LogicDef.Cofix]
set_ufield [Fol_coq]
set_unreachable [WpAnnot]
setup_precondition_proxy [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 [LogicHavoc]
shift [Hoare_mem.Create]
shift [Store_mem.Create.Data]
shift [Runtime_mem.Create.Data]
shift [Funvar_mem.Create]
shift_field [Runtime_mem.Create.Tint]
shift_loc [Translate_expr.Create]
shift_n_elem [Runtime_mem.Create.Tint]
signed [Ctypes]
true if ikind is signed
signed_in_bound [Fol]
simpl [LogicRaw]
simpl [Fol]
simplify [Mcfg.Splitter]
simplify [Fol_split]
simplify [Prover.SMT]
singleton [Formula.S]
singleton a returns the singleton set containning a.
singleton [Fol_formula]
singleton [Map.S]
singleton x y returns the one-element map that contains a binding y for x.
singleton [Set.S]
singleton x returns the one-element set containing only x.
size_of_int [Runtime_mem.Create.Tint]
size_of_int64 [Runtime_mem.Create.Tint]
sizeof [Hoare_mem.Create]
sizeof [Store_mem.Create]
sizeof_c_object [Runtime_mem.Create]
sizeof_loc [Store_mem.Create.Model]
sizeof_object [Ctypes]
sizeof_path [Funvar_mem.Create.Lookup]
sizeof_poffset [Funvar_mem.Create.Lookup]
skip [Script]
space [LogicLang]
space [LogicId]
Creates an empty name space (but with the external names).
split [Mcfg.Splitter]
split [Fol_split]
First, unfold zones when method is effect-assigns.
split [Map.S]
split x m returns a triple (l, data, r), where l is the map with all the bindings of m whose key is strictly less than x; r is the map with all the bindings of m whose key is strictly greater than x; data is None if m contains no binding for x, or Some v if m binds v to x.
split [WpAnnot]
splits a prop_id goals into prop_id parts for each sub-goals
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 [LogicDef.Cofix]
stack [Datalib.Collector]
stars_exp [Variables_analysis]
stars_lv_typ [Variables_analysis]
stars_term [Variables_analysis]
stars_typ [Variables_analysis]
stars_var_type_typ [Variables_analysis]
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 [Translate_expr.Create]
startof [Hoare_mem.Create]
startof [Store_mem.Create]
startof [Runtime_mem.Create]
startof [Funvar_mem.Create]
status [Translate_prop.Create]
store [Runtime_mem.Create.RtLib]
store [Runtime_mem.Create]
store [Funvar_mem.Create]
store_mem [Mvalues.Data]
store_mem [Store_mem.Create.Data]
store_mem [Store_mem.Create]
store_mem [Runtime_mem.Create.Data]
store_rec [Store_mem.Create.Data]
store_with [Store_mem.Create]
stored [Data_mem.Create]
strange_loops [Cil2cfg]
detect is there are non natural loops or natural loops where we didn't manage to compute back edges (see mark_loops).
strategy_has_asgn_goal [WpStrategy]
strategy_has_prop_goal [WpStrategy]
strategy_kind [WpStrategy]
string_addr [Variables_analysis]
string_of_termination_kind [WpPropId]
TODO: should probably be somewhere else
sub [Runtime_mem.Create.Aint]
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_c_float [Ctypes]
sub_c_int [Ctypes]
sub_int [Fol_decl]
sub_real [Fol_decl]
subproof_idx [WpPropId]
subproof index of this propr_id
subproofs [WpPropId]
About proofs
subset [Set.S]
subset s1 s2 tests whether the set s1 is a subset of the set s2.
subst [Formula.Logic]
subst [Datalib.Create]
subst_havoc [Mwp.S]
Binds the free variables in the wp representing the memory locations that live in zone.
subst_havoc [Hoare_mem.Create]
subst_havoc [Store_mem.Create]
subst_havoc [Runtime_mem.Create]
subst_havoc [Funvar_mem.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 [Hoare_mem.Create]
subst_lval [Store_mem.Create]
subst_lval [Runtime_mem.Create]
subst_lval [Funvar_mem.Create]
subst_result [Translate_prop.Create]
subst_vars_in_pred [Fol]
Similar to change_vars_in_exp but on predicates.
succ_e [Cil2cfg]
suitable [Proof]
switch [Mcfg.S]
switch [CfgWeakestPrecondition.Create]
switch [Cfgpropid.Create]
merge the switch branches :
symb_is_init [Mvalues.Values]
symb_is_init [Datalib.Cvalues]
symb_is_init_range [Mvalues.Values]
symb_is_init_range [Datalib.Cvalues]
system [Wpo]

T
t_alloc [Hoare_mem.Create]
t_alloc [Store_mem.Create]
t_alloc [Runtime_mem.Create]
t_data [Store_mem.Create]
t_mbits [Runtime_mem.Create]
t_mem [Runtime_mem.Create]
t_memory [Store_mem.Create]
tag [Mcfg.S]
tag [CfgWeakestPrecondition.Create]
tag [Cfgpropid.Create]
tag_named [Fol_ergo]
tag_named [Fol_pretty]
target [WpAnnot]
tarray_dim [ACSL]
tarray_elt [ACSL]
tarray_name [ACSL]
tarray_of_arrayinfo [ACSL]
tarray_of_typ [ACSL]
task_for [Prover]
tau_of_ctype [ACSL]
tau_of_ctype [Fol_decl.Tau]
tau_of_ctype [Datalib.Cvalues]
tau_of_ctype_logic [Register.Tr]
tau_of_ctype_logic [Register.Ts]
tau_of_ctype_logic [Register.Th]
tau_of_ctype_logic [Fol_decl.Tau]
tau_of_ctype_logic [Datalib.Cvalues]
tau_of_darray [ACSL]
tau_of_dzone [Mwp.S]
tau_of_dzone [Hoare_mem.Create]
tau_of_dzone [Store_mem.Create]
tau_of_dzone [Runtime_mem.Create]
tau_of_dzone [Funvar_mem.Create]
tau_of_loc [Mvalues.Model]
tau_of_loc [Hoare_mem.Create.Model]
tau_of_loc [Store_mem.Create.Model]
tau_of_loc [Runtime_mem.Create.Model]
tau_of_loc [Funvar_mem.Create.Model]
tau_of_loc [Datalib.Cvalues]
tau_of_logic_type [Mvalues.Values]
tau_of_logic_type [ACSL]
tau_of_logic_type [Fol_decl.Tau]
tau_of_logic_type [Datalib.Cvalues]
tau_of_mem [Mvalues.Data]
tau_of_mem [Store_mem.Create.Data]
tau_of_mem [Runtime_mem.Create.Data]
tau_of_object [Mvalues.Values]
tau_of_object [ACSL]
tau_of_object [Fol_decl.Tau]
tau_of_object [Datalib.Cvalues]
tau_of_object_array [Mvalues.Values]
tau_of_object_array [Datalib.Cvalues]
tau_of_tarray [ACSL]
tau_of_var [Formula.S]
tau_of_var [LogicLang]
tau_of_var [LogicRaw.VAR]
tau_of_var [Fol_formula]
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 [Fol_eqs]
term [Fol_let]
term_alpha_cv [Fol]
term_calls [Formula.S]
term_calls [Fol_formula]
term_calls [Fol]
term_closed [Formula.S]
term_closed [Fol_formula]
term_filter [Translate_prop.Create]
term_has_var [Formula.S]
term_has_var [Fol_formula]
term_of_data [Translate_prop.Create]
term_of_loc [Mvalues.Model]
term_of_loc [Hoare_mem.Create.Model]
term_of_loc [Store_mem.Create.Model]
term_of_loc [Runtime_mem.Create.Model]
term_of_loc [Funvar_mem.Create.Model]
term_of_loc [Datalib.Cvalues]
term_of_xaddr [Runtime_mem.Create.Tint]
term_of_xsize [Runtime_mem.Create.Tint]
term_of_xzone [Runtime_mem.Create.Tint]
term_replace [Fol]
term_such_that [Formula.Logic]
term_such_that [Datalib.Create]
terms_alpha_cv [Fol]
test [Mcfg.S]
test [CfgWeakestPrecondition.Create]
test [Cfgpropid.Create]
test_edge_loop_ok [Calculus.Cfg]
the_model [LogicDef]
to_bits [Runtime_mem.Create.RtLib]
to_int [ACSL]
to_term [Runtime_mem.Create.Aint]
toffset_of_field [Runtime_mem.Create.Tint]
token [Kreal]
token [Script]
touch [LogicId]
Count the identifier in the space.
tracelog [Register]
trail [Kreal]
translate [Prover.SMT]
translate_assigned [CfgWeakestPrecondition.Create]
translate_assigned_targets [CfgWeakestPrecondition.Create]
tsize_of_field [Runtime_mem.Create.Tint]
ty [Datatype.Set]
typ_of_elements [Translate_prop.Create]
typeOf_array_elem [Translate_expr.Create]

U
ufield [Fol_coq]
unalloc [LogicId]
uncapitalize [String]
Return a copy of the argument, with the first character set to lowercase.
union [Formula.S]
union s0 s1 returns the union set of s0 and s1.
union [Fol_formula]
union [Set.S]
Set union.
union_data [Translate_prop.Create]
union_map [Translate_prop.Create]
unions [Formula.S]
unions [Fol_formula]
unique [LogicId]
Reserves the identifier to be assigned its basename as name, if possible.
unlet [Fol_cc]
unlet_pred [Fol_cc]
unlet_term [Fol_cc]
unlock [Translate_prop.Create.UserDefinition]
unlock [LogicDef]
unmark [LogicId]
unop [LogicLang]
unop [Fol_formula]
unreachable_nodes [Cil2cfg]
unsigned_in_bound [Fol]
unstructuredness [Cil2cfg.LoopInfo]
unsupported [Hoare_mem.Create]
unsupported [Store_mem.Create]
unsupported [Runtime_mem]
unsupported [Wp_error]
unwrap [Formula.S]
unwrap [Fol_formula]
upd_base [Store_mem.Create.Model]
upd_field [Formula.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 [Fol_formula]
upd_index [Formula.S]
upd_index [Fol_formula]
upd_obj [Store_mem.Create.Model]
upd_off [Store_mem.Create.Model]
update [Mwp.S]
update [LogicDef.Cofix]
update [LogicDef]
update [Hoare_mem.Create]
update [Store_mem.Create]
update [Runtime_mem.Create]
update [Funvar_mem.Create]
update_offset [Funvar_mem.Create]
updater [CfgProof.Description]
Unique name for the internal updater
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_of_data [Translate_prop.Create]
use_assigns [Mcfg.S]
use_assigns env hid kind assgn goal performs the havoc on the goal.
use_assigns [CfgWeakestPrecondition.Create]
use_assigns [Cfgpropid.Create]
use_loop_assigns [Calculus.Cfg]
user_axiomlabels [Translate_prop.Create]
user_axioms [Translate_prop.Create]
user_default_label [Translate_prop.Create]
user_definitions [Translate_prop.Create]
user_env [Translate_prop.Create]
user_frame [Translate_prop.Create]
user_prop_names [WpPropId]
This is used to give the name of the property that the user can give to select it from the command line (-wp-prop option)
userdef_is_ref_param [Mlogic.S]
userdef_ref_param p tests if p is a by reference logic formal parameter.
userdef_is_ref_param [Hoare_mem.Create]
userdef_is_ref_param [Store_mem.Create]
userdef_is_ref_param [Runtime_mem.Create]
userdef_is_ref_param [Funvar_mem.Create]
userdef_mem_apply [Mlogic.S]
userdef_mem_apply [Hoare_mem.Create]
userdef_mem_apply [Store_mem.Create]
userdef_mem_apply [Runtime_mem.Create]
userdef_mem_apply [Funvar_mem.Create]
userdef_mem_signature [Mlogic.S]
userdef_mem_signature [Hoare_mem.Create]
userdef_mem_signature [Store_mem.Create]
userdef_mem_signature [Runtime_mem.Create]
userdef_mem_signature [Funvar_mem.Create]
userdef_ref_apply [Mlogic.S]
userdef_ref_apply [Hoare_mem.Create]
userdef_ref_apply [Store_mem.Create]
userdef_ref_apply [Runtime_mem.Create]
userdef_ref_apply [Funvar_mem.Create]
userdef_ref_has_cvar [Mlogic.S]
userdef_ref_has_cvar p tests if the by reference logic formal parameter p needs a C addresses.
userdef_ref_has_cvar [Hoare_mem.Create]
userdef_ref_has_cvar [Store_mem.Create]
userdef_ref_has_cvar [Runtime_mem.Create]
userdef_ref_has_cvar [Funvar_mem.Create]
userdef_ref_signature [Mlogic.S]
userdef_ref_signature [Hoare_mem.Create]
userdef_ref_signature [Store_mem.Create]
userdef_ref_signature [Runtime_mem.Create]
userdef_ref_signature [Funvar_mem.Create]

V
val_of [LogicRaw.PRED]
val_of [Fol]
valid [Mlogic.S]
valid [Hoare_mem.Create]
valid [Store_mem.Create]
valid [Runtime_mem.Create.RtLib]
valid [Runtime_mem.Create]
valid [Funvar_mem.Create]
valid [Prover.AltErgo]
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]
vampire [Prover.SMT]
var [Formula.S]
var [Fol_formula]
var_counter [Fol.Var]
var_name [Fol.Var]
var_type [Fol.Var]
var_type_of_lvar [Variables_analysis]
varinfo_of_xaddr [Runtime_mem.Create.Tint]
varname [Datatype.Set]
vertex_attributes [Cil2cfg.Printer]
vertex_name [Cil2cfg.Printer]
very_strange_loops [Cil2cfg]
detect is there are natural loops where we didn't manage to compute back edges (see mark_loops).
vkind_of_var [Formula.Logic]
vkind_of_var [Datalib.Create]

W
warning [Wp_parameters]
whydp [Prover.SMT]
wp_call [Calculus.Cfg]
wp_compute [Register]
wp_compute_call [Register]
wp_dir [Wp_gui]
wp_generation [Wp_parameters]
wp_highlight [Wp_gui]
wp_loop [Calculus.Cfg]
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_preconditions [WpAnnot]
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_select [Wp_gui]
wp_stmt [Calculus.Cfg]
wp_strategy [Wp_parameters]
wp_unreachable [WpAnnot]
wrap [Formula.S]
wrap [Fol_formula]

X
xaddr_of_integer [Runtime_mem.Create.Tint]
xaddr_of_var [Runtime_mem.Create.Tint]
xsize_of_range [Runtime_mem.Create.Tint]
xvar [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]
zip [CfgWeakestPrecondition.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.SplitZoneInclusion]