|
__ocaml_lex_comment_rec [Script] |
|
__ocaml_lex_proof_rec [Script] |
|
__ocaml_lex_tables [Script] |
|
__ocaml_lex_token_rec [Script] |
|
A |
a_false [Whylib.Create] |
|
a_sizeof [Region.Create] |
|
a_true [Whylib.Create] |
|
acc_field [Mdata.S] |
Takes a record term of type (tau_of F.fcomp) and
returns the term of type (tau_of F) for its field 'F'
|
acc_field [Datalib.Create] |
|
acc_index [Mdata.S] |
Takes term of type 'a farray and returns the 'a at index i .
|
acc_index [Datalib.Create] |
|
access [Funvar_mem.Create.Lookup] |
|
access [Datalib.Create] |
|
add [Wpo] |
|
add [State_builder.Dashtbl] |
|
add [Runtime_mem.Create.Aint] |
|
add [Store_mem.Create] |
|
add [Map.S] |
add x y m returns a map containing the same bindings as
m , plus a binding of x to y .
|
add [Cil2cfg.HEsig] |
|
add [State_builder.Hashtbl] |
Add a new binding.
|
add [Cil2cfg.HE] |
|
add [Hashtbl.S] |
|
add [Set.S] |
add x s returns a set containing all elements of s ,
plus x .
|
add_array_length_hyp [Hoare_mem.Create] |
|
add_as_goal [Mcfg.S] |
|
add_as_goal [Cfgpropid.Create] |
|
add_as_goal [CfgWeakestPrecondition.Create] |
|
add_as_hyp [Mcfg.S] |
add_as_goal env g p add g as goal to p (g /\ p)
|
add_as_hyp [Cfgpropid.Create] |
|
add_as_hyp [CfgWeakestPrecondition.Create] |
|
add_assigns [Mcfg.S] |
|
add_assigns [WpAnnot] |
|
add_assigns [Cfgpropid.Create] |
|
add_assigns [CfgWeakestPrecondition.Create] |
|
add_assigns_goal [Calculus.Cfg] |
|
add_axiom [Mcfg.S] |
|
add_axiom [Data_mem.Create.Compound] |
|
add_axiom [Cfgpropid.Create] |
|
add_axiom [Translate_prop.Create] |
Compile an axiom and add it to the list of global declarations.
|
add_axiom [CfgWeakestPrecondition.Create] |
|
add_axiom [Calculus.Cfg] |
|
add_behaviors_props [WpAnnot] |
|
add_bhv_assigns [WpAnnot] |
|
add_cfg_menu [Wp_gui] |
|
add_complet_behaviors_props [WpAnnot] |
|
add_declaration [Mdata.S] |
|
add_declaration [Datalib.Create] |
|
add_depend [Datalib.Collector] |
|
add_disjoint_behaviors_props [WpAnnot] |
|
add_edge [Cil2cfg] |
|
add_edges_before [Cil2cfg] |
|
add_effect_assigns [CfgWeakestPrecondition.Create] |
|
add_fct_pre [WpAnnot] |
|
add_glob_axiom [WpAnnot] |
|
add_goal [Mcfg.S] |
add_as_hyp env h p add h as hypothesis in p (h => p)
|
add_goal [Cfgpropid.Create] |
|
add_goal [CfgWeakestPrecondition.Create] |
|
add_goal [CfgProof.Create] |
|
add_goal [Calculus.Cfg] |
|
add_hyp [Mcfg.S] |
|
add_hyp [Cfgpropid.Create] |
|
add_hyp [CfgWeakestPrecondition.Create] |
|
add_hyp [Calculus.Cfg] |
|
add_int [Whylib] |
|
add_int_format_hyp [Runtime_mem.Create] |
|
add_integer [Translate_prop.Create] |
|
add_inv_goal [Calculus.Cfg] |
|
add_inv_hyp [Calculus.Cfg] |
Similar to add_hyp and add_goal except that h and g already
come from computations, so they are already represented in the memory model
(no translation needed)
|
add_irreducible [Cil2cfg.WeiMaoZouChenInput] |
store the node as an irreducible loop header.
|
add_irreducible [Cil2cfg.LoopInfo] |
|
add_loop_assigns [WpAnnot] |
|
add_loop_header [Cil2cfg.WeiMaoZouChenInput] |
store the node as a loop header.
|
add_loop_header [Cil2cfg.LoopInfo] |
|
add_lvar [Translate_prop.Create] |
|
add_node [Cil2cfg] |
|
add_normal_assigns [CfgWeakestPrecondition.Create] |
|
add_oblig [Calculus.Cfg.R] |
|
add_offset [Store_mem.Create] |
|
add_on_edges [WpAnnot] |
|
add_proof [WpAnnot] |
accumulate int the proof the partial proof for this prop_id
|
add_prop [WpAnnot] |
|
add_real [Whylib] |
|
add_reentry_edge [Cil2cfg.WeiMaoZouChenInput] |
store the edge between the two nodes (n1, n2) as a reentry edge.
|
add_reentry_edge [Cil2cfg.LoopInfo] |
|
add_region_assigns [CfgWeakestPrecondition.Create] |
|
add_script [Proof] |
|
add_set [Mdata.S] |
|
add_set [Datalib.Create] |
|
add_spec_assigns_as_hyp [WpAnnot] |
|
add_state [Dashtbl.Graph] |
|
add_stmt_spec_after [WpAnnot] |
|
add_stmt_spec_before [WpAnnot] |
|
add_stmt_spec_postcond [WpAnnot] |
|
add_stmt_spec_precond_as_hyp [WpAnnot] |
|
add_unique [Caveat_mem.Make.WP] |
TODOopt should we have oredered lists ?
|
add_var_decl_hyp [Hoare_mem.Create] |
Add some hypotheses about the variable because we are going out of its
scope.
|
add_warning [Datalib.Collector] |
When adding a warning, one has to provide : the source of the warning (for instance "model M"),, the effect of the warning (for instance "stop computation"), and a formated message about why this warning is emited.
|
add_wp_menu [Wp_gui] |
|
addr [Store_mem.Create.Model] |
|
addr [Translate_expr.Create] |
addr mem lv interprets the left value lv as
an address (memory location) in the memory mem .*
|
addr [CfgWeakestPrecondition.Create] |
|
addr [Hoare_lib.Create.Hlib] |
|
addr [Caveat_fol] |
|
addr_format [Store_mem.Create] |
|
addr_of_assignable [Store_mem.Create] |
|
addr_of_data [Caveat_fol] |
Pre the data should represent an object (as oposed to an address).
|
all_provers [Wpo] |
|
all_separated [Region.Create] |
|
alloc [Runtime_mem.Create.RtLib] |
|
alloc_vars [Store_mem.Create] |
|
alpha [Mdata.S] |
|
alpha [Datalib.Create] |
|
alpha_bound_var [Fol] |
|
alpha_unbound [Fol] |
|
altergo [Prover.SMT] |
|
apply [Mdata.S] |
|
apply [Hook.S] |
Apply all the functions of the hook on the given parameter.
|
apply [Fol_gformula.Predicate] |
|
apply [Datalib.Create] |
|
apply [Axiomatics] |
|
apply_alpha [Fol] |
|
apply_bindings [Datalib.Create] |
|
apply_closure [Translate_prop.Create] |
|
apply_function [Translate_prop.Create] |
|
apply_hints [Translate_prop.Create] |
|
apply_predicate [Translate_prop.Create] |
|
apply_sigma [Translate_prop.Create] |
|
array [Fol_ergo] |
|
array_flag [Fol_ergo] |
|
array_format [Mdata.S] |
|
array_format [Data_mem.Create] |
|
array_format [Datalib.Create] |
|
array_length [Hoare_lib.Create.Hlib] |
|
array_of_data [Translate_prop.Create] |
|
array_of_path [Funvar_mem.Create] |
|
as_hint [Translate_prop.Create] |
|
assign [Mcfg.S] |
|
assign [Cfgpropid.Create] |
|
assign [CfgWeakestPrecondition.Create] |
|
assignable [Store_mem.Create] |
|
assignable_loc [Store_mem.Create] |
|
assignable_range [Store_mem.Create] |
|
assignable_sizeof [Store_mem.Create] |
|
assigned [Translate_prop.Create] |
Compiles an arbitrary term representing a set of left-values into a zone
|
assigned_for_assigns_goal [CfgWeakestPrecondition.Create] |
|
assigned_of_assigns [CfgWeakestPrecondition.Create] |
|
assigned_of_data [Translate_prop.Create] |
|
assigns_clause [Translate_prop.Create] |
|
assigns_goal [Mwp.S] |
|
assigns_goal [Runtime_mem.Create] |
|
assigns_goal [Store_mem.Create] |
|
assigns_goal [Hoare_mem.Create] |
|
assigns_goal [Funvar_mem.Create] |
|
assigns_goal [Caveat_mem.Make.WP] |
|
assigns_method [Mcfg.S] |
|
assigns_method [Cfgpropid.Create] |
|
assigns_method [CfgWeakestPrecondition.Create] |
|
assigns_method [CfgProof.Create] |
|
assigns_supported [Mwp.S] |
|
assigns_supported [Runtime_mem.Create] |
|
assigns_supported [Store_mem.Create] |
|
assigns_supported [Hoare_mem.Create] |
|
assigns_supported [Funvar_mem.Create] |
|
assigns_supported [Caveat_mem.Make.WP] |
|
axiom_env [Translate_prop.Create] |
|
B |
bad_eq_terms [Fol] |
compare terms without knowing how to compare data : better than something
for smart constructors (see eq_terms )
|
bad_pred_closed [Fol] |
|
bad_pred_has_var [Fol] |
|
bad_term_closed [Fol] |
|
bad_term_has_var [Fol] |
|
bar [Wpo] |
|
base [Runtime_mem.Create.Tint] |
|
base [Store_mem.Create.Model] |
|
base [Region.Create] |
An arbitrary base-address of any allocated C memory-block.
|
base [Hoare_lib.Create.Hlib] |
|
base [Caveat_fol] |
|
base_address [Mlogic.S] |
base_address m l return the base address of l .
|
base_address [Runtime_mem.Create] |
|
base_address [Store_mem.Create] |
|
base_address [Hoare_mem.Create] |
|
base_address [Funvar_mem.Create] |
|
base_address [Caveat_mem.Make.WP] |
|
basename [Mdata.S.Identifiable] |
|
basename [Fol.Var] |
|
basename [Ctypes] |
|
basename [Datalib.Create.Identifiable] |
|
basename [Datalib.Create.LTinfoId] |
|
basename [Datalib.Create.Logicvar] |
|
basename [Datalib.Create.LTypeinfo] |
|
basename [Datalib.Create.Arrayinfo] |
|
basename [Datalib.Create.Compinfo] |
|
basename [Datalib.Create.Fieldinfo] |
|
basename [Datalib.Create.Varinfo] |
|
basename_of_var [Fol_gformula.Pool] |
|
basename_of_var [Caveat_fol] |
|
basetype [Ctypes] |
|
behavior_name_of_config [WpAnnot] |
|
binop [Whylib.Create] |
|
bits_and [Mint.S] |
|
bits_and [Mint_natural.Create] |
|
bits_lshift [Mint.S] |
|
bits_lshift [Mint_natural.Create] |
|
bits_not [Mint.S] |
|
bits_not [Mint_natural.Create] |
|
bits_of_value [Runtime_mem.Create.Data] |
|
bits_of_value [Runtime_mem.Create] |
|
bits_or [Mint.S] |
|
bits_or [Mint_natural.Create] |
|
bits_rshift [Mint.S] |
|
bits_rshift [Mint_natural.Create] |
|
bits_xor [Mint.S] |
|
bits_xor [Mint_natural.Create] |
|
bkind_sid [Cil2cfg] |
|
bkind_stmt [Cil2cfg] |
|
blit [String] |
String.blit src srcoff dst dstoff len copies len characters
from string src , starting at character number srcoff , to
string dst , starting at character number dstoff .
|
block [Region.Create] |
The full block at given block
|
block_length [Mlogic.S] |
block_length m l t return the block_length
of the location l .
|
block_length [Runtime_mem.Create.RtLib] |
|
block_length [Runtime_mem.Create] |
|
block_length [Store_mem.Create] |
|
block_length [Hoare_mem.Create] |
|
block_length [Funvar_mem.Create] |
|
block_length [Hoare_lib.Create.Hlib] |
|
block_length [Caveat_mem.Make.WP] |
|
blocks_closed_by_edge [Cil2cfg] |
|
body_of_id_assigns [WpAnnot] |
|
body_of_id_pred [WpAnnot] |
|
bool_and [Whylib] |
|
bool_not [Whylib] |
|
bool_or [Whylib] |
|
boolean_of_data [Translate_prop.Create] |
|
boolean_of_float [Translate_expr.Create] |
|
boolean_of_int [Translate_expr.Create] |
|
boolean_of_integer [Translate_expr.Create] |
|
boolean_of_ptr [Translate_expr.Create] |
|
boolean_of_value [Translate_expr.Create] |
|
build_bhv_assumes [WpFroms] |
|
build_bhv_assumes [WpAnnot] |
|
build_bhv_strategy [WpAnnot] |
|
build_cfg [Register] |
|
build_fimpl_call [WpFroms] |
Build out = f_n (inputs)
|
build_prop_of_from [Mcfg.S] |
build p => alpha(p) for functional dependencies verification.
|
build_prop_of_from [Cfgpropid.Create] |
|
build_prop_of_from [CfgWeakestPrecondition.Create] |
|
build_strategy_for_froms [WpAnnot] |
|
build_wpos [CfgProof.Create] |
|
C |
c_bool [Fol] |
|
c_bool [Ctypes] |
Returns the type of int
|
c_char [Ctypes] |
Returns the type of char
|
c_enum [Ctypes] |
Returns the type of enums
|
c_float [Fol] |
|
c_float [Ctypes] |
Conforms to
|
c_float_of_str [Fol] |
|
c_int [Fol] |
|
c_int [Ctypes] |
Conforms to
|
c_int_bounds [Ctypes] |
|
c_int_of_str [Fol] |
|
c_int_of_typ [Translate_expr.Create] |
|
c_label [Clabels] |
Assumes the logic label only comes from normalized labels.
|
c_object_of_data [Caveat_mem.Make.Export] |
|
c_ptr [Ctypes] |
Returns the type of pointers
|
call [CfgWeakestPrecondition.Create] |
|
call_exit [Mcfg.S] |
|
call_exit [Cfgpropid.Create] |
|
call_exit [Translate_prop.Create] |
|
call_exit [CfgWeakestPrecondition.Create] |
|
call_normal [Mcfg.S] |
|
call_normal [Cfgpropid.Create] |
|
call_normal [CfgWeakestPrecondition.Create] |
|
call_post [Translate_prop.Create] |
|
call_post_for_froms [WpAnnot] |
|
call_pre [Translate_prop.Create] |
|
capitalize [String] |
Return a copy of the argument, with the first character set to uppercase.
|
capture [Mdata.S] |
|
capture [Datalib.Create] |
|
cardinal [Store_mem.Create] |
|
cardinal [Set.S] |
Return the number of elements of a set.
|
case_of [Fol] |
|
case_of_exp [CfgWeakestPrecondition.Create] |
|
cast [Translate_prop.Create] |
|
cast [CfgWeakestPrecondition.Create] |
|
cast_int_to_loc [Mvalues.Model] |
|
cast_int_to_loc [Runtime_mem.Create.Model] |
|
cast_int_to_loc [Store_mem.Create.Model] |
|
cast_int_to_loc [Hoare_mem.Create.Model] |
|
cast_int_to_loc [Funvar_mem.Create.Model] |
|
cast_int_to_loc [Datalib.Cvalues] |
|
cast_int_to_loc [Caveat_mem.Make.WP.Model] |
|
cast_loc_to_int [Mvalues.Model] |
|
cast_loc_to_int [Runtime_mem.Create.Model] |
|
cast_loc_to_int [Store_mem.Create.Model] |
|
cast_loc_to_int [Hoare_mem.Create.Model] |
|
cast_loc_to_int [Funvar_mem.Create.Model] |
|
cast_loc_to_int [Datalib.Cvalues] |
|
cast_loc_to_int [Caveat_mem.Make.WP.Model] |
|
cast_loc_to_loc [Mvalues.S] |
cast_loc_to_loc t1 t2 l returns the casted location of type t2
from the location l of type t1
|
cast_loc_to_loc [Runtime_mem.Create] |
|
cast_loc_to_loc [Store_mem.Create] |
|
cast_loc_to_loc [Hoare_mem.Create] |
|
cast_loc_to_loc [Funvar_mem.Create] |
|
cast_loc_to_loc [Caveat_mem.Make.WP] |
|
cat [Prover] |
|
catch_label_error [NormAtLabels] |
|
cc_pred [Fol_eqs] |
|
ccp [Fol_eqs] |
|
ccpred [Fol_eqs] |
|
cct [Fol_eqs] |
|
cfg_block [Cil2cfg] |
|
cfg_dot [Cil2cfg] |
|
cfg_graph [Cil2cfg] |
|
cfg_kf [Cil2cfg] |
|
cfg_start [Cil2cfg] |
|
cfg_stmt [Cil2cfg] |
|
cfg_stmts [Cil2cfg] |
build the nodes for the stmts , connect the last one with next ,
and return the node of the first stmt.
|
cfg_switch [Cil2cfg] |
|
change_data_in_exp [Fol] |
Similar to change_in_exp but only transforms data into data.
|
change_data_in_pred [Fol] |
change_data_in_pred do_data_rec p where do_data_rec do_exp d
|
change_exp_in_pred [Fol] |
apply do_exp on each sub expression of the predicate.
|
change_in_exp [Fol] |
Apply do_var and do_data in term subexpressions.
|
change_mode [Calculus.Cfg.R] |
|
check [Prover.Coqide] |
|
check [Prover.Coq] |
|
check [Prover.AltErgo] |
|
check [Prover.SMT] |
|
check [Prover] |
|
check_assigns [CfgWeakestPrecondition.Create] |
|
check_by [Prover] |
|
check_indir_label [Caveat_mem.Make.WP] |
We want to read d at label , but in Caveat model, everything comes
from variables, so we cannot read at a label if the address is evaluated
at another one...
|
check_names [Wp_parameters] |
|
check_pred [Fol] |
|
check_term [Fol] |
|
choose [Proof] |
|
choose [Set.S] |
Return one element of the given set, or raise Not_found if
the set is empty.
|
cil_field_info [Runtime_mem.Create] |
|
cil_field_offset [Runtime_mem.Create] |
|
cil_field_size [Runtime_mem.Create] |
|
clean_graph [Cil2cfg] |
|
clear [Mdata.S.Declarator] |
|
clear [Mdata.S] |
|
clear [Wpo.Results] |
|
clear [Wpo] |
|
clear [State_builder.Dashtbl] |
|
clear [Proof] |
|
clear [Hook.S] |
Clear the hook.
|
clear [Cil2cfg.HEsig] |
|
clear [State_builder.Hashtbl] |
Clear the table.
|
clear [Cil2cfg.HE] |
|
clear [State_builder.Ref] |
Reset the reference to its default value.
|
clear [Datalib.Create.Declarator] |
|
clear [Hashtbl.S] |
|
clear [Datalib.Create] |
|
close [Mdata.S] |
|
close [Mcfg.S] |
|
close [Script] |
|
close [Prover.Log] |
|
close [Cfgpropid.Create] |
|
close [CfgWeakestPrecondition.Create] |
|
close [Datalib.Create] |
|
close_env [Funvar_mem.Create] |
|
close_property [CfgWeakestPrecondition.Create] |
|
closed [Mdata.S] |
|
closed [Mdata.Addr] |
|
closed [Datalib.Create] |
|
cmdline_run [Register] |
|
cnst_mult [Runtime_mem.Create.Aint] |
|
cnst_mult_size [Runtime_mem.Create.Tint] |
|
code_annot_names [WpAnnot] |
|
collect_and [Fol_pretty] |
|
collect_and [Fol_ergo] |
|
collect_and [Fol_coq] |
|
collect_assoc [Fol_pretty] |
|
collect_assoc [Fol_ergo] |
|
collect_assoc [Fol_coq] |
|
collect_iff [Fol_pretty] |
|
collect_iff [Fol_ergo] |
|
collect_iff [Fol_coq] |
|
collect_imply [Fol_pretty] |
|
collect_imply [Fol_ergo] |
|
collect_imply [Fol_coq] |
|
collect_or [Fol_pretty] |
|
collect_or [Fol_ergo] |
|
collect_or [Fol_coq] |
|
collect_scripts [Proof] |
|
collect_signature [Hoare_mem.Create] |
|
collect_signature [Funvar_mem.Create] |
|
column_tbl [Po_navigator.Prover_Column] |
|
command [Prover.Log] |
|
comment [Script] |
|
compare [Map.S] |
Total ordering between maps.
|
compare [Fol.Var] |
|
compare [Ctypes.AinfoComparable] |
|
compare [String] |
|
compare [Ctypes] |
|
compare [Cil2cfg.EL] |
|
compare [Cil2cfg.VL] |
|
compare [Datalib.Create.LTinfo] |
|
compare [Set.S] |
Total ordering between sets.
|
compare_c_float [Ctypes] |
|
compare_c_int [Ctypes] |
|
compare_edge_type [Cil2cfg.EL] |
|
compare_prop_id [WpAnnot] |
|
compile_function [Translate_prop.Create] |
|
compile_predicate [Translate_prop.Create] |
|
compile_user_axiom [Translate_prop.Create] |
|
compile_user_hypothesis [Translate_prop.Create] |
|
compiled [Prover.Coq] |
|
compute [Vaddr] |
|
compute [Calculus.Cfg] |
|
compute [Axiomatics] |
|
compute_bindings [Datalib.Create] |
|
compute_int_mode [Runtime_mem.Create] |
|
compute_rte_for [WpAnnot] |
|
compute_wp_edge [Calculus.Cfg] |
|
computer [Register] |
|
concat [String] |
String.concat sep sl concatenates the list of strings sl ,
inserting the separator string sep between each.
|
cond [Translate_expr.Create] |
cond mem e interprets e as a boolean
in memory mem .
|
cond [CfgWeakestPrecondition.Create] |
|
cond_binop [Translate_expr.Create] |
|
cond_rec [Translate_expr.Create] |
|
cond_unop [Translate_expr.Create] |
|
consolidate_loop [WpAnnot] |
|
constant [Fol_pretty] |
|
constant [Fol_ergo] |
|
constant [Fol_coq] |
|
constant [Ctypes] |
|
contains [String] |
String.contains s c tests if character c
appears in the string s .
|
contains_from [String] |
String.contains_from s start c tests if character c
appears in s after position start .
|
context [CfgProof.Description] |
Basename for environment files ; unique per updater
|
context [Datalib.Create] |
|
copy [Datatype.S] |
Deep copy: no possible sharing between x and copy x .
|
copy [Datatype.Set] |
|
copy [String] |
Return a copy of the given string.
|
copy [Hashtbl.S] |
|
coq_for_env [Wpo] |
|
coq_for_model [Wpo] |
|
coq_normalize [Fol_norm] |
|
coqc [Prover.Coq] |
|
coqidelock [Prover.Coqide] |
|
create [Wpo.Results] |
|
create [Prover.Log] |
|
create [Funvar_mem.Create] |
|
create [String] |
String.create n returns a fresh string of length n .
|
create [Cil2cfg.HEsig] |
|
create [Cil2cfg.HE] |
|
create [Cil2cfg] |
|
create [CfgProof.Create] |
|
create [Hashtbl.S] |
|
create_and_add_state [Dashtbl.Graph] |
|
create_data_name [Caveat_mem.Make.WP] |
Create names for address variables, field, structure types...
|
create_proof [WpAnnot] |
to be used only once for one of the related prop_id
|
ctype_of_data [Caveat_mem.Make.WP] |
Try to find the data type needed to generated 'format' for indir
and mu_indir
|
ctype_of_fvar [Caveat_fol] |
|
cur_fct_default_bhv [WpAnnot] |
|
current [Wp_error] |
|
current [Prover.Log] |
|
cut [Fol] |
|
cvar [Mvalues.S] |
|
cvar [Runtime_mem.Create.Data] |
|
cvar [Store_mem.Create.Data] |
|
cvar [Hoare_mem.Create] |
|
cvar [Region.Create] |
Base of a C-variable.
|
cvar [Funvar_mem.Create] |
|
cvar [Caveat_mem.Make.WP] |
|
cvar_of_var [Store_mem.Create.Data] |
|
cvc3 [Prover.SMT] |
|
D |
data_alpha_cv [Caveat_fol] |
|
data_binop [Translate_prop.Create] |
|
data_cmp [Translate_prop.Create] |
|
data_const [Translate_prop.Create] |
|
data_field [Translate_prop.Create] |
|
data_has_var [Caveat_fol] |
|
data_index [Translate_prop.Create] |
|
data_index_range [Translate_prop.Create] |
|
data_load [Translate_prop.Create] |
|
data_of_assignable [Translate_prop.Create] |
|
data_of_boolean [Translate_prop.Create] |
|
data_of_cvar_at [Caveat_fol] |
|
data_of_cvar_at_l [Caveat_fol] |
|
data_of_integer [Translate_prop.Create] |
|
data_of_lvar [Caveat_fol] |
|
data_of_real [Translate_prop.Create] |
|
data_of_term [Translate_prop.Create] |
|
data_of_term [Caveat_fol] |
|
data_rec [Translate_prop.Create] |
|
data_separated [Translate_prop.Create] |
|
data_shift [Translate_prop.Create] |
|
data_shift_range [Translate_prop.Create] |
|
data_startof [Translate_prop.Create] |
|
data_startof_set [Translate_prop.Create] |
|
data_unop [Translate_prop.Create] |
|
data_valid [Translate_prop.Create] |
|
debug1 [Caveat_mem] |
Trace call from outside
|
debug2 [Caveat_mem] |
|
debug3 [Caveat_mem] |
All the details
|
declare [Mdata.S.Declarator] |
|
declare [Datalib.Create.Declarator] |
|
decode [Mdata.S] |
|
decode [Datalib.Create] |
|
default [Prover.Coq] |
|
default [Cil2cfg.EL] |
|
default_edge_attributes [Cil2cfg.Printer] |
|
default_vertex_attributes [Cil2cfg.Printer] |
|
define [Mdata.S.Registry] |
|
define [Data_mem.Create.Compound] |
|
define [Translate_prop.Create.UserAxiomDefs] |
|
define [Translate_prop.Create.UserDefinition] |
|
define [Datalib.Create.Registry] |
|
define [Datalib.Create.Register] |
|
define_access [Data_mem.Create.LoadedCompound] |
|
define_array [Data_mem.Create.UpdatedCompound] |
|
define_array [Data_mem.Create.StoredCompound] |
|
define_array [Data_mem.Create.LoadedCompound] |
|
define_comp [Data_mem.Create.UpdatedCompound] |
|
define_comp [Data_mem.Create.StoredCompound] |
|
define_comp [Data_mem.Create.LoadedCompound] |
|
define_update [Data_mem.Create.StoredCompound] |
|
define_vinfo [Store_mem.Create.Data] |
|
dependencies [Wprop.Info] |
|
dependencies [Wprop.Actor] |
|
dependencies [WpAnnot] |
|
descr [Datatype.Set] |
|
diff [Set.S] |
Set difference.
|
dimension [Ctypes] |
|
direct_lval [Caveat_mem.Make.WP] |
|
disj [Caveat_mem.Make.WP] |
|
dispatch [Register] |
|
dispatch [Fol_split] |
Splits conjunctions and unfold the definition
of included over zones .
|
div_int [Whylib] |
|
dnode_cpt [Cfgpropid.Create] |
|
do_compute [Register] |
|
do_data_rec [Caveat_fol] |
propagate transformations do_data and do_exp in d .
|
do_exists [Datalib.Create] |
|
do_exp_in_data [Caveat_fol] |
propagate expression transformation do_exp in the data d
|
do_forall [Datalib.Create] |
|
do_instantiate [Translate_prop.Create] |
|
do_labels [Calculus.Cfg] |
Before storing something at a program point, we have to process the label
at that point.
|
do_loadscripts [Proof] |
|
do_main_init_if_needed [Calculus.Cfg] |
If kf is the 'main' function, process global initialisations
as if they were a kind of prelude of the 'main'.
|
do_path [Caveat_fol] |
|
do_subst [Datalib.Create] |
|
do_wp_check [Register] |
|
do_wp_checks [Register] |
|
do_wp_checks_for [Register] |
|
do_wp_passes [Register] |
|
do_wp_print [Register] |
|
do_wp_print_for [Register] |
|
do_wp_proof [Register] |
|
do_wp_proofs [Register] |
|
do_wp_proofs_for [Register] |
|
do_wpo_feedback [Register] |
|
domain [Datalib.Create] |
|
dot_annots [Cil2cfg] |
dot_annots cfg bhv_name pp_annots
|
dot_cfg [Cil2cfg] |
Output the graph in a dot file and return its name *
|
dot_lannots [Register] |
|
dot_wp_res [Cil2cfg] |
dot_wp_res cfg model pp_wp_res
|
dummy [Mdata.S] |
|
dummy [Datalib.Create] |
|
dump_scripts [Proof] |
dump_scripts f saves all scripts from the database into file f .
|
dzone_assigned [Mwp.S] |
|
dzone_assigned [Runtime_mem.Create] |
|
dzone_assigned [Store_mem.Create] |
|
dzone_assigned [Hoare_mem.Create] |
|
dzone_assigned [Funvar_mem.Create] |
|
dzone_assigned [Caveat_mem.Make.WP] |
|
dzone_empty [Mwp.S] |
|
dzone_empty [Runtime_mem.Create] |
|
dzone_empty [Store_mem.Create] |
|
dzone_empty [Hoare_mem.Create] |
|
dzone_empty [Funvar_mem.Create] |
|
dzone_empty [Caveat_mem.Make.WP] |
|
dzone_of_var [Caveat_mem.Make.WP] |
|
dzone_subset [Mwp.S] |
|
dzone_subset [Runtime_mem.Create] |
|
dzone_subset [Store_mem.Create] |
|
dzone_subset [Hoare_mem.Create] |
|
dzone_subset [Funvar_mem.Create] |
|
dzone_subset [Caveat_mem.Make.WP] |
|
dzone_union [Mwp.S] |
|
dzone_union [Runtime_mem.Create] |
|
dzone_union [Store_mem.Create] |
|
dzone_union [Hoare_mem.Create] |
|
dzone_union [Funvar_mem.Create] |
|
dzone_union [Caveat_mem.Make.WP] |
|
E |
e_and [Formula.S] |
|
e_and [Whylib.Create] |
|
e_app [Fol] |
|
e_app0 [Mdata.S] |
|
e_app0 [Datalib.Create] |
|
e_app1 [Mdata.S] |
|
e_app1 [Datalib.Create] |
|
e_app2 [Mdata.S] |
|
e_app2 [Datalib.Create] |
|
e_app3 [Mdata.S] |
|
e_app3 [Datalib.Create] |
|
e_app4 [Mdata.S] |
|
e_app4 [Datalib.Create] |
|
e_app5 [Mdata.S] |
|
e_app5 [Datalib.Create] |
|
e_band [Formula.S] |
|
e_band [Whylib.Create] |
|
e_bnot [Formula.S] |
|
e_bnot [Whylib.Create] |
|
e_bool [Formula.S] |
|
e_bool [Whylib.Create] |
|
e_bor [Formula.S] |
|
e_bor [Whylib.Create] |
|
e_bxor [Formula.S] |
|
e_bxor [Whylib.Create] |
|
e_call [Formula.Vernacular] |
|
e_call [Fol_gformula.Langage] |
|
e_closed [Fol] |
|
e_cnst [Fol] |
|
e_cond [Formula.S] |
|
e_cond [Whylib.Create] |
|
e_data [Fol] |
|
e_false [Formula.S] |
|
e_false [Fol_gformula.Langage] |
|
e_false [Fol] |
|
e_field [Region.Create] |
|
e_float [Formula.S] |
|
e_float [Fol_gformula.Langage] |
|
e_float [Fol] |
|
e_has_var [Fol] |
|
e_icmp [Formula.S] |
|
e_icmp [Whylib.Create] |
|
e_icst [Formula.S] |
|
e_icst [Fol_gformula.Langage] |
|
e_if [Fol] |
|
e_ineg [Formula.S] |
|
e_ineg [Whylib.Create] |
|
e_int [Formula.S] |
|
e_int [Formula.Vernacular] |
|
e_int [Fol_gformula.Langage] |
|
e_int [Fol] |
|
e_int64 [Formula.S] |
|
e_int64 [Fol_gformula.Langage] |
|
e_int64 [Fol] |
|
e_iop [Formula.S] |
|
e_iop [Whylib.Create] |
|
e_let [Fol] |
|
e_lshift [Formula.S] |
|
e_lshift [Whylib.Create] |
|
e_not [Formula.S] |
|
e_not [Whylib.Create] |
|
e_or [Formula.S] |
|
e_or [Whylib.Create] |
|
e_rcmp [Formula.S] |
|
e_rcmp [Whylib.Create] |
|
e_rcst [Formula.S] |
|
e_rcst [Fol_gformula.Langage] |
|
e_rename [Formula.S] |
Requires domain to be disjoint from co-domain
|
e_rename [Fol_gformula.Predicate] |
|
e_rename [Caveat_fol] |
|
e_rneg [Formula.S] |
|
e_rneg [Whylib.Create] |
|
e_rop [Formula.S] |
|
e_rop [Whylib.Create] |
|
e_rshift [Formula.S] |
|
e_rshift [Whylib.Create] |
|
e_sizeof [Region.Create] |
|
e_subst [Formula.S] |
|
e_subst [Fol_gformula.Predicate] |
|
e_true [Formula.S] |
|
e_true [Fol_gformula.Langage] |
|
e_true [Fol] |
|
e_unfold [Fol_split] |
|
e_var [Fol] |
|
eat [Script] |
|
edge_attributes [Cil2cfg.Printer] |
|
edge_dst [Cil2cfg] |
|
edge_key [Cil2cfg.HE] |
|
edge_src [Cil2cfg] |
node and edges relations
|
edge_type [Cil2cfg] |
|
effect_supported [Mwp.S] |
|
effect_supported [Runtime_mem.Create] |
|
effect_supported [Store_mem.Create] |
|
effect_supported [Hoare_mem.Create] |
|
effect_supported [Funvar_mem.Create] |
|
effect_supported [Caveat_mem.Make.WP] |
|
elements [Set.S] |
Return the list of all elements of the given set.
|
empty [Mdata.S] |
empty() returns the polymorphic empty set.
|
empty [Mcfg.S] |
|
empty [Region.Create] |
The empty region
|
empty [Map.S] |
The empty map.
|
empty [Cfgpropid.Create] |
|
empty [CfgWeakestPrecondition.Create] |
|
empty [Set.S] |
The empty set.
|
empty [Datalib.Create] |
|
empty [Calculus.Cfg.R] |
|
empty_acc [WpAnnot] |
|
empty_alpha [Formula.S] |
|
empty_alpha [Fol_formula] |
|
empty_alpha [Caveat_fol] |
|
encode [Mdata.S] |
|
encode [Datalib.Create] |
|
env_at [Funvar_mem.Create] |
|
env_at [Translate_prop.Create] |
|
env_body [Translate_prop.Create] |
|
env_name [Wpo] |
|
epp_pred_atom [Fol_pretty] |
|
epp_pred_atom [Fol_ergo] |
|
epp_pred_atom [Fol_coq] |
|
epp_pred_named [Fol_pretty] |
|
epp_pred_vbox [Fol_pretty] |
|
epp_pred_vbox [Fol_ergo] |
|
epp_pred_vbox [Fol_coq] |
|
eq_array [Mdata.S] |
|
eq_array [Datalib.Create] |
|
eq_array_definition [Datalib.Create] |
|
eq_data [Caveat_fol] |
|
eq_epath [Caveat_fol] |
|
eq_int [Whylib] |
|
eq_int_bool [Whylib] |
|
eq_nodes [Cil2cfg.WeiMaoZouChenInput] |
|
eq_nodes [Cil2cfg.LoopInfo] |
|
eq_pred [Runtime_mem.Create.Aint] |
|
eq_real [Whylib] |
|
eq_real_bool [Whylib] |
|
eq_record [Mdata.S] |
|
eq_record [Datalib.Create] |
|
eq_record_definition [Datalib.Create] |
|
eq_term [Caveat_fol] |
|
eq_term_opt [Caveat_fol] |
|
eq_terms [Fol] |
|
eq_var [Formula.S] |
|
eq_var [Fol_gformula.Predicate] |
|
eq_var [Caveat_fol] |
|
eq_zone [Runtime_mem.Create.Tint] |
|
equal [Mdata.S] |
|
equal [Mdata.Addr] |
|
equal [Map.S] |
equal cmp m1 m2 tests whether the maps m1 and m2 are
equal, that is, contain equal keys and associate them with
equal data.
|
equal [Fol.Var] |
|
equal [Ctypes.AinfoComparable] |
|
equal [Ctypes] |
|
equal [Cil2cfg.VL] |
|
equal [Datalib.Create.LTinfo] |
|
equal [Set.S] |
equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [Datalib.Create] |
|
equal_pointer_bool [Mdata.S] |
equal_pointer_bool p q is the boolean that is true when
pointers p and q , that points to elements of type ty ,
are equal.
|
equal_pointer_bool [Datalib.Create] |
|
equal_rec [Datalib.Create] |
|
equal_terms [Formula.S] |
Returns true when the two terms are syntactically equals
|
equal_terms [Fol_gformula.Predicate] |
|
eraise [Script] |
|
ergo_normalize [Fol_norm] |
|
error [Script] |
|
escaped [String] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of Objective Caml.
|
exists [Mdata.S] |
|
exists [Region.Create.Merge] |
|
exists [Region.Create] |
|
exists [Set.S] |
exists p s checks if at least one element of
the set satisfies the predicate p .
|
exists [Datalib.Create] |
|
exit_status [Mlogic.S] |
exit_status e returns the variable associates to
the function exit status in the environment e .
|
exit_status [Runtime_mem.Create] |
|
exit_status [Store_mem.Create] |
|
exit_status [Hoare_mem.Create] |
|
exit_status [Funvar_mem.Create] |
|
exit_status [Caveat_mem.Make.WP] |
|
export [Prover] |
|
export [Cil2cfg] |
|
export_data [Fol_why] |
|
export_data [Fol_ergo] |
|
export_data [Fol_coq] |
|
export_decl [Mwp.Export] |
|
export_decl [Mcfg.Export] |
|
export_decl [Fol_why] |
|
export_decl [Fol_ergo.E92] |
|
export_decl [Fol_ergo.E91] |
|
export_decl [Fol_ergo] |
|
export_decl [Fol_coq] |
|
export_decl [Caveat_mem.Make.Export.Create] |
|
export_goal [Mwp.Export] |
|
export_goal [Mcfg.Export] |
|
export_goal [Fol_why] |
|
export_goal [Fol_ergo.E92] |
|
export_goal [Fol_ergo.E91] |
|
export_goal [Fol_ergo] |
|
export_goal [Fol_coq] |
|
export_goal [Caveat_mem.Make.Export.Create] |
|
export_item [Fol_why] |
|
export_item [Fol_ergo] |
|
export_item [Fol_coq] |
|
export_pred [Fol_why] |
|
export_pred [Fol_ergo] |
|
export_pred [Fol_coq] |
|
export_tau [Fol_why] |
|
export_tau [Fol_ergo.E92] |
|
export_tau [Fol_ergo.E91] |
|
export_tau [Fol_ergo] |
|
export_tau [Fol_coq] |
|
export_term [Fol_why] |
|
export_term [Fol_ergo] |
|
export_term [Fol_coq] |
|
export_wpo [CfgProof.Create] |
|
expp [Fol_eval] |
|
expr [Translate_expr.Create] |
expr mem e interprets the expressione as a value
in memory mem *
|
expr [CfgWeakestPrecondition.Create] |
|
expr_binop [Translate_expr.Create] |
|
expr_cast [Translate_expr.Create] |
|
expr_cond_cmp [Translate_expr.Create] |
|
expr_cond_cmp_arith [Translate_expr.Create] |
|
expr_cond_cmp_ptr [Translate_expr.Create] |
|
expr_const [Translate_expr.Create] |
|
expr_float [Translate_expr.Create] |
|
expr_float_operator [Translate_expr.Create] |
|
expr_int [Translate_expr.Create] |
|
expr_int_operator [Translate_expr.Create] |
|
expr_rec [Translate_expr.Create] |
|
expr_rec_spec_null [Translate_expr.Create] |
|
expr_unop [Translate_expr.Create] |
|
expt [Fol_eval] |
|
extend [Hook.S] |
Add a new function to the hook.
|
extend [Po_navigator] |
|
extract_from_data [Translate_prop.Create] |
|
F |
f_cmp [Mfloat.S] |
|
f_cmp [Mfloat_natural.Create] |
|
f_convert [Mdata.S] |
|
f_convert [Ctypes] |
|
f_convert [Datalib.Create] |
|
f_guard [Mdata.S] |
|
f_guard [Datalib.Create] |
|
f_neg [Mfloat.S] |
|
f_neg [Mfloat_natural.Create] |
|
f_op [Mfloat.S] |
|
f_op [Mfloat_natural.Create] |
|
f_sizeof [Ctypes] |
|
farray_access [Datalib] |
|
farray_update [Datalib] |
|
fcmp_operator [Translate_expr.Create] |
|
fdecl_of_decl [Caveat_mem.Make.Export] |
|
fdx [Ctypes] |
|
field [Mvalues.S] |
|
field [Mvalues.Data] |
|
field [Runtime_mem.Create.Data] |
|
field [Store_mem.Create.Data] |
|
field [Hoare_mem.Create] |
|
field [Funvar_mem.Create] |
|
field [Caveat_mem.Make.WP] |
|
field_access [Hoare_mem.Create] |
|
field_offset [Ctypes] |
|
file [Prover.Tmp] |
|
file_for_body [Wpo] |
|
file_for_ctxt [Wpo] |
|
file_for_env [Wpo] |
|
file_for_goal [Wpo] |
|
file_for_head [Wpo] |
|
file_for_log [Wpo] |
|
file_for_model [Wpo] |
|
fill [Script] |
|
fill [String] |
String.fill s start len c modifies string s in place,
replacing len characters by c , starting at start .
|
filter [State_builder.Dashtbl] |
|
filter [Set.S] |
filter p s returns the set of all elements in s
that satisfy predicate p .
|
find [State_builder.Dashtbl] |
|
find [Map.S] |
find x m returns the current binding of x in m ,
or raises Not_found if no such binding exists.
|
find [Cil2cfg.HEsig] |
|
find [State_builder.Hashtbl] |
Return the current binding of the given key.
|
find [Cil2cfg.HE] |
|
find [Hashtbl.S] |
|
find [Calculus.Cfg.R] |
|
find_all [State_builder.Dashtbl] |
|
find_all [Cil2cfg.HEsig] |
|
find_all [State_builder.Hashtbl] |
Return the list of all data associated with the given key.
|
find_all [Cil2cfg.HE] |
|
find_all [Hashtbl.S] |
|
find_all_data [State_builder.Dashtbl] |
|
find_all_local [State_builder.Dashtbl] |
|
find_all_local_data [State_builder.Dashtbl] |
|
find_all_local_states [State_builder.Dashtbl] |
|
find_all_states [State_builder.Dashtbl] |
|
find_data [State_builder.Dashtbl] |
|
find_key [State_builder.Dashtbl] |
|
find_mem_at [Runtime_mem.Create] |
|
find_script_for_goal [Proof] |
Retrieve script file for one specific goal.
|
find_script_for_keywords [Proof] |
Retrieve matchable script files for w.r.t provided keywords.
|
find_state [State_builder.Dashtbl] |
|
fingerprint [Region.Create] |
|
fixpoint [Datalib.Create] |
|
flatten [Fol_split] |
|
float_of_value [Translate_expr.Create] |
|
float_operator [Translate_expr.Create] |
|
flow [Wpo] |
|
flush [Mdata.S] |
|
flush [Fol_eqs] |
|
flush [Datalib.Create] |
|
flush_context [Translate_prop.Create] |
|
fmemo [Ctypes] |
|
fold [State_builder.Dashtbl] |
|
fold [Map.S] |
fold f m a computes (f kN dN ... (f k1 d1 a)...) ,
where k1 ... kN are the keys of all bindings in m
(in increasing order), and d1 ... dN are the associated data.
|
fold [State_builder.Hashtbl] |
|
fold [Hashtbl.S] |
|
fold [Set.S] |
fold f s a computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s , in increasing order.
|
fold_alpha [Formula.S] |
|
fold_alpha [Fol_formula] |
|
fold_alpha [Caveat_fol] |
|
fold_data_in_exp [Fol] |
fold_data_in_exp do_var do_data acc exp
|
fold_data_in_pred [Fol] |
|
fold_exp_in_pred [Fol] |
TODO: this function is probably not exactly the good one
since bounded variables might escape.
|
fold_key [State_builder.Dashtbl] |
|
fold_nodes [Cil2cfg] |
iterators
|
fold_pred [Cil2cfg] |
|
fold_pred_e [Cil2cfg] |
|
fold_succ [Cil2cfg.WeiMaoZouChenInput] |
apply the function on the node successors
|
fold_succ [Cil2cfg.LoopInfo] |
|
fold_succ [Cil2cfg] |
|
fold_succ_e [Cil2cfg] |
|
for_all [Set.S] |
for_all p s checks if all elements of the set
satisfy the predicate p .
|
forall [Mdata.S] |
|
forall [Region.Create.Merge] |
|
forall [Region.Create] |
|
forall [Datalib.Create] |
|
forall_loc [Mvalues.Data] |
|
forall_loc [Runtime_mem.Create.Data] |
|
forall_loc [Store_mem.Create.Data] |
|
format_of_addr [Runtime_mem.Create] |
|
format_of_array [Runtime_mem.Create] |
|
format_of_c_float_type [Runtime_mem.Create] |
|
format_of_c_int_type [Runtime_mem.Create] |
|
format_of_compinfo [Runtime_mem.Create] |
|
format_of_object [Mdata.S] |
|
format_of_object [Datalib.Create] |
|
fp_addr [Region.Create] |
|
fp_base [Region.Create] |
|
fp_map [Region.Create] |
|
fp_offset [Region.Create] |
|
fp_range [Region.Create] |
|
fp_size [Region.Create] |
|
fpp_decl [Fol_pretty] |
|
fpp_decl [Fol_ergo] |
|
fpp_decl [Fol_coq] |
|
fpp_f_let [Fol_ergo] |
|
fpp_f_let [Fol_coq] |
|
fpp_goal [Fol_pretty] |
|
fpp_goal [Fol_ergo] |
|
fpp_goal [Fol_coq] |
|
fpp_header [Fol_pretty] |
|
fpp_header [Fol_ergo] |
|
fpp_header [Fol_coq] |
|
fpp_item [Fol_pretty] |
|
fpp_item [Fol_ergo] |
|
fpp_item [Fol_coq] |
|
fpp_lf_let [Fol_ergo] |
|
fpp_lf_let [Fol_coq] |
|
fpp_pred [Fol_pretty] |
|
fpp_pred [Fol_ergo] |
|
fpp_pred [Fol_coq] |
|
fpp_term [Fol_pretty] |
|
fpp_term [Fol_ergo] |
|
fpp_term [Fol_coq] |
|
fpred_of_pred [Caveat_mem.Make.Export] |
|
fpretty_term [Fol_pretty] |
|
fquantify_at_label [Funvar_mem.Create] |
|
fract_real [Whylib] |
|
free [Runtime_mem.Create.RtLib] |
|
free_vars [Store_mem.Create] |
|
free_vars [Fol_cc] |
|
fresh [Mdata.S] |
|
fresh [Mdata.Addr] |
|
fresh [Formula.S] |
|
fresh [Fol_gformula.Pool] |
|
fresh [Datalib.Create] |
|
fresh [Caveat_fol] |
|
fresh_name [Mdata.S] |
|
fresh_name [Datalib.Create] |
|
fresh_named_var [Fol.Var] |
|
fresh_typed_var [Fol.Var] |
|
fresh_var [Fol_gformula.Pool] |
|
fresh_var [Fol.Var] |
|
fresh_vars [Store_mem.Create] |
|
fresh_vars_in_pred [Fol] |
|
freshen [Formula.S] |
|
freshen [Fol_gformula.Pool] |
|
freshen [Datalib.Create] |
|
freshen [Caveat_fol] |
|
freshen_sigma [Datalib.Create] |
|
from_bits [Runtime_mem.Create.RtLib] |
|
fterm_of_addr [Caveat_mem.Make.Export] |
|
fterm_of_field [Caveat_mem.Make.Export] |
|
fterm_of_field_access [Caveat_mem.Make.Export] |
|
fterm_of_havoc_field [Caveat_mem.Make.Export] |
|
fterm_of_havoc_index [Caveat_mem.Make.Export] |
|
fterm_of_havoc_range [Caveat_mem.Make.Export] |
|
fterm_of_mu_field [Caveat_mem.Make.Export] |
|
fterm_of_mu_index [Caveat_mem.Make.Export] |
|
fterm_of_shift_field [Caveat_mem.Make.Export] |
|
fterm_of_shift_index [Caveat_mem.Make.Export] |
|
fterm_of_shift_pointer [Caveat_mem.Make.Export] |
|
fterm_of_term [Caveat_mem.Make.Export] |
|
fun_load [Funvar_mem.Create] |
|
funvar_offset [Funvar_mem.Create] |
|
funvar_path [Funvar_mem.Create] |
|
fupdate_at_label [Funvar_mem.Create] |
|
fvar_of_cvar [Caveat_fol] |
This variable has to be used for the value of v at Here .
|
fvar_of_cvar_at [Caveat_fol] |
|
G |
gaddress_of_cvar [Translate_prop.Create] |
|
gaddress_of_mem [Translate_prop.Create] |
|
gclear [Datalib.Create] |
|
gdummy [Datalib.Create] |
|
get [Wpo.Results] |
|
get [Po_navigator.Prover_Column] |
|
get [String] |
String.get s n returns character number n in string s .
|
get [Cil2cfg] |
|
get [State_builder.Ref] |
Get the referenced value.
|
get_annot_opt [Wp_gui] |
|
get_array_length [Hoare_lib.Create] |
build array_length t = sz when we know how to interpet the size sz
|
get_asgn_goal [WpAnnot] |
|
get_asgn_hyp [WpAnnot] |
|
get_asked_bhv_from_name [WpAnnot] |
|
get_assigns_method [Wp_parameters] |
|
get_axiom [Translate_prop.Create] |
|
get_behav [WpAnnot] |
|
get_behavior_annots [WpAnnot] |
|
get_behavior_names [WpAnnot] |
|
get_behavior_strategies [WpAnnot] |
Compute the strategy to prove all the properties of the behavior.
|
get_behaviors [Wp_parameters] |
|
get_bhv_assumes [WpAnnot] |
|
get_call_out_edges [Cil2cfg] |
similar to succ_e g v
but gives the edge to VcallOut first and the edge to VcallExit second.
|
get_cut [WpAnnot] |
get_inv only gives the general invariants (not loop invariant)
|
get_definition [Mdata.S.Registry] |
|
get_definition [Translate_prop.Create] |
|
get_definition [Datalib.Create.Registry] |
|
get_definition [Datalib.Create.Register] |
|
get_edge_labels [Cil2cfg] |
|
get_edge_next_stmt [Cil2cfg] |
|
get_env [Wp_parameters] |
|
get_exit [Store_mem.Create] |
|
get_exit_edges [Cil2cfg] |
Find the edges e that goes to the Vexit node inside the statement
begining at node n
|
get_exit_status [Mlogic.S] |
|
get_exit_status [Runtime_mem.Create] |
|
get_exit_status [Store_mem.Create] |
|
get_exit_status [Hoare_mem.Create] |
|
get_exit_status [Funvar_mem.Create] |
|
get_exit_status [Caveat_mem.Make.WP] |
|
get_ext_fct_assigns [WpAnnot] |
|
get_ext_postconditions [WpAnnot] |
|
get_ext_preconditions [WpAnnot] |
|
get_fct_assigns [WpAnnot] |
|
get_fct_post [WpAnnot] |
|
get_frame [Translate_prop.Create] |
|
get_function_strategies [WpAnnot] |
Compute the strategies to prove all the properties of the selected function.
|
get_funvar [Funvar_mem.Create] |
|
get_global_annotations [WpAnnot] |
|
get_goal_only [WpAnnot] |
|
get_hyp_goal [WpAnnot] |
the bool in get_cut results says if the property has to be
considered as a both goal and hyp (goal=true , or hyp only (goal=false )
|
get_hyp_only [WpAnnot] |
|
get_id_prop_strategies [WpAnnot] |
Compute the strategies to prove the selected property.
|
get_iloop_header [Cil2cfg.WeiMaoZouChenInput] |
get the node innermost loop header if any
|
get_iloop_header [Cil2cfg.LoopInfo] |
|
get_implicit_fun [WpFroms] |
Build the implicit function for the nth assign clause of behavior b
in the ki element of function kf.
|
get_ind [Mdata.S.Indexed] |
|
get_ind [Datalib.Create.Indexed] |
|
get_ind [Datalib.Create.Dindex] |
|
get_induction [WpAnnot] |
|
get_init_linfo [WpFroms] |
|
get_int [Ctypes] |
|
get_internal_edges [Cil2cfg] |
Find the edges e of the statement node n postcondition
and the set of edges that are inside the statement (e excluded).
|
get_inv [WpAnnot] |
|
get_linfo [WpFroms] |
|
get_linfo_cpt [WpFroms] |
Find the logic_info for the given name and signature.
|
get_loop_annots [WpAnnot] |
|
get_loop_assigns_for_from [WpAnnot] |
|
get_model [Wp_parameters] |
|
get_models [Wp_parameters] |
|
get_named_bhv [WpAnnot] |
|
get_node [Cil2cfg] |
|
get_norm [Wp_parameters] |
|
get_offset [Funvar_mem.Create.Lookup] |
|
get_only_succ [Calculus.Cfg] |
|
get_output [Wp_parameters] |
|
get_pos [Cil2cfg.WeiMaoZouChenInput] |
get the previously stored position of the node or 0 if nothing has been
stored
|
get_pos [Cil2cfg.LoopInfo] |
|
get_pos_if_traversed [Cil2cfg.WeiMaoZouChenInput] |
get the previously stored position of the node if any, or None
if set_pos hasn't been called already for this node.
|
get_pos_if_traversed [Cil2cfg.LoopInfo] |
|
get_pred_linfo [WpFroms] |
|
get_prop_strategies [WpAnnot] |
Similar to get_id_prop_strategies but with a named property.
|
get_properties [Wp_parameters] |
|
get_provers [Wp_parameters] |
|
get_range_index [Mdata.S] |
|
get_range_index [Datalib] |
|
get_range_index [Datalib.Create] |
|
get_read_addr [Caveat_mem.Make.WP] |
Collect the addresses of locations read by p .
|
get_result [Wpo] |
|
get_result [Store_mem.Create] |
|
get_results [Wpo] |
|
get_spec_assigns [WpAnnot] |
|
get_stmt [WpAnnot] |
|
get_stmt_annots [WpAnnot] |
|
get_stmt_node [Cil2cfg] |
In some cases (goto for instance) we have to create a node before having
processed if through cfg_stmt .
|
get_strategies [WpAnnot] |
|
get_subgraph [Cil2cfg.Printer] |
|
get_switch_edges [Cil2cfg] |
similar to succ_e g v
but give the switch cases and the default edge
|
get_terminates [WpAnnot] |
|
get_test_edges [Cil2cfg] |
Get the edges going out a test node with the then branch first
|
get_user_variable [Translate_prop.Create] |
|
get_var [Hoare_mem.Create] |
Get the wp variable of the C variable.
|
get_var [Caveat_mem.Make.WP] |
Get the wp variable of the C variable.
|
get_var [Caveat_fol] |
Get the wp variable of the C variable.
|
get_var_and_mu [Hoare_mem.Create] |
|
get_var_and_mu [Caveat_mem.Make.WP] |
|
get_variant [WpAnnot] |
|
get_weakest_precondition [Calculus.Cfg] |
|
get_wp_edge [Calculus.Cfg] |
|
gfresh [Datalib.Create] |
|
gid [Wpo] |
|
gindex [Datalib.Create] |
|
gindexref [Datalib.Create] |
|
global_frame [Caveat_mem.Make.WP] |
|
globalhints [Axiomatics] |
|
goal [Prover.Coq] |
|
goal [Prover.Why] |
|
goal_to_select [WpAnnot] |
|
graph_attributes [Cil2cfg.Printer] |
|
gsection [Datalib.Create] |
|
gstartof [Translate_prop.Create] |
|
gstartof_cvar [Translate_prop.Create] |
|
gstartof_mem [Translate_prop.Create] |
|
gstartof_value [Translate_prop.Create] |
|
guard [Mdata.S] |
|
guard [Datalib.Create] |
|
guards_with [Datalib.Create] |
|
H |
has_asgn_goal [WpAnnot] |
|
has_exit [Cil2cfg] |
wether an exit edge exists or not
|
has_prefix [Clabels] |
|
has_prop_goal [WpAnnot] |
|
has_reserved_prefix [Datalib] |
Returns true iff the string contains '_' and the prefix ending at the first '_' is
a reserved prefix.
|
has_type [Mdata.S] |
|
has_type [Datalib.Create] |
|
has_type_int [Datalib.Create] |
|
has_var [Datalib.Create] |
|
has_vars [Mdata.S] |
|
has_vars [Datalib.Create] |
|
hash [Datatype.Set] |
|
hash [Ctypes.AinfoComparable] |
|
hash [Ctypes] |
|
hash [Cil2cfg.VL] |
|
hash [Datalib.Create.LTinfo] |
|
havoc [Runtime_mem.Create.RtLib] |
|
havoc_field [Hoare_lib.Create.Hlib] |
|
havoc_index [Hoare_lib.Create.Hlib] |
|
havoc_inductive [Mdata.S] |
|
havoc_inductive [Datalib.Create] |
|
havoc_region [CfgWeakestPrecondition.Create] |
|
havoc_static [Mdata.S] |
|
havoc_static [Datalib.Create] |
|
havoc_ufield [Hoare_lib.Create.Hlib] |
|
hint_context [Translate_prop.Create] |
|
hints [Translate_prop.Create] |
|
huge_pred [Formula.S] |
|
huge_pred [Fol_formula] |
|
huge_pred [Fol] |
|
huge_pred [Caveat_fol] |
|
huge_term [Formula.S] |
|
huge_term [Fol_formula] |
|
huge_term [Fol] |
|
huge_term [Caveat_fol] |
|
I |
i_bool [Whylib] |
|
i_cmp [Mint.S] |
|
i_cmp [Mint_natural.Create] |
|
i_compare [Fol] |
|
i_compute [Fol] |
|
i_convert [Mdata.S] |
|
i_convert [Ctypes] |
|
i_convert [Datalib.Create] |
|
i_neg [Mint.S] |
|
i_neg [Mint_natural.Create] |
|
i_op [Mint.S] |
|
i_op [Whylib] |
|
i_op [Mint_natural.Create] |
|
i_pred [Whylib] |
|
i_sizeof [Ctypes] |
|
icmp_operator [Translate_expr.Create] |
|
id_of_id_assigns [WpAnnot] |
|
id_of_id_pred [WpAnnot] |
|
id_prop_txt [WpAnnot] |
|
ident [Script] |
|
ident_named_var [Fol.Var] |
|
identifier [Datalib] |
|
identify_loops [Cil2cfg.WeiMaoZouChen] |
|
idents [Script] |
|
idx [Ctypes] |
|
imemo [Ctypes] |
|
in_range [Data_mem.Create] |
|
included [Region.Create] |
|
included [Fol_split] |
|
included_bases [Region.Create] |
|
included_cvars [Region.Create] |
|
included_find [Region.Create] |
|
included_ranges [Region.Create] |
|
included_roots [Region.Create] |
|
included_zone_in_bases [Region.Create] |
|
included_zone_in_cvars [Region.Create] |
|
included_zone_in_roots [Region.Create] |
|
incr [Cil2cfg.LoopInfo] |
|
incr_xi [Cil2cfg.WeiMaoZouChenInput] |
the unstructuredness coefficient k can be computed = 1+(xi+yi)/E
when E is the number of edge in the graph.
|
incr_xi [Cil2cfg.LoopInfo] |
|
incr_yi [Cil2cfg.WeiMaoZouChenInput] |
|
incr_yi [Cil2cfg.LoopInfo] |
|
index [Mvalues.S] |
index tab tau k computes the location
of tab[k] , where tab is an array with elements of type tau .
|
index [Mvalues.Data] |
|
index [Mdata.S.Identifiable] |
|
index [Runtime_mem.Create.Data] |
|
index [Store_mem.Create.Data] |
|
index [Hoare_mem.Create] |
|
index [Region.Create] |
index b k is the cell at index k in block k .
|
index [Funvar_mem.Create] |
|
index [String] |
String.index s c returns the character number of the first
occurrence of character c in string s .
|
index [Translate_prop.Create.UserAxiomDefs] |
|
index [Translate_prop.Create.UserDefinition] |
|
index [Datalib.Create.Identifiable] |
|
index [Datalib.Create.LTinfoId] |
|
index [Datalib.Create.Logicvar] |
|
index [Datalib.Create.LTypeinfo] |
|
index [Datalib.Create.Arrayinfo] |
|
index [Datalib.Create.Compinfo] |
|
index [Datalib.Create.Fieldinfo] |
|
index [Datalib.Create.Varinfo] |
|
index [Caveat_mem.Make.WP] |
|
index_from [String] |
String.index_from s i c returns the character number of the
first occurrence of character c in string s after position i .
|
indir [Caveat_mem.Make.WP.CavLib] |
|
indir [Caveat_mem.Make.WP] |
d should be a data that represent an adddress:
|
indir [Caveat_fol] |
|
indir_at [Caveat_fol] |
|
indir_here [Caveat_fol] |
|
init [Cil2cfg.WeiMaoZouChenInput] |
build a new env from a graph,
and also return the entry point of the graph which has to be unique.
|
init [Cil2cfg.LoopInfo] |
|
init_cfg [Cil2cfg] |
|
init_env [Fol_eqs] |
|
instance_of_hint [Translate_prop.Create] |
|
instantiate [Translate_prop.Create] |
|
int_cmp [Translate_prop.Create] |
|
int_format [Mdata.S] |
|
int_format [Datalib.Create] |
|
int_format_for_hyp [Runtime_mem.Create] |
|
int_of_value [Translate_expr.Create] |
|
int_op [Translate_prop.Create] |
|
int_operator [Translate_expr.Create] |
|
integer_of_data [Translate_prop.Create] |
|
integer_of_real [Formula.S] |
|
integer_of_real [Whylib.Create] |
|
integer_of_real [Whylib] |
|
integer_of_value [Translate_prop.Create] |
|
integer_of_xaddr [Runtime_mem.Create.Tint] |
|
integers [Datalib.Create] |
|
inter [Mdata.S] |
inter s0 s1 returns the intersection set of s0 and s1 .
|
inter [Set.S] |
Set intersection.
|
inter [Datalib.Create] |
|
internal_function_behaviors [WpAnnot] |
|
internal_kind [Dashtbl.Graph] |
|
internal_pretty_code [Datatype.Set] |
|
interval [Mdata.S] |
range l h returns the integer set s such as { i in s | l <=
i <= h }.
|
interval [Datalib.Create] |
|
ip_complete [WpAnnot] |
|
ip_contract [WpAnnot] |
|
ip_disjoint [WpAnnot] |
|
ip_external [WpAnnot] |
|
is_annot_for_config [WpAnnot] |
|
is_assigns [WpAnnot] |
|
is_atomic [Region.Create] |
|
is_back_edge [Cil2cfg] |
|
is_composed [WpAnnot] |
whether a proof needs several lemma to be complete
|
is_empty [Hook.S] |
Is no function already registered in the hook?
|
is_empty [Region.Create] |
|
is_empty [Map.S] |
Test whether a map is empty or not.
|
is_empty [Set.S] |
Test whether a set is empty or not.
|
is_error [Prover.Log] |
|
is_false [Formula.S] |
|
is_false [Fol_gformula.Predicate] |
|
is_funvar [Vaddr] |
|
is_havoc [Runtime_mem.Create.RtLib] |
|
is_irreducible [Cil2cfg.LoopInfo] |
|
is_local [State_builder.Dashtbl] |
|
is_null [Mdata.S] |
Take a term representing an address and returns a
term of type bool .
|
is_null [Datalib.Create] |
|
is_proved [WpAnnot] |
wether all partial proofs have been accumulated or not
|
is_requires [WpAnnot] |
|
is_true [Formula.S] |
|
is_true [Fol_gformula.Predicate] |
|
is_zone [Fol_split] |
|
iter [Mdata.S] |
|
iter [Wpo.Results] |
|
iter [Wpo] |
|
iter [State_builder.Dashtbl] |
|
iter [Map.S] |
iter f m applies f to all bindings in map m .
|
iter [String] |
String.iter f s applies function f in turn to all
the characters of s .
|
iter [State_builder.Hashtbl] |
|
iter [Hashtbl.S] |
|
iter [Set.S] |
iter f s applies f in turn to all elements of s .
|
iter [Datalib.Create] |
|
iter_all [Mdata.S] |
|
iter_all [Datalib.Create] |
|
iter_bases [Region.Create] |
|
iter_description [Cfgpropid.Create] |
|
iter_dnodes [Cfgpropid] |
|
iter_edges [Cil2cfg] |
|
iter_edges_e [Cil2cfg.Printer] |
|
iter_key [State_builder.Dashtbl] |
|
iter_nodes [Cil2cfg] |
|
iter_others [Region.Create] |
|
iter_pred_e [Cil2cfg] |
|
iter_succ [Cil2cfg] |
|
iter_vertex [Cil2cfg.Printer] |
|
J |
job [Wp_parameters] |
|
K |
key [Script] |
|
keywords [Script] |
|
ki_assigns_labels [WpAnnot] |
|
kill [Mdata.S] |
|
kill [Datalib.Create] |
|
kill_context [Translate_prop.Create] |
|
kind [Wprop.Info] |
|
kind [Wprop.Actor] |
|
kind_of [Translate_prop.Create] |
|
kind_of_data [Translate_prop.Create] |
|
kind_of_typ [Translate_prop.Create] |
|
kind_of_var [Formula.S] |
|
kind_of_var [Fol_gformula.Pool] |
|
kind_of_var [Fol.Var] |
|
kind_of_var [Caveat_fol] |
|
kind_order [WpAnnot] |
|
kindex [Wprop] |
|
L |
label [Mcfg.S] |
|
label [Clabels] |
|
label [Cfgpropid.Create] |
|
label [CfgWeakestPrecondition.Create] |
|
label_at_closure [Mlogic.S] |
|
label_at_closure [Runtime_mem.Create] |
|
label_at_closure [Store_mem.Create] |
|
label_at_closure [Hoare_mem.Create] |
|
label_at_closure [Funvar_mem.Create] |
|
label_at_closure [Caveat_mem.Make.WP] |
|
label_name [Axiomatics] |
|
label_of_kind [WpAnnot] |
|
label_of_prop_id [WpAnnot] |
Short description of the kind of PO
|
labels_assert_after [NormAtLabels] |
|
labels_assert_before [NormAtLabels] |
|
labels_axiom [NormAtLabels] |
|
labels_empty [NormAtLabels] |
|
labels_fct_assigns [NormAtLabels] |
|
labels_fct_post [NormAtLabels] |
|
labels_fct_pre [NormAtLabels] |
|
labels_loop_assigns [NormAtLabels] |
|
labels_loop_inv [NormAtLabels] |
|
labels_predicate [NormAtLabels] |
|
labels_stmt_assigns [NormAtLabels] |
|
labels_stmt_post [NormAtLabels] |
|
labels_stmt_pre [NormAtLabels] |
|
le_int [Whylib] |
|
le_int_bool [Whylib] |
|
le_pointer [Mdata.S] |
le_pointer p q is the less than or equal comparison
of pointers p and q , that points to elements of type ty ,
ie.
|
le_pointer [Datalib.Create] |
|
le_pointer_bool [Mdata.S] |
le_pointer_bool p q is the less than or equal comparison
of pointers p and q , that points to elements of type ty ,
ie.
|
le_pointer_bool [Datalib.Create] |
|
le_real [Whylib] |
|
le_real_bool [Whylib] |
|
length [State_builder.Dashtbl] |
|
length [Hook.S] |
Number of registered functions.
|
length [String] |
Return the length (number of characters) of the given string.
|
length [State_builder.Hashtbl] |
Length of the table.
|
length [Hashtbl.S] |
|
let_expansion [Fol_eval] |
|
let_pred [Fol] |
Build a predicate equivalent to let v = e in p but may use the
substitution in some simple cases (like substitute a variable by another
variable for instance).
|
list_of [Translate_prop.Create] |
|
load [Mvalues.S] |
|
load [Runtime_mem.Create.RtLib] |
|
load [Runtime_mem.Create] |
|
load [Store_mem.Create] |
|
load [Hoare_mem.Create] |
|
load [Funvar_mem.Create] |
|
load [Caveat_mem.Make.WP] |
|
load_mem [Mvalues.Data] |
|
load_mem [Runtime_mem.Create.Data] |
Read a data of type te at loc and returns it as a logic value.
|
load_mem [Store_mem.Create.Data] |
|
load_mem [Store_mem.Create] |
|
load_rec [Store_mem.Create.Data] |
|
load_with [Store_mem.Create] |
|
loaded [Data_mem.Create] |
|
loadscripts [Proof] |
Load scripts from -wp-script f .
|
loc_of_data [Translate_prop.Create] |
|
loc_of_funloc [Funvar_mem.Create] |
|
loc_of_path [Funvar_mem.Create] |
|
loc_of_pointer [Mvalues.Model] |
|
loc_of_pointer [Runtime_mem.Create.Model] |
|
loc_of_pointer [Store_mem.Create.Model] |
|
loc_of_pointer [Hoare_mem.Create.Model] |
|
loc_of_pointer [Funvar_mem.Create.Model] |
|
loc_of_pointer [Datalib.Cvalues] |
|
loc_of_pointer [Caveat_mem.Make.WP.Model] |
|
loc_of_value [Translate_expr.Create] |
|
loc_offset [Translate_prop.Create] |
|
loc_range [Datalib.Create] |
|
local [Wpo] |
|
local_scope [Mwp.S] |
local_scope m l transforms the predicate p at the
enter-point of a block or function that
declares the local variables in the list.
|
local_scope [Runtime_mem.Create] |
|
local_scope [Store_mem.Create] |
|
local_scope [Hoare_mem.Create] |
process local scope : bool=true for allocation, false for free
|
local_scope [Funvar_mem.Create] |
|
local_scope [Caveat_mem.Make.WP] |
|
location [Mdata.S.Identifiable] |
|
location [Datalib.Create.Identifiable] |
|
location [Datalib.Create.LTinfoId] |
|
location [Datalib.Create.Logicvar] |
|
location [Datalib.Create.LTypeinfo] |
|
location [Datalib.Create.Arrayinfo] |
|
location [Datalib.Create.Compinfo] |
|
location [Datalib.Create.Fieldinfo] |
|
location [Datalib.Create.Varinfo] |
|
locked [Datalib.Create] |
|
logic_data [Caveat_mem.Make.WP] |
|
logic_of_mem [Runtime_mem.Create] |
|
logic_of_value [Mvalues.Values] |
|
logic_of_value [Datalib.Cvalues] |
|
logic_offset [Translate_prop.Create] |
|
lookup [Clabels] |
lookup bindings lparam retrieves the actual label
for the label in bindings for label parameter lparam .
|
loop_head_label [Cil2cfg] |
|
loop_node_edges [Cil2cfg] |
|
loop_nodes [Cil2cfg] |
|
loop_stmts [Cil2cfg] |
|
lowercase [String] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
|
lt_int [Whylib] |
|
lt_int_bool [Whylib] |
|
lt_pointer [Mdata.S] |
lt_pointer p q is the less than comparison
of pointers p and q , that points to elements of type ty ,
ie.
|
lt_pointer [Datalib.Create] |
|
lt_pointer_bool [Mdata.S] |
lt_pointer_bool p q is the less than comparison
of pointers p and q , that points to elements of type ty ,
ie.
|
lt_pointer_bool [Datalib.Create] |
|
lt_real [Whylib] |
|
lt_real_bool [Whylib] |
|
lvar [Translate_prop.Create] |
|
lvar_of_variable [Fol.Var] |
|
M |
main [Wp_gui] |
|
main [Register] |
|
make [String] |
String.make n c returns a fresh string of length n ,
filled with the character c .
|
make_c_float [Ctypes] |
|
make_c_int [Ctypes] |
|
make_goal [Runtime_mem.Create] |
|
make_goal [Cfgpropid.Create] |
|
make_logic_info [WpFroms] |
Build a logic_info with fname and the signature given by
(out_type, in_types) (see WpFroms.mk_linfo_type )
TODO: should be Cil_const.make_logic_info when it be finished.
|
make_panel [Po_navigator] |
|
malloc_of_mem [Runtime_mem.Create] |
|
map [Map.S] |
map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
|
mapi [Map.S] |
Same as Map.S.map , but the function receives as arguments both the
key and the associated value for each binding of the map.
|
mark_loops [Cil2cfg] |
|
massigned [Funvar_mem.Create] |
|
max_elt [Set.S] |
Same as Set.S.min_elt , but returns the largest element of the
given set.
|
mbits_of_mem [Runtime_mem.Create] |
|
mem [State_builder.Dashtbl] |
|
mem [Map.S] |
mem x m returns true if m contains a binding for x ,
and false otherwise.
|
mem [State_builder.Hashtbl] |
|
mem [Hashtbl.S] |
|
mem [Set.S] |
mem x s tests whether x belongs to the set s .
|
mem_at [Mlogic.S] |
mem_at e l returns the memory associates to
the label l in the environment e .
|
mem_at [Runtime_mem.Create] |
|
mem_at [Store_mem.Create] |
|
mem_at [Hoare_mem.Create] |
gives the memory state for that label.
|
mem_at [Funvar_mem.Create] |
|
mem_at [Caveat_mem.Make.WP] |
gives the memory state for that label.
|
mem_at_env [Translate_prop.Create] |
|
mem_project [Datatype.Set] |
|
memo [State_builder.Dashtbl] |
|
memo [State_builder.Hashtbl] |
Memoization.
|
memory_offset [Translate_prop.Create] |
|
merge [Mcfg.S] |
|
merge [Cfgpropid.Create] |
|
merge [Translate_prop.Create] |
|
merge [CfgWeakestPrecondition.Create] |
|
merge_acc [WpAnnot] |
|
merge_assigns [WpAnnot] |
|
merge_assigns [CfgWeakestPrecondition.Create] |
|
merge_property [CfgWeakestPrecondition.Create] |
|
merge_with [CfgWeakestPrecondition.Create] |
|
min_elt [Set.S] |
Return the smallest element of the given set
(with respect to the Ord.compare ordering), or raise
Not_found if the set is empty.
|
minus_pointer [Mdata.S] |
minus_pointer ty p q is the arithmetics difference of
pointers p and q , that points to elements of type ty ,
ie.
|
minus_pointer [Datalib.Create] |
|
missing_rte [WpAnnot] |
|
mk_access_ufield [Datalib] |
|
mk_annot_id [WpAnnot] |
|
mk_array_format [Datalib] |
|
mk_assign_annots_for_froms [WpAnnot] |
|
mk_assign_post [WpFroms] |
Build P(output)
|
mk_assign_pre [WpFroms] |
Build xi = Init (i) /\ ... forall inputs.
|
mk_assign_strategy_for_froms [WpAnnot] |
|
mk_axiom_id [WpAnnot] |
|
mk_code_annot_id [WpAnnot] |
|
mk_compl_bhv_id [WpAnnot] |
|
mk_decrease_id [WpAnnot] |
|
mk_def [Fol_cc] |
|
mk_disj_bhv_id [WpAnnot] |
|
mk_empty [Datalib] |
|
mk_eq_array [Datalib] |
|
mk_eq_array_bool [Datalib] |
|
mk_eq_record [Datalib] |
|
mk_eq_record_bool [Datalib] |
|
mk_eq_urecord [Datalib] |
|
mk_eq_urecord_bool [Datalib] |
|
mk_equal_pointer_bool [Datalib] |
|
mk_establish_id [WpAnnot] |
|
mk_exit_assigns_id [WpAnnot] |
|
mk_fct_post_id [WpAnnot] |
|
mk_fformat [Datalib] |
|
mk_fguard [Datalib] |
|
mk_fout_assigns_id [WpAnnot] |
|
mk_iformat [Datalib] |
|
mk_iguard [Datalib] |
|
mk_imodulo [Datalib] |
|
mk_int_format [Datalib] |
|
mk_integers [Datalib] |
|
mk_inter [Datalib] |
|
mk_inv_hyp_id [WpAnnot] |
|
mk_is_null [Datalib] |
|
mk_le_pointer [Datalib] |
|
mk_le_pointer_bool [Datalib] |
|
mk_let [Caveat_fol] |
|
mk_linfo_type [WpFroms] |
Build the logic type of the function that takes parameters of in_types
and return an out_type result (None for a predicate)
|
mk_logic_label [Cil2cfg] |
create a virtual label to a statement (it can have no label)
|
mk_loop_assigns_id [WpAnnot] |
|
mk_lt_pointer [Datalib] |
|
mk_lt_pointer_bool [Datalib] |
|
mk_lvar_variable [Fol.Var] |
|
mk_minus_pointer [Datalib] |
|
mk_mu [Hoare_mem.Create] |
compute m_0 where : mu_i = mu (obj_(i-1), d_i -> mu_(i+1))
and at the last step (n), mu_(n+1) = exp.
|
mk_mu [Caveat_mem.Make.WP] |
|
mk_mu [Caveat_fol] |
|
mk_mu_range [Caveat_fol] |
|
mk_mu_range_indir [Caveat_fol] |
|
mk_mu_sh_indir [Caveat_fol] |
|
mk_null [Datalib] |
|
mk_pointer_format [Datalib] |
|
mk_pre_id [WpAnnot] |
|
mk_predicate_id [WpAnnot] |
|
mk_preserve_id [WpAnnot] |
|
mk_prop [WpAnnot] |
|
mk_radd [Datalib] |
|
mk_range [Datalib] |
|
mk_range_inf [Datalib] |
|
mk_range_sup [Datalib] |
|
mk_real_format [Datalib] |
|
mk_record_format [Datalib] |
|
mk_remove [Datalib] |
|
mk_rmult [Datalib] |
|
mk_rneg [Datalib] |
|
mk_round [Datalib] |
|
mk_singleton [Datalib] |
|
mk_stmt_assigns_id [WpAnnot] |
|
mk_stmt_post_id [WpAnnot] |
|
mk_union [Datalib] |
|
mk_update_ufield [Datalib] |
|
mk_urecord_format [Datalib] |
|
mk_v_array_length [Hoare_lib.Create] |
|
mk_var_decr_id [WpAnnot] |
|
mk_var_pos_id [WpAnnot] |
|
mk_variant_properties [WpAnnot] |
|
mk_xzone [Runtime_mem.Create.Tint] |
|
mloc_of_loc [Funvar_mem.Create] |
|
mloc_of_path [Funvar_mem.Create.Lookup] |
|
mod_int [Whylib] |
|
model_access [Store_mem.Create] |
|
model_access_range [Store_mem.Create] |
|
model_addr [Store_mem.Create] |
|
model_addr_of_pointer [Store_mem.Create] |
|
model_addr_shift [Store_mem.Create] |
|
model_alloc [Store_mem.Create] |
|
model_base [Store_mem.Create] |
|
model_block [Store_mem.Create] |
|
model_free [Store_mem.Create] |
|
model_included [Store_mem.Create] |
|
model_isfresh [Store_mem.Create] |
|
model_ishavoc [Store_mem.Create] |
|
model_names [Wp_parameters] |
|
model_of_name [Wp_parameters] |
|
model_offset [Store_mem.Create] |
|
model_offset_of_pointer [Store_mem.Create] |
|
model_pointer_of_addr [Store_mem.Create] |
|
model_separated [Store_mem.Create] |
|
model_update [Store_mem.Create] |
|
model_update_range [Store_mem.Create] |
|
model_valid [Store_mem.Create] |
|
model_zempty [Store_mem.Create] |
|
model_zrange [Store_mem.Create] |
|
model_zrange_of_addr_range [Store_mem.Create] |
|
model_zunion [Store_mem.Create] |
|
modulo [Mdata.S] |
|
modulo [Datalib.Create] |
|
most_suitable [Proof] |
|
mu_indir [Caveat_mem.Make.WP.CavLib] |
|
mu_range_indir [Caveat_mem.Make.WP.CavLib] |
similat to D1.set_range_index but for pointer
|
mul [Store_mem.Create] |
|
mul_int [Whylib] |
|
mul_real [Whylib] |
|
mult [Runtime_mem.Create.Aint] |
|
mult_set [Mdata.S] |
|
mult_set [Datalib.Create] |
|
mvalue_of_value [Funvar_mem.Create] |
|
N |
n_size [Store_mem.Create] |
|
name [Wprop.Actor] |
|
name [Wp_error] |
|
name [Datatype.Set] |
|
name [CfgProof.Description] |
Public name for user feedback
|
name_of_field [Runtime_mem.Create] |
|
name_of_var [Formula.S] |
|
name_of_var [Runtime_mem.Create] |
|
name_of_var [Fol_gformula.Pool] |
|
name_of_var [Caveat_fol] |
|
names_at [Clabels] |
|
ne_int [Whylib] |
|
ne_int_bool [Whylib] |
|
ne_real [Whylib] |
|
ne_real_bool [Whylib] |
|
neg_int [Whylib] |
|
neg_interval [Translate_prop.Create] |
|
neg_real [Whylib] |
|
neg_set [Mdata.S] |
|
neg_set [Datalib.Create] |
|
new_cfg_env [Cil2cfg] |
|
new_env [Mcfg.S] |
|
new_env [Wpo] |
Generates a fresh environment name.
|
new_env [Cfgpropid.Create] |
|
new_env [CfgWeakestPrecondition.Create] |
|
new_fname [Fol_eval] |
|
new_frame [Mlogic.S] |
|
new_frame [Runtime_mem.Create] |
|
new_frame [Store_mem.Create] |
|
new_frame [Hoare_mem.Create] |
|
new_frame [Funvar_mem.Create] |
|
new_frame [Caveat_mem.Make.WP] |
|
new_fun_frame [Funvar_mem.Create] |
|
new_loop_computation [WpAnnot] |
|
new_loops [WpAnnot] |
|
new_mem [Runtime_mem.Create] |
|
new_mem [Hoare_mem.Create] |
|
new_name [Fol_eqs] |
|
new_name [Fol_cc] |
|
new_script [Proof] |
new_script goal keys proof registers the script proof for goal goal
and keywords keys
|
newline [Script] |
|
next_edge [Cil2cfg] |
|
no_quantif_do_exp [Fol] |
|
node_after [Cil2cfg] |
Find the node that follows the input node statement.
|
node_id [Cil2cfg] |
|
node_stmt_exn [Cil2cfg] |
|
node_stmt_opt [Cil2cfg] |
|
node_type [Cil2cfg] |
|
node_type_id [Cil2cfg] |
gives a identifier to each CFG node in order to hash them
|
normalize [Fol_norm] |
|
not_of_float [Translate_expr.Create] |
|
not_of_int [Translate_expr.Create] |
|
not_of_integer [Translate_expr.Create] |
|
not_of_ptr [Translate_expr.Create] |
|
not_of_value [Translate_expr.Create] |
|
not_yet_implemented [Wp_error] |
|
notexists_vars [Store_mem.Create] |
|
null [Mdata.S] |
null return the special location of the memory model designing
the null pointer.
|
null [Datalib.Create] |
|
null [Caveat_mem.Make.WP] |
|
null [Caveat_fol] |
|
O |
object_of [Ctypes] |
|
object_of_pointed [Ctypes] |
c_objects of elements pointed to by pointer or array.
|
object_of_pointed [Translate_prop.Create] |
|
occur_check [Datalib.Create] |
|
of_int [Runtime_mem.Create.Aint] |
|
of_int64 [Runtime_mem.Create.Aint] |
|
of_name [Prover.SMT] |
|
of_term [Runtime_mem.Create.Aint] |
|
offset [Store_mem.Create.Data] |
|
offset [Store_mem.Create.Model] |
|
offset_of_field [Store_mem.Create] |
|
on_all_functions [Register] |
|
on_array [Data_mem.Create.Compound] |
|
on_clear [Mdata.S] |
|
on_clear [Datalib.Create] |
|
on_context [CfgWeakestPrecondition.Create] |
|
on_definition [Mdata.S.Registry] |
|
on_definition [Register] |
|
on_definition [Datalib.Create.Registry] |
|
on_definition [Datalib.Create.Register] |
|
on_function [Register] |
|
on_function_names [Register] |
|
on_record [Data_mem.Create.Compound] |
|
on_reset [Wp_parameters] |
|
once [Prover.Coq] |
|
one [Store_mem.Create] |
|
open_file [Script] |
|
opt_env [Funvar_mem.Create] |
|
opt_mem [Funvar_mem.Create] |
|
option [Register] |
|
output [Prover.Log] |
|
P |
p_alpha_cv [Formula.S] |
easier to use when doing a simple alpha conversion.
|
p_alpha_cv [Fol_formula] |
|
p_alpha_cv [Fol] |
|
p_alpha_cv [Caveat_fol] |
|
p_and [Formula.S] |
|
p_and [Fol_gformula.Predicate] |
|
p_and [Fol] |
|
p_app [Fol] |
|
p_app0 [Mdata.S] |
|
p_app0 [Datalib.Create] |
|
p_app1 [Mdata.S] |
|
p_app1 [Datalib.Create] |
|
p_app2 [Mdata.S] |
|
p_app2 [Datalib.Create] |
|
p_app3 [Mdata.S] |
|
p_app3 [Datalib.Create] |
|
p_app4 [Mdata.S] |
|
p_app4 [Datalib.Create] |
|
p_app5 [Mdata.S] |
|
p_app5 [Datalib.Create] |
|
p_block [Region.Create] |
|
p_bool [Formula.S] |
|
p_bool [Fol_gformula.Predicate] |
|
p_call [Formula.Vernacular] |
|
p_call [Fol_gformula.Langage] |
|
p_closed [Fol] |
|
p_cond [Formula.S] |
|
p_cond [Fol_gformula.Predicate] |
|
p_conj [Formula.S] |
|
p_conj [Fol_gformula.Predicate] |
|
p_conj [Fol] |
|
p_disj [Formula.S] |
|
p_disj [Fol_gformula.Predicate] |
|
p_disj [Fol] |
|
p_eq [Formula.S] |
|
p_eq [Fol_gformula.Predicate] |
|
p_eq [Fol] |
|
p_exists [Formula.S] |
|
p_exists [Fol_gformula.Predicate] |
|
p_exists [Fol] |
|
p_exists [Caveat_fol] |
|
p_exists_vars [Fol] |
|
p_false [Formula.S] |
|
p_false [Fol_gformula.Predicate] |
|
p_field [Region.Create] |
|
p_forall [Formula.S] |
|
p_forall [Fol_gformula.Predicate] |
|
p_forall [Fol] |
|
p_forall [Caveat_fol] |
|
p_forall_vars [Fol] |
|
p_has_var [Fol] |
|
p_icmp [Formula.S] |
|
p_icmp [Whylib.Create] |
|
p_if [Fol] |
|
p_iff [Formula.S] |
|
p_iff [Fol_gformula.Predicate] |
|
p_iff [Fol] |
|
p_implies [Formula.S] |
|
p_implies [Fol_gformula.Predicate] |
|
p_implies [Fol] |
|
p_index [Region.Create] |
|
p_interval [Region.Create] |
|
p_let [Fol] |
|
p_more_alpha_cv [Formula.S] |
alpha', p' = p_more_alpha_cv alpha p build p' from p by renaming
all the variable v into v' according to the mapping alpha.
|
p_more_alpha_cv [Fol_formula] |
|
p_more_alpha_cv [Caveat_fol] |
|
p_named [Formula.S] |
|
p_named [Fol_gformula.Predicate] |
|
p_named [Fol] |
|
p_neq [Formula.S] |
|
p_neq [Fol_gformula.Predicate] |
|
p_neq [Fol] |
|
p_not [Formula.S] |
|
p_not [Fol_gformula.Predicate] |
|
p_not [Fol] |
|
p_or [Formula.S] |
|
p_or [Fol_gformula.Predicate] |
|
p_or [Fol] |
|
p_range [Region.Create] |
|
p_rcmp [Formula.S] |
|
p_rcmp [Whylib.Create] |
|
p_subst [Formula.S] |
|
p_subst [Fol_gformula.Predicate] |
|
p_subst [Caveat_fol] |
|
p_true [Formula.S] |
|
p_true [Fol_gformula.Predicate] |
|
p_unfold [Fol_split] |
|
p_xor [Formula.S] |
|
p_xor [Fol_gformula.Predicate] |
|
p_xor [Fol] |
|
packed_descr [Datatype.Set] |
|
parse_coqproof [Proof] |
parse_coqproof f parses a coq-file f and fetch the first proof.
|
parse_scripts [Proof] |
parse_scripts f parses all scripts from file f and put them in the database.
|
part_of_item [Datalib.Create] |
|
partition [Set.S] |
partition p s returns a pair of sets (s1, s2) , where
s1 is the set of all the elements of s that satisfy the
predicate p , and s2 is the set of all the elements of
s that do not satisfy p .
|
path [Region.Create] |
|
path_has_var [Caveat_fol] |
|
pcmp_operator [Translate_expr.Create] |
|
pcmp_rel [Translate_expr.Create] |
|
pid_for_function [WpAnnot] |
|
pint_cmp [Translate_prop.Create] |
|
plus [Translate_prop.Create] |
|
plus_interval [Translate_prop.Create] |
|
plus_interval_interval [Translate_prop.Create] |
|
pointer_format [Mdata.S] |
|
pointer_format [Datalib.Create] |
|
pointer_of_loc [Mvalues.Model] |
|
pointer_of_loc [Runtime_mem.Create.Model] |
|
pointer_of_loc [Store_mem.Create.Model] |
|
pointer_of_loc [Hoare_mem.Create.Model] |
|
pointer_of_loc [Funvar_mem.Create.Model] |
|
pointer_of_loc [Datalib.Cvalues] |
|
pointer_of_loc [Caveat_mem.Make.WP.Model] |
|
pointer_of_xaddr [Runtime_mem.Create.Tint] |
Notice that pointer_of_loc and loc_of_pointer are abstract
operations to switch between generic part and model part.
|
pool [Mdata.S] |
|
pool [Formula.S] |
|
pool [Fol_gformula.Pool] |
|
pool [Datalib.Create] |
|
pool [Caveat_fol] |
|
pop [Mdata.S] |
|
pop [Datalib.Collector] |
|
pop [Datalib.Create] |
|
pop_instances [Translate_prop.Create] |
|
post_of_assigns_in_spec [WpFroms] |
For each behavior of the specification, return a predicate
which is a conjonction of out_i = implicit_fun_i (inputs)
for each out_i \from inputs assigns property of the behavior.
|
pp_addr [Mdata.Addr] |
|
pp_addr [Runtime_mem.Create.Tint] |
|
pp_annots [WpAnnot] |
|
pp_args [Fol_ergo] |
|
pp_args [Fol_coq] |
|
pp_asked_prop [WpAnnot] |
|
pp_assign [Wp_error] |
|
pp_assigns [Wp_error] |
|
pp_assigns_mode [WpAnnot] |
|
pp_axiomdef_descr [Translate_prop.Create.UserAxiomDefs] |
|
pp_axiomdef_title [Translate_prop.Create.UserAxiomDefs] |
|
pp_binding [Datalib.Create] |
|
pp_bindings [Datalib.Create] |
|
pp_block [Fol_pretty] |
|
pp_block [Fol_ergo] |
|
pp_block [Fol_coq] |
|
pp_closure [Mlogic.S] |
|
pp_closure [Runtime_mem.Create] |
|
pp_closure [Store_mem.Create] |
|
pp_closure [Hoare_mem.Create] |
|
pp_closure [Funvar_mem.Create] |
|
pp_closure [Caveat_mem.Make.WP] |
|
pp_closures [Translate_prop.Create] |
|
pp_command [Prover.Log] |
|
pp_ctype [Datalib.Create] |
|
pp_current [Prover.Log] |
|
pp_data [Translate_prop.Create] |
|
pp_data [Caveat_fol.Data] |
|
pp_data [Caveat_fol] |
|
pp_decl [Formula.S] |
|
pp_decl [Fol_pretty.Create] |
|
pp_dependency [Wpo] |
|
pp_descr [Mdata.S.Identifiable] |
|
pp_descr [Cfgpropid.Create] |
|
pp_descr [Datalib.Create.Identifiable] |
|
pp_descr [Datalib.Create.LTinfoId] |
|
pp_descr [Datalib.Create.Logicvar] |
|
pp_descr [Datalib.Create.LTypeinfo] |
|
pp_descr [Datalib.Create.Arrayinfo] |
|
pp_descr [Datalib.Create.Compinfo] |
|
pp_descr [Datalib.Create.Fieldinfo] |
|
pp_descr [Datalib.Create.Varinfo] |
|
pp_dim [Datalib.Create] |
|
pp_dnode [Cfgpropid] |
|
pp_edge [Cil2cfg] |
|
pp_environment [Wpo] |
|
pp_epath [Hoare_mem.Create.Model] |
|
pp_epath [Caveat_fol] |
|
pp_float [Ctypes] |
|
pp_flow [Fol_pretty] |
|
pp_flow [Fol_ergo] |
|
pp_flow [Fol_coq] |
|
pp_formals [Translate_prop.Create] |
|
pp_function [Wpo] |
|
pp_goal [Formula.S] |
|
pp_goal [Wpo] |
|
pp_goal [Fol_pretty.Create] |
|
pp_goal [Cfgpropid.Create] |
|
pp_goal_flow [Wpo] |
|
pp_goalx [Cfgpropid.Create] |
|
pp_hint [Axiomatics] |
|
pp_id [WpAnnot] |
|
pp_int [Ctypes] |
|
pp_interval [Mdata.S] |
|
pp_interval [Datalib.Create] |
|
pp_kind [Mdata.S] |
|
pp_kind [Translate_prop.Create] |
|
pp_kind [Datalib.Create] |
|
pp_labels [Axiomatics] |
|
pp_list [Fol_pretty] |
|
pp_list [Fol_ergo] |
|
pp_list [Fol_coq] |
|
pp_list [Cfgpropid] |
|
pp_loc [Mvalues.Model] |
|
pp_loc [Runtime_mem.Create.Model] |
|
pp_loc [Store_mem.Create.Model] |
|
pp_loc [Hoare_mem.Create.Model] |
|
pp_loc [Funvar_mem.Create.Model] |
|
pp_loc [Datalib.Cvalues] |
|
pp_loc [Caveat_mem.Make.WP.Model] |
|
pp_logic_label [Wp_error] |
|
pp_names [WpAnnot] |
|
pp_node [Cil2cfg] |
|
pp_node_type [Cil2cfg] |
|
pp_object [Ctypes] |
|
pp_partial [Translate_prop.Create] |
|
pp_path [Funvar_mem.Create.Lookup] |
|
pp_pred [Formula.S] |
|
pp_pred [Fol_pretty.Create] |
|
pp_pred_atom [Fol_why] |
|
pp_pred_atom [Fol_pretty.Create] |
|
pp_pred_atom [Fol_ergo] |
|
pp_pred_atom [Fol_coq] |
|
pp_pred_debug [Fol_pretty.Create] |
|
pp_pred_vbox [Fol_pretty.Create] |
|
pp_prehint [Axiomatics] |
|
pp_presigma [Axiomatics] |
|
pp_prover [Wpo] |
|
pp_range [Region.Create] |
|
pp_region [Mwp.S] |
|
pp_region [Runtime_mem.Create] |
|
pp_region [Store_mem.Create] |
|
pp_region [Hoare_mem.Create] |
|
pp_region [Region.Create] |
|
pp_region [Funvar_mem.Create] |
|
pp_region [Caveat_mem.Make.WP] |
|
pp_result [Wpo] |
|
pp_sigma [Datalib.Create] |
|
pp_sigma [Axiomatics] |
|
pp_status [Prover.Log] |
|
pp_strategy_info [WpAnnot] |
|
pp_string_list [Wp_error] |
|
pp_tau [Fol_pretty.Create] |
|
pp_tau [Datalib.Tau] |
|
pp_term [Formula.S] |
|
pp_term [Fol_pretty.Create] |
|
pp_term [Caveat_fol.Data] |
|
pp_term [Caveat_fol] |
|
pp_term_opt [Caveat_fol] |
|
pp_title [Mdata.S.Identifiable] |
|
pp_title [Datalib.Create.Identifiable] |
|
pp_title [Datalib.Create.LTinfoId] |
|
pp_title [Datalib.Create.Logicvar] |
|
pp_title [Datalib.Create.LTypeinfo] |
|
pp_title [Datalib.Create.Arrayinfo] |
|
pp_title [Datalib.Create.Compinfo] |
|
pp_title [Datalib.Create.Fieldinfo] |
|
pp_title [Datalib.Create.Varaddr] |
|
pp_title [Datalib.Create.Varinfo] |
|
pp_token [Script] |
|
pp_typelist [Fol_coq] |
|
pp_userdef_descr [Translate_prop.Create.UserDefinition] |
|
pp_userdef_title [Translate_prop.Create.UserDefinition] |
|
pp_value [Mvalues.Values] |
|
pp_value [Datalib.Cvalues] |
|
pp_var [Formula.S] |
|
pp_var [Fol_pretty] |
|
pp_var [Fol_formula] |
|
pp_var [Fol_ergo] |
|
pp_var [Fol_coq] |
|
pp_var [Caveat_fol] |
|
pp_vars [CfgWeakestPrecondition.Create] |
|
pp_vkind [Datalib.Create] |
|
pp_warning [Wpo] |
|
pp_xzone [Runtime_mem.Create.Tint] |
|
preal_cmp [Translate_prop.Create] |
|
pred_alpha_cv [Fol] |
pred_alpha_c data_alpha alpha p -> alpha', p'
|
pred_closed [Formula.S] |
|
pred_closed [Fol_formula] |
|
pred_closed [Caveat_fol] |
|
pred_cmp [Translate_prop.Create] |
|
pred_e [Cil2cfg] |
|
pred_has_var [Formula.S] |
|
pred_has_var [Fol_formula] |
|
pred_has_var [Caveat_fol] |
|
pred_replace [Fol] |
|
predicate [CfgWeakestPrecondition.Create] |
|
predicate_kind_txt [WpAnnot] |
|
predop [Whylib.Create] |
|
prefix [Mdata.S.Identifiable] |
|
prefix [Datalib.Create.Identifiable] |
|
prefix [Datalib.Create.LTinfoId] |
|
prefix [Datalib.Create.Logicvar] |
|
prefix [Datalib.Create.LTypeinfo] |
|
prefix [Datalib.Create.Arrayinfo] |
|
prefix [Datalib.Create.Compinfo] |
|
prefix [Datalib.Create.Fieldinfo] |
|
prefix [Datalib.Create.Varaddr] |
|
prefix [Datalib.Create.Varinfo] |
|
prepare_annot [WpAnnot] |
|
prepare_behaviors_spec [WpAnnot] |
|
prepare_fct_post [WpAnnot] |
|
prepare_guard [Caveat_mem.Make.WP] |
|
prepare_inv_establish [WpAnnot] |
|
prepare_inv_fixpoint [WpAnnot] |
|
prepare_inv_preserve [WpAnnot] |
|
prepare_pre [WpAnnot] |
|
prepare_pre_pred [WpAnnot] |
|
prepare_stmt_spec_post [WpAnnot] |
|
prepare_var_decr [WpAnnot] |
|
prepare_var_pos [WpAnnot] |
|
preproc_annot [NormAtLabels] |
|
preproc_assigns [NormAtLabels] |
|
preproc_label [NormAtLabels] |
|
pretty [Mcfg.S] |
|
pretty [Datatype.Set] |
|
pretty [Ctypes] |
|
pretty [Clabels] |
|
pretty [Cil2cfg.EL] |
|
pretty [Cil2cfg.VL] |
|
pretty [Cfgpropid.Create] |
|
pretty [CfgWeakestPrecondition.Create] |
|
pretty_code [Datatype.Set] |
|
pretty_node [Cil2cfg.WeiMaoZouChenInput] |
|
pretty_node [Cil2cfg.LoopInfo] |
|
pretty_raw_stmt [Cil2cfg.Printer] |
|
process_global_init [Calculus.Cfg] |
WP of global initialisations.
|
process_unreached_annots [WpAnnot] |
Get the not yet proved properties of unreachable CFG nodes.
|
proj [Caveat_fol] |
|
promote [Ctypes] |
|
proof [Script] |
|
prop [Translate_prop.Create] |
prop e p interprets an ACSL predicate as a logic predicats
in memory model environment e .
|
prop [Translate_expr.Create] |
prop mem e interprets the expressione as a predicate
in memory mem *
|
prop_binop [Translate_expr.Create] |
|
prop_body [Translate_prop.Create] |
|
prop_cast [Translate_expr.Create] |
|
prop_cmp [Translate_expr.Create] |
|
prop_cmp_ptr [Translate_expr.Create] |
|
prop_const [Translate_expr.Create] |
|
prop_icmp [Translate_expr.Create] |
|
prop_main [WpAnnot] |
|
prop_of_float [Translate_expr.Create] |
|
prop_of_int [Translate_expr.Create] |
|
prop_of_integer [Translate_expr.Create] |
|
prop_of_ptr [Translate_expr.Create] |
|
prop_of_value [Translate_expr.Create] |
|
prop_rcmp [Translate_expr.Create] |
|
prop_rec [Translate_expr.Create] |
|
prop_txt [WpAnnot] |
generates an unique name for a given PO.
|
prop_unop [Translate_expr.Create] |
|
property [Wprop.Indexed] |
|
property [Wprop.Indexed2] |
|
property_of_id [WpAnnot] |
returns the annotation which lead to the given PO.
|
protect [Wp_error] |
|
protect_map [Wp_error] |
|
protect_translation [Wp_error] |
|
protect_translation3 [Wp_error] |
|
protect_translation4 [Wp_error] |
|
protect_translation5 [Wp_error] |
|
protect_warning [Wp_error] |
|
prove [Wpo] |
|
prove [Prover.Coqide] |
|
prove [Prover.Coq] |
|
prove [Prover.AltErgo] |
|
prove [Prover.SMT] |
|
prove [Prover] |
|
proved [WpAnnot] |
|
prover_names [Wp_parameters] |
|
prover_of_name [Wpo] |
|
ptr [Caveat_mem.Make.WP.CavLib] |
Used to specify the pointer data in which we can safely
ignore muI .
|
ptr_cmp [Translate_prop.Create] |
|
ptr_rel [Translate_prop.Create] |
|
push [Mdata.S] |
|
push [Datalib.Collector] |
|
push [Datalib.Create] |
|
push_context [Translate_prop.Create] |
|
push_instances [Translate_prop.Create] |
|
Q |
quant_env [Translate_prop.Create] |
|
quantify_at_label [Mwp.S] |
quantify_at_label frame l p quantifies the free variables in p
representing the state at label l to the current memory.
|
quantify_at_label [Runtime_mem.Create] |
|
quantify_at_label [Store_mem.Create] |
|
quantify_at_label [Hoare_mem.Create] |
|
quantify_at_label [Funvar_mem.Create] |
|
quantify_at_label [Caveat_mem.Make.WP] |
|
R |
r_bool [Whylib] |
|
r_op [Whylib] |
|
r_pred [Whylib] |
|
range [Region.Create] |
range b k n builds a region of length n starting at offset k
in the block of base b .
|
range_disjoint [Region.Create] |
|
range_empty [Region.Create] |
|
range_inf [Datalib.Create] |
|
range_subset [Region.Create] |
|
range_sup [Datalib.Create] |
|
rcontains_from [String] |
String.rcontains_from s stop c tests if character c
appears in s before position stop+1 .
|
real_cmp [Translate_prop.Create] |
|
real_format [Mdata.S] |
|
real_format [Datalib.Create] |
|
real_from_bits [Runtime_mem.Create] |
|
real_of_data [Translate_prop.Create] |
|
real_of_integer [Formula.S] |
|
real_of_integer [Whylib.Create] |
|
real_of_integer [Whylib] |
|
real_of_value [Translate_prop.Create] |
|
real_op [Translate_prop.Create] |
|
rec_apply_function [Translate_prop.Create] |
|
rec_apply_predicate [Translate_prop.Create] |
|
record_format [Mdata.S] |
|
record_format [Data_mem.Create] |
|
record_format [Datalib.Create] |
|
record_of_data [Translate_prop.Create] |
|
region [Store_mem.Create] |
|
region_assigned [Mwp.S] |
|
region_assigned [Runtime_mem.Create] |
|
region_assigned [Store_mem.Create] |
|
region_assigned [Hoare_mem.Create] |
|
region_assigned [Funvar_mem.Create] |
|
region_assigned [Caveat_mem.Make.WP] |
|
region_assigns [CfgWeakestPrecondition.Create] |
|
region_empty [Mwp.S] |
|
region_empty [Runtime_mem.Create] |
|
region_empty [Store_mem.Create] |
|
region_empty [Hoare_mem.Create] |
|
region_empty [Funvar_mem.Create] |
|
region_empty [Caveat_mem.Make.WP] |
|
region_fingerprint [Mwp.S] |
|
region_fingerprint [Runtime_mem.Create] |
|
region_fingerprint [Store_mem.Create] |
|
region_fingerprint [Hoare_mem.Create] |
|
region_fingerprint [Funvar_mem.Create] |
|
region_fingerprint [Caveat_mem.Make.WP] |
|
region_included [Mwp.S] |
|
region_included [Runtime_mem.Create] |
|
region_included [Store_mem.Create] |
|
region_included [Hoare_mem.Create] |
|
region_included [Funvar_mem.Create] |
|
region_included [CfgWeakestPrecondition.Create] |
|
region_included [Caveat_mem.Make.WP] |
|
region_of_loc [Store_mem.Create] |
|
region_range [Store_mem.Create] |
|
region_separated [Mwp.S] |
|
region_separated [Runtime_mem.Create] |
|
region_separated [Store_mem.Create] |
|
region_separated [Hoare_mem.Create] |
|
region_separated [Funvar_mem.Create] |
|
region_separated [Caveat_mem.Make.WP] |
|
region_supported [Mwp.S] |
|
region_supported [Runtime_mem.Create] |
|
region_supported [Store_mem.Create] |
|
region_supported [Hoare_mem.Create] |
|
region_supported [Funvar_mem.Create] |
|
region_supported [Caveat_mem.Make.WP] |
|
region_union [Mwp.S] |
|
region_union [Runtime_mem.Create] |
|
region_union [Store_mem.Create] |
|
region_union [Hoare_mem.Create] |
|
region_union [Funvar_mem.Create] |
|
region_union [Caveat_mem.Make.WP] |
|
register [Wpo] |
|
register [Po_navigator.Prover_Column] |
|
register_prefix [Datalib] |
|
rel_op [Translate_prop.Create] |
|
release_env [Wpo] |
Releases the last generated environment name.
|
remove [Mdata.S] |
remove s0 s1 returns a set s' such as {b in s' | b in s0
and !(b in s1) }.
|
remove [Wpo.Results] |
|
remove [State_builder.Dashtbl] |
|
remove [Map.S] |
remove x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
|
remove [State_builder.Hashtbl] |
|
remove [Hashtbl.S] |
|
remove [Set.S] |
remove x s returns a set containing all elements of s ,
except x .
|
remove [Datalib.Create] |
|
remove_all [State_builder.Dashtbl] |
|
remove_state [Dashtbl.Graph] |
|
rename [Datalib.Create] |
|
replace [Wpo.Results] |
|
replace [State_builder.Dashtbl] |
|
replace [Cil2cfg.HEsig] |
|
replace [State_builder.Hashtbl] |
Add a new binding.
|
replace [Cil2cfg.HE] |
|
replace [Hashtbl.S] |
|
reprs [Datatype.Set] |
|
require_env [Prover.Coq] |
|
require_model [Prover.Coq] |
|
require_wp [Prover.Coq] |
|
reserved_prefix_tbl [Datalib] |
|
reset [Wp_parameters] |
|
reset_pos [Cil2cfg.WeiMaoZouChenInput] |
reset the position (set the position to 0), but should keep the
information that the node has been seen already.
|
reset_pos [Cil2cfg.LoopInfo] |
|
resetdemon [Wp_parameters] |
|
result [Mlogic.S] |
result e returns the variable associates to
the function result in the environment e .
|
result [Runtime_mem.Create] |
|
result [Store_mem.Create] |
|
result [Prover] |
|
result [Hoare_mem.Create] |
|
result [Funvar_mem.Create] |
|
result [Caveat_mem.Make.WP] |
|
result_compile [Prover.Coq] |
|
return [Mcfg.S] |
|
return [Cfgpropid.Create] |
|
return [CfgWeakestPrecondition.Create] |
|
reverse [Datalib.Create] |
|
rindex [String] |
String.rindex s c returns the character number of the last
occurrence of character c in string s .
|
rindex_from [String] |
String.rindex_from s i c returns the character number of the
last occurrence of character c in string s before position i+1 .
|
root [Region.Create] |
Create a fresh root, separated from base address of all
variables.
|
roots [Region.Create] |
|
round [Mdata.S] |
|
round [Datalib.Create] |
|
rt_fformat [Runtime_mem.Create.RtLib] |
|
rt_format_of_ctype [Runtime_mem.Create] |
|
rt_global [Runtime_mem.Create.RtLib] |
|
rt_gsize [Runtime_mem.Create.RtLib] |
|
rt_vformat [Runtime_mem.Create.RtLib] |
|
rte_generated [WpAnnot] |
|
rte_wp [WpAnnot] |
|
run [Register] |
Use options to know what to do
|
run_and_prove [Wp_gui] |
|
run_coqide [Prover.Coqide] |
|
S |
s_index [Datalib.Create] |
|
saturate [Translate_prop.Create] |
|
savescripts [Proof] |
If necessary, dump the scripts database into the file
specified by -wp-script f .
|
scope [Mcfg.S] |
|
scope [Cfgpropid.Create] |
|
scope [CfgWeakestPrecondition.Create] |
|
script_for [Prover.Coq] |
|
scriptbase [Proof] |
|
scriptfile [Proof] |
|
scriptmodified [Proof] |
|
section [Mdata.S.Declarator] |
|
section [Datalib.Create.Declarator] |
|
selector [Wp_gui] |
|
self [Dashtbl.Graph] |
|
separated [Mlogic.S] |
|
separated [Runtime_mem.Create] |
|
separated [Store_mem.Create] |
|
separated [Hoare_mem.Create] |
|
separated [Region.Create] |
|
separated [Funvar_mem.Create] |
|
separated [Hoare_lib.Create.Hlib] |
|
separated [Caveat_mem.Make.WP] |
|
separated_bases [Region.Create] |
|
separated_bases_others [Region.Create] |
|
separated_cvars [Region.Create] |
|
separated_find [Region.Create] |
|
separated_others_bases [Region.Create] |
|
separated_ranges [Region.Create] |
|
separated_roots [Region.Create] |
|
server [Prover] |
|
set [String] |
String.set s n c modifies string s in place,
replacing the character number n by c .
|
set [Properties_status.Make_updater] |
Set the status of an annotation.
|
set [State_builder.Ref] |
Change the referenced value.
|
set [Calculus.Cfg.R] |
store the result p for the computation of the edge e.
|
set_addr_taken [Vaddr] |
|
set_back_edge [Cil2cfg] |
|
set_checked [Wprop.Updater] |
|
set_exit_status [Mlogic.S] |
|
set_exit_status [Runtime_mem.Create] |
|
set_exit_status [Store_mem.Create] |
|
set_exit_status [Hoare_mem.Create] |
|
set_exit_status [Funvar_mem.Create] |
|
set_exit_status [Caveat_mem.Make.WP] |
|
set_iloop_header [Cil2cfg.WeiMaoZouChenInput] |
set_iloop_header env b h store h as the innermost loop header for b.
|
set_iloop_header [Cil2cfg.LoopInfo] |
|
set_model [Wp_error] |
|
set_of [Translate_prop.Create] |
|
set_of_list [Mdata.S] |
|
set_of_list [Datalib.Create] |
|
set_po_result [Wpo] |
|
set_pos [Cil2cfg.WeiMaoZouChenInput] |
store the position for the node and also the fact that the node has
been seen
|
set_pos [Cil2cfg.LoopInfo] |
|
set_proxy [Wprop.Indexed] |
|
set_range_index [Mdata.S] |
|
set_range_index [Datalib] |
|
set_range_index [Datalib.Create] |
|
set_result [Wpo] |
|
set_unknown [Wprop.Updater] |
|
set_unreachable [WpAnnot] |
|
shared [CfgProof.Description] |
Shared resource basename for the model
|
shift [Mvalues.S] |
shift ptr tau k computes the location
of ptr+k , where ptr is a pointer to a value of type tau .
|
shift [Runtime_mem.Create.Data] |
|
shift [Store_mem.Create.Data] |
|
shift [Hoare_mem.Create] |
|
shift [Funvar_mem.Create] |
|
shift [Caveat_mem.Make.WP] |
|
shift_epath [Caveat_fol] |
|
shift_field [Runtime_mem.Create.Tint] |
|
shift_field [Hoare_lib.Create.Hlib] |
|
shift_field [Caveat_fol] |
|
shift_index [Hoare_lib.Create.Hlib] |
|
shift_index [Caveat_fol] |
|
shift_loc [Translate_expr.Create] |
|
shift_n_elem [Runtime_mem.Create.Tint] |
|
shift_pointer [Hoare_lib.Create.Hlib] |
|
shift_pointer [Caveat_fol] |
|
shift_ufield [Hoare_lib.Create.Hlib] |
|
show_cfg [Wp_gui] |
|
signed [Ctypes] |
true if ikind is signed
|
simpl [Fol] |
|
simplify [Prover.SMT] |
|
singleton [Mdata.S] |
singleton a returns the singleton set containning a .
|
singleton [Set.S] |
singleton x returns the one-element set containing only x .
|
singleton [Datalib.Create] |
|
size [Wprop.Info] |
|
size_of_int [Runtime_mem.Create.Tint] |
|
size_of_int64 [Runtime_mem.Create.Tint] |
|
sizeof [Store_mem.Create] |
|
sizeof [Region.Create] |
|
sizeof_c_object [Runtime_mem.Create] |
|
sizeof_object [Ctypes] |
|
skip [Script] |
|
some_alpha [Datalib.Create] |
|
split [Mcfg.Splitter] |
|
split [WpAnnot] |
|
split [Fol_split] |
First, unfold zones when method is effect-assigns.
|
split [Caveat_mem.Make.Splitter] |
|
split [Set.S] |
split x s returns a triple (l, present, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
present is false if s contains no element equal to x ,
or true if s contains an element equal to x .
|
stack [Datalib.Collector] |
|
start_edge [Cil2cfg] |
get the starting edges
|
start_stmt_of_node [Cil2cfg] |
|
startof [Mvalues.S] |
startof return a pointer to the first element of an array
|
startof [Runtime_mem.Create] |
|
startof [Store_mem.Create] |
|
startof [Hoare_mem.Create] |
|
startof [Funvar_mem.Create] |
|
startof [Translate_expr.Create] |
|
startof [Caveat_mem.Make.WP] |
|
state [Wprop.Indexed] |
|
state [Wprop.Indexed2] |
|
state_name [Wprop.Info] |
|
state_proxy [Wprop.Info] |
|
status [Prover.Log] |
|
store [Runtime_mem.Create.RtLib] |
|
store [Runtime_mem.Create] |
|
store [Funvar_mem.Create] |
|
store_mem [Mvalues.Data] |
|
store_mem [Runtime_mem.Create.Data] |
|
store_mem [Store_mem.Create.Data] |
|
store_mem [Store_mem.Create] |
|
store_rec [Store_mem.Create.Data] |
|
store_with [Store_mem.Create] |
|
stored [Data_mem.Create] |
|
string_of_termination_kind [WpAnnot] |
|
sub [Runtime_mem.Create.Aint] |
|
sub [Store_mem.Create] |
|
sub [String] |
String.sub s start len returns a fresh string of length len ,
containing the substring of s that starts at position start and
has length len .
|
sub [Datalib.Create] |
|
sub_c_float [Ctypes] |
|
sub_c_int [Ctypes] |
|
sub_int [Whylib] |
|
sub_real [Whylib] |
|
subproof_idx [WpAnnot] |
|
subproofs [WpAnnot] |
|
subset [Set.S] |
subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subst [Mdata.S] |
|
subst [Hoare_mem.Create] |
|
subst [Datalib.Create] |
|
subst [Caveat_mem.Make.WP] |
|
subst_data_in_pred [Caveat_fol] |
|
subst_havoc [Mwp.S] |
Binds the free variables in
the wp representing the memory locations that live in zone .
|
subst_havoc [Runtime_mem.Create] |
|
subst_havoc [Store_mem.Create] |
|
subst_havoc [Hoare_mem.Create] |
Compute the WP for the predicate p of something that modifies
only the assigned locations out_locs .
|
subst_havoc [Funvar_mem.Create] |
|
subst_havoc [Caveat_mem.Make.WP] |
|
subst_in_bindings [Datalib.Create] |
|
subst_in_pred [Fol] |
Specialized version of subst_vars_in_pred to substitute one variable v
by and expression exp in a predicate p .
|
subst_lval [Mwp.S] |
subst_lval frame l te v p binds in p the free variables
representing the value at location l in the current memory to
the actual value v .
|
subst_lval [Runtime_mem.Create] |
|
subst_lval [Store_mem.Create] |
|
subst_lval [Hoare_mem.Create] |
|
subst_lval [Funvar_mem.Create] |
|
subst_lval [Caveat_mem.Make.WP] |
|
subst_result [Mwp.S] |
subst_result frame v p bind the free variable representing
\result in to an actual value.
|
subst_result [Runtime_mem.Create] |
|
subst_result [Store_mem.Create] |
|
subst_result [Hoare_mem.Create] |
|
subst_result [Funvar_mem.Create] |
|
subst_result [Caveat_mem.Make.WP] |
|
subst_vars_in_pred [Fol] |
Similar to change_vars_in_exp but on predicates.
|
succ_e [Cil2cfg] |
|
suitable [Proof] |
|
switch [Mcfg.S] |
|
switch [Cfgpropid.Create] |
merge the switch branches :
|
switch [CfgWeakestPrecondition.Create] |
|
system [Wpo] |
|
T |
t_alloc [Runtime_mem.Create] |
|
t_alloc [Store_mem.Create] |
|
t_mbits [Runtime_mem.Create] |
|
t_mem [Runtime_mem.Create] |
|
t_memory [Store_mem.Create] |
|
t_of_l [Caveat_mem.Make.Export] |
|
target [WpAnnot] |
|
task_for [Prover] |
|
tau_of_ctype [Mdata.S] |
|
tau_of_ctype [Datalib.Create] |
|
tau_of_dzone [Mwp.S] |
|
tau_of_dzone [Runtime_mem.Create] |
|
tau_of_dzone [Store_mem.Create] |
|
tau_of_dzone [Hoare_mem.Create] |
|
tau_of_dzone [Funvar_mem.Create] |
|
tau_of_dzone [Caveat_mem.Make.WP] |
|
tau_of_logic_ctype [Datalib.Tau] |
|
tau_of_logic_type [Mdata.S] |
|
tau_of_logic_type [Datalib.Create] |
|
tau_of_mem [Mvalues.Data] |
|
tau_of_mem [Runtime_mem.Create.Data] |
|
tau_of_mem [Store_mem.Create.Data] |
|
tau_of_object [Mdata.S] |
|
tau_of_object [Datalib.Create] |
|
tau_of_var [Formula.S] |
|
tau_of_var [Fol_gformula.Pool] |
|
tau_of_var [Caveat_fol] |
|
tbits_of_var [Runtime_mem.Create] |
|
tcomp_of_comp [Runtime_mem.Create] |
|
term [Translate_prop.Create] |
term e t interprets the C terms t in memory model environment e
as a logic term.*
|
term_alpha_cv [Fol] |
|
term_closed [Formula.S] |
|
term_closed [Fol_formula] |
|
term_closed [Caveat_fol] |
|
term_has_var [Formula.S] |
|
term_has_var [Fol_formula] |
|
term_has_var [Caveat_fol] |
|
term_load [Hoare_mem.Create] |
|
term_of_data [Translate_prop.Create] |
|
term_of_data [Caveat_fol] |
|
term_of_var [Caveat_fol] |
|
term_of_xaddr [Runtime_mem.Create.Tint] |
|
term_of_xsize [Runtime_mem.Create.Tint] |
|
term_of_xzone [Runtime_mem.Create.Tint] |
|
term_opt_has_var [Caveat_fol] |
|
term_replace [Fol] |
This one doesn't know how to substitute in data ,
so it builds a let if needed.
|
term_such_that [Mdata.S] |
|
term_such_that [Datalib.Create] |
|
terms_alpha_cv [Fol] |
|
test [Mcfg.S] |
|
test [Cfgpropid.Create] |
|
test [CfgWeakestPrecondition.Create] |
|
tmp [Prover.Tmp] |
|
tmp_dir [Wp_parameters] |
|
to_bits [Runtime_mem.Create.RtLib] |
|
to_term [Runtime_mem.Create.Aint] |
|
toffset_of_field [Runtime_mem.Create.Tint] |
|
token [Script] |
|
top_loc_term [Caveat_mem.Make.WP] |
|
translate [Prover.SMT] |
|
translate_assigned [CfgWeakestPrecondition.Create] |
|
translate_assigned_targets [CfgWeakestPrecondition.Create] |
|
translate_data_in_pred [Fol] |
translate_data_in_pred do_data pred
|
translate_data_in_term [Fol] |
translate_data_in_term do_data exp
|
translate_pred_in_decl [Fol] |
translate_pred_in_decl do_pred item
|
translate_pred_in_item [Fol] |
translate_pred_in_item do_pred item
|
tsize_of_field [Runtime_mem.Create.Tint] |
|
ty [Datatype.Set] |
|
typ_of_elements [Translate_prop.Create] |
|
typeOf_array_elem [Translate_expr.Create] |
|
U |
uncapitalize [String] |
Return a copy of the argument, with the first character set to lowercase.
|
union [Mdata.S] |
union s0 s1 returns the union set of s0 and s1 .
|
union [Region.Create.Merge] |
|
union [Region.Create] |
Union of arbitrary regions
|
union [Set.S] |
Set union.
|
union [Datalib.Create] |
|
union_data [Translate_prop.Create] |
|
union_map [Translate_prop.Create] |
|
union_range [Region.Create] |
|
unions [Mdata.S] |
|
unions [Datalib.Create] |
|
unlet [Fol_cc] |
|
unlet_pred [Fol_cc] |
|
unlet_term [Fol_cc] |
|
unop [Whylib.Create] |
|
unstructuredness [Cil2cfg.LoopInfo] |
|
unsupported [Wp_error] |
|
unsupported [Runtime_mem] |
|
unsupported [Store_mem.Create] |
|
unsupported [Hoare_mem.Create] |
|
unsupported [Caveat_mem] |
|
unsupported [Caveat_fol] |
|
unwrap [Formula.Vernacular] |
|
unwrap [Fol_gformula.Langage] |
|
upd_field [Mdata.S] |
Takes a record term of type (tau_of F.fcomp) and
a new term of type (tau_of F) for its field 'F'
and return the updated record.
|
upd_field [Datalib.Create] |
|
upd_index [Mdata.S] |
|
upd_index [Datalib.Create] |
|
update [Funvar_mem.Create] |
|
update [Properties_status.Make_updater] |
Update the status of a given annotation according to the old
status.
|
update_at_label [Mwp.S] |
update_at_label frame l p binds free variables in p representing
the state at label l to the current memory.
|
update_at_label [Runtime_mem.Create] |
|
update_at_label [Store_mem.Create] |
|
update_at_label [Hoare_mem.Create] |
|
update_at_label [Funvar_mem.Create] |
|
update_at_label [Caveat_mem.Make.WP] |
Substitute the variables that represent values at label by the
variables that represent values at Here .
|
updater [CfgProof.Description] |
Unique name for the internal updater
|
updaters [Wpo] |
|
uppercase [String] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
|
urecord_format [Mdata.S] |
|
urecord_format [Datalib.Create] |
|
urecord_of_data [Translate_prop.Create] |
|
use_assigns [Mcfg.S] |
|
use_assigns [Cfgpropid.Create] |
|
use_assigns [CfgWeakestPrecondition.Create] |
|
user_axiomdefs [Translate_prop.Create] |
|
user_axioms [Translate_prop.Create] |
|
user_definitions [Translate_prop.Create] |
|
user_env [Translate_prop.Create] |
|
user_prop_names [WpAnnot] |
|
user_variables [Translate_prop.Create] |
|
userdef_closure [Mlogic.S] |
|
userdef_closure [Runtime_mem.Create] |
|
userdef_closure [Store_mem.Create] |
|
userdef_closure [Hoare_mem.Create] |
|
userdef_closure [Funvar_mem.Create] |
|
userdef_closure [Caveat_mem.Make.WP] |
|
userdef_frame [Mlogic.S] |
|
userdef_frame [Runtime_mem.Create] |
|
userdef_frame [Store_mem.Create] |
|
userdef_frame [Hoare_mem.Create] |
|
userdef_frame [Funvar_mem.Create] |
|
userdef_frame [Caveat_mem.Make.WP] |
|
userdef_fun_closure [Funvar_mem.Create] |
|
userdef_fun_signature [Funvar_mem.Create] |
|
userdef_signature [Mlogic.S] |
|
userdef_signature [Runtime_mem.Create] |
|
userdef_signature [Store_mem.Create] |
|
userdef_signature [Hoare_mem.Create] |
|
userdef_signature [Funvar_mem.Create] |
|
userdef_signature [Caveat_mem.Make.WP] |
|
uterm_of_data [Caveat_mem.Make.Export] |
|
V |
val_of [Fol] |
|
valid [Mlogic.S] |
|
valid [Runtime_mem.Create.RtLib] |
|
valid [Runtime_mem.Create] |
|
valid [Store_mem.Create] |
|
valid [Prover.AltErgo] |
|
valid [Hoare_mem.Create] |
|
valid [Funvar_mem.Create] |
|
valid [Caveat_mem.Make.WP] |
|
valid_pointer [Hoare_lib.Create.Hlib] |
|
valid_range [Hoare_lib.Create.Hlib] |
|
valid_txt [WpAnnot] |
|
valloc_of_mem [Runtime_mem.Create] |
|
value_of_bits [Runtime_mem.Create.Data] |
|
value_of_bits [Runtime_mem.Create] |
Compute the logic value from bits interpreted with type t .
|
value_of_boolean [Translate_expr.Create] |
|
value_of_integer [Translate_expr.Create] |
|
value_of_logic [Mvalues.Values] |
|
value_of_logic [Datalib.Cvalues] |
|
value_of_mvalue [Funvar_mem.Create] |
|
var [Formula.S] |
|
var [Fol_gformula.Pool] |
|
var [Caveat_fol] |
for Formula signature
|
var_counter [Fol.Var] |
|
var_data [Caveat_mem.Make.WP] |
|
var_data_term [Caveat_mem.Make.WP] |
|
var_name [Fol.Var] |
|
var_type [Fol.Var] |
|
varinfo_of_xaddr [Runtime_mem.Create.Tint] |
|
varmem_at [Store_mem.Create] |
|
varname [Datatype.Set] |
|
vbits_of_mem [Runtime_mem.Create] |
|
vertex_attributes [Cil2cfg.Printer] |
|
vertex_name [Cil2cfg.Printer] |
|
visit_data_in_pred [Caveat_fol] |
use to collect things about data: call do_data on each data node of e
and recursively inside the data.
|
visit_exp_in_data [Caveat_fol] |
do_sub_data is a function applied to each sub-data of d (NOT on d ).
|
visit_path [Caveat_fol] |
|
vkind_of_var [Mdata.S] |
|
vkind_of_var [Datalib.Create] |
|
W |
warning [Wp_parameters] |
|
why [Wpo] |
|
whydp [Prover.SMT] |
|
wp_call [Calculus.Cfg] |
|
wp_cfg_dot [Register] |
|
wp_compute [Register] |
|
wp_dir [Wp_gui] |
|
wp_generation [Wp_parameters] |
|
wp_loop [Calculus.Cfg.R] |
Compute the result for edge e which goes to the loop node nloop .
|
wp_model [Register] |
|
wp_model [Wp_parameters] |
|
wp_model_menu [Wp_gui] |
|
wp_panel [Wp_gui] |
|
wp_po [Wp_parameters] |
|
wp_prover [Wp_parameters] |
|
wp_prover_get [Wp_gui] |
|
wp_prover_menu [Wp_gui] |
|
wp_prover_set [Wp_gui] |
|
wp_scope [Calculus.Cfg] |
|
wp_script [Wp_gui] |
|
wp_stmt [Calculus.Cfg] |
|
wp_strategy [Wp_parameters] |
|
wrap [Formula.Vernacular] |
|
wrap [Fol_gformula.Langage] |
|
X |
xaddr_of_gvar [Runtime_mem.Create.Tint] |
|
xaddr_of_integer [Runtime_mem.Create.Tint] |
|
xaddr_of_pointer [Runtime_mem.Create.Tint] |
|
xaddr_of_var [Runtime_mem.Create.Tint] |
|
xsize_of_range [Runtime_mem.Create.Tint] |
|
xvar_of_varinfo [Translate_prop.Create] |
|
xzone_assigned [Runtime_mem.Create] |
|
xzone_disj [Runtime_mem.Create.Tint] |
|
xzone_of_var [Runtime_mem.Create.Tint] |
|
Y |
yices [Prover.SMT] |
|
Z |
z3 [Prover.SMT] |
|
z_from_bits [Runtime_mem.Create] |
|
zenon [Prover.SMT] |
|
zero [Store_mem.Create] |
|
zip [CfgWeakestPrecondition.Create] |
|
zone [Region.Create] |
|
zone_of_assignable [Store_mem.Create] |
|
zrange [Store_mem.Create] |
|
zs_empty [Runtime_mem.Create.RtLib] |
|
zs_incl [Runtime_mem.Create.RtLib] |
|
zs_singleton [Runtime_mem.Create.RtLib] |
|
zs_union [Runtime_mem.Create.RtLib] |
|
zunion [Fol_split] |
|