|
(&&&) [Register] |
|
__ocaml_lex_comment_rec [Script] |
|
__ocaml_lex_proof_rec [Script] |
|
__ocaml_lex_tables [Script] |
|
__ocaml_lex_token_rec [Script] |
|
A |
a_false [LogicLang] |
|
a_false [Fol_formula] |
|
a_of_data [Store_mem.Create] |
|
a_true [LogicLang] |
|
a_true [Fol_formula] |
|
acc_field [Formula.S] |
Takes a record term of type (tau_of F.fcomp) and
returns the term of type (tau_of F) for its field 'F'
|
acc_field [Fol_formula] |
|
acc_index [Formula.S] |
Takes term of type 'a farray and returns the 'a at index i .
|
acc_index [Fol_formula] |
|
access [LogicHavoc] |
|
access [Funvar_mem.Create.Lookup] |
|
access_poffset [Funvar_mem.Create.Lookup] |
|
active_lgg [CfgProof.Create] |
|
add [Runtime_mem.Create.Aint] |
|
add [Map.S] |
add x y m returns a map containing the same bindings as
m , plus a binding of x to y .
|
add [Hashtbl.S] |
|
add [Wpo] |
|
add [Cil2cfg.HEsig] |
|
add [Cil2cfg.HE] |
|
add [Set.S] |
add x s returns a set containing all elements of s ,
plus x .
|
add [State_builder.Hashtbl] |
Add a new binding.
|
add_all_axioms [WpStrategy] |
|
add_array_reference_arg [Variables_analysis] |
|
add_array_reference_param [Variables_analysis] |
|
add_assigns [Mcfg.S] |
|
add_assigns [CfgWeakestPrecondition.Create] |
|
add_assigns [Cfgpropid.Create] |
|
add_assigns [WpStrategy] |
generic function to add an assigns property.
|
add_assigns_any [WpStrategy] |
generic function to add a WriteAny assigns property.
|
add_assigns_goal [Calculus.Cfg] |
|
add_assigns_hyp [Calculus.Cfg] |
|
add_axiom [Mcfg.S] |
|
add_axiom [CfgWeakestPrecondition.Create] |
|
add_axiom [Cfgpropid.Create] |
|
add_axiom [Calculus.Cfg] |
|
add_axiom [Translate_prop.Create] |
Compile an axiom and add it to the list of global declarations.
|
add_axiom [Data_mem.Create.Compound] |
|
add_axiom [WpStrategy] |
|
add_behaviors_props [WpAnnot] |
|
add_call_assigns_hyp [WpFroms] |
|
add_call_assigns_hyp [WpStrategy] |
shortcut to add a call assigns property as an hypothesis.
|
add_call_hyp [Calculus.Cfg] |
|
add_called_post [WpAnnot] |
|
add_called_pre [WpAnnot] |
|
add_complete_behaviors_props [WpAnnot] |
|
add_cycle [LogicDef.Cofix] |
|
add_declaration [Formula.S] |
|
add_declaration [Fol_formula] |
|
add_depend [Datalib.Collector] |
|
add_depend_field [LogicDef] |
|
add_depend_pred [LogicLang] |
|
add_depend_tau [LogicLang] |
|
add_depend_term [LogicLang] |
|
add_depend_var [LogicDef] |
|
add_dependencies [CfgWeakestPrecondition.Create] |
|
add_disjoint_behaviors_props [WpAnnot] |
|
add_edge [Cil2cfg] |
|
add_edges_before [Cil2cfg] |
|
add_effect_assigns [CfgWeakestPrecondition.Create] |
|
add_fct_assigns_goal [WpAnnot] |
|
add_fct_bhv_assigns_hyp [WpStrategy] |
|
add_fct_pre [WpAnnot] |
|
add_field [Funvar_mem.Create] |
|
add_file [Prover.Logs] |
|
add_global_annotations [WpAnnot] |
|
add_goal [Mcfg.S] |
|
add_goal [CfgProof.Create] |
|
add_goal [CfgWeakestPrecondition.Create] |
|
add_goal [Cfgpropid.Create] |
|
add_goal [Calculus.Cfg] |
|
add_hook [Wprop.Indexed2] |
|
add_hook [Wprop.Indexed] |
|
add_hyp [Mcfg.S] |
|
add_hyp [CfgWeakestPrecondition.Create] |
|
add_hyp [Cfgpropid.Create] |
|
add_hyp [Calculus.Cfg] |
|
add_index [Funvar_mem.Create] |
|
add_int [Fol_decl] |
|
add_int_format_hyp [Runtime_mem.Create] |
|
add_integer [Translate_prop.Create] |
|
add_irreducible [Cil2cfg.WeiMaoZouChenInput] |
store the node as an irreducible loop header.
|
add_irreducible [Cil2cfg.LoopInfo] |
|
add_logic_vars [Translate_prop.Create] |
|
add_logics_value [Variables_analysis] |
|
add_loop_annots [WpStrategy] |
|
add_loop_assigns_goal [WpAnnot] |
|
add_loop_assigns_hyp [WpFroms] |
|
add_loop_assigns_hyp [WpStrategy] |
shortcut to add a loop assigns property as an hypothesis.
|
add_loop_header [Cil2cfg.WeiMaoZouChenInput] |
store the node as a loop header.
|
add_loop_header [Cil2cfg.LoopInfo] |
|
add_loop_invariant_annot [WpAnnot] |
|
add_memo [Calculus.Cfg.R] |
|
add_node [Cil2cfg] |
|
add_node_annots [WpStrategy] |
add_node_annots cfg annots v (before, (after, exits))
add the annotations for the node :
|
add_normal_assigns [CfgWeakestPrecondition.Create] |
|
add_oblig [Calculus.Cfg.R] |
|
add_offset [Hoare_mem.Create] |
|
add_offset [Store_mem.Create] |
|
add_on_edges [WpStrategy] |
|
add_proof [WpAnnot] |
accumulate int the proof the partial proof for this prop_id
|
add_prop [WpStrategy] |
generic function to add a predicate property after normalisation.
|
add_prop_assert [WpStrategy] |
|
add_prop_call_post [WpStrategy] |
Add a postcondition of a called function.
|
add_prop_call_pre [WpStrategy] |
|
add_prop_fct_bhv_pre [WpStrategy] |
Add the preconditions of the behavior :
if impl_assumes , add b_assumes => b_requires
else add both the b_requires and the b_assumes
|
add_prop_fct_post [WpStrategy] |
|
add_prop_fct_pre [WpStrategy] |
Add the predicate as a function precondition.
|
add_prop_inv_establish [WpAnnot] |
|
add_prop_inv_fixpoint [WpAnnot] |
|
add_prop_inv_preserve [WpAnnot] |
|
add_prop_loop_inv [WpStrategy] |
|
add_prop_stmt_bhv_requires [WpStrategy] |
Add all the b_requires .
|
add_prop_stmt_post [WpStrategy] |
Add the predicate as a stmt precondition.
|
add_prop_stmt_pre [WpStrategy] |
Add the predicate as a stmt precondition.
|
add_prop_stmt_spec_pre [WpStrategy] |
Process the stmt spec precondition as an hypothesis for external properties.
|
add_ptr_reference_arg [Variables_analysis] |
|
add_ptr_reference_param [Variables_analysis] |
|
add_real [Fol_decl] |
|
add_reentry_edge [Cil2cfg.WeiMaoZouChenInput] |
store the edge between the two nodes (n1, n2) as a reentry edge.
|
add_reentry_edge [Cil2cfg.LoopInfo] |
|
add_requires [Variables_analysis] |
|
add_rte_menu [Wp_gui] |
|
add_script [Proof] |
new_script goal keys proof registers the script proof for goal goal
and keywords keys
|
add_set [Formula.S] |
|
add_set [Fol_formula] |
|
add_spec_annots [WpFroms] |
|
add_stmt_assigns_goal [WpAnnot] |
|
add_stmt_bhv_as_goal [WpAnnot] |
we want to prove this behavior: add the requires as preconditions to both prove and use as hyp,, add the assumes as hypotheses,, add the postconditions as goals.
|
add_stmt_invariant_annot [WpAnnot] |
|
add_stmt_spec_annots [WpAnnot] |
|
add_stmt_spec_assigns_hyp [WpFroms] |
|
add_stmt_spec_assigns_hyp [WpStrategy] |
shortcut to add a stmt spec assigns property as an hypothesis.
|
add_stmt_spec_post_as_hyp [WpAnnot] |
Add the post condition of the whole spec as hypothesis.
|
add_terminates [WpAnnot] |
|
add_variant [WpAnnot] |
|
add_variant_annot [WpAnnot] |
|
add_warning [Datalib.Collector] |
When adding a warning, one has to provide : the source of the warning (for instance "model M"),, the effect of the warning (for instance "stop computation"), and a formated message about why this warning is emited.
|
add_wp_menu [Wp_gui] |
|
addr [CfgWeakestPrecondition.Create] |
|
addr [Translate_expr.Create] |
addr mem lv interprets the left value lv as
an address (memory location) in the memory mem .*
|
addr [Store_mem.Create.Model] |
|
addr_of_assignable [Store_mem.Create] |
|
addr_of_data [Store_mem.Create] |
|
addr_of_ref [Translate_prop.Create] |
|
adt_decl [Formula.S] |
|
adt_decl [Fol_formula] |
|
all_filter [Translate_prop.Create] |
|
all_stable [LogicDef.Cofix] |
|
alloc [Hoare_mem.Create] |
|
alloc [Runtime_mem.Create.RtLib] |
|
alloc_vars [Hoare_mem.Create] |
|
alloc_vars [Store_mem.Create] |
|
allocator [LogicId] |
|
alpha [Formula.Logic] |
|
alpha [LogicId] |
User-friendly name sorting.
|
alpha [Fol_eqs] |
|
alpha [Fol_let] |
|
alpha [Datalib.Create] |
|
alpha_bound_var [Fol] |
|
alpha_unbound [Fol] |
|
altergo [Prover.SMT] |
|
annot_for_asked_bhv [WpFroms] |
|
apply [Hook.S] |
Apply all the functions of the hook on the given parameter.
|
apply [Formula.Logic] |
|
apply [Fol_formula] |
|
apply [Datalib.Create] |
|
apply_alpha [Fol] |
|
apply_formals [Translate_prop.Create] |
|
apply_function [Translate_prop.Create] |
|
apply_labels [LogicPretty] |
|
apply_predicate [Translate_prop.Create] |
|
apply_references [Translate_prop.Create] |
|
array [LogicHavoc] |
|
array_dim [Ctypes] |
|
array_format [Data_mem.Create] |
|
array_of [Funvar_mem.Create] |
|
array_of_data [Translate_prop.Create] |
|
array_reference [Variables_analysis] |
|
as_int [Fol] |
|
as_int_format [Fol] |
|
assign [Mcfg.S] |
|
assign [CfgWeakestPrecondition.Create] |
|
assign [Cfgpropid.Create] |
|
assignable [Store_mem.Create] |
|
assignable_loc [Store_mem.Create] |
|
assignable_range [Store_mem.Create] |
|
assignable_sizeof [Store_mem.Create] |
|
assigned [Translate_prop.Create] |
Compiles an arbitrary term representing a set of left-values into a zone
|
assigned_for_assigns_goal [CfgWeakestPrecondition.Create] |
|
assigned_of_assigns [CfgWeakestPrecondition.Create] |
|
assigned_of_data [Translate_prop.Create] |
|
assigns_goal [Mwp.S] |
|
assigns_goal [Hoare_mem.Create] |
|
assigns_goal [Store_mem.Create] |
|
assigns_goal [Runtime_mem.Create] |
|
assigns_goal [Funvar_mem.Create] |
|
assigns_info_id [WpPropId] |
|
assigns_method [Mcfg.S] |
|
assigns_method [CfgProof.Create] |
|
assigns_method [CfgWeakestPrecondition.Create] |
|
assigns_method [Cfgpropid.Create] |
|
assigns_supported [Mwp.S] |
|
assigns_supported [Hoare_mem.Create] |
|
assigns_supported [Store_mem.Create] |
|
assigns_supported [Runtime_mem.Create] |
|
assigns_supported [Funvar_mem.Create] |
|
assigns_upper_bound [WpStrategy] |
|
associative [LogicPretty] |
|
axiom_env [Translate_prop.Create] |
|
B |
bar [Wpo] |
|
base [Hoare_mem.Create.Model] |
|
base [Store_mem.Create.Model] |
|
base [Runtime_mem.Create.Tint] |
|
base_address [Mlogic.S] |
base_address m l return the base address of l .
|
base_address [Hoare_mem.Create] |
|
base_address [Store_mem.Create] |
|
base_address [Runtime_mem.Create] |
|
base_address [Funvar_mem.Create] |
|
basename [Formula.S.Identifiable] |
|
basename [LogicLib] |
|
basename [LogicRaw.VAR] |
|
basename [LogicId] |
|
basename [Fol_formula.Identifiable] |
|
basename [Fol_formula.LTinfoId] |
|
basename [Fol_formula.ArrayDim] |
|
basename [Fol_formula.Cobject] |
|
basename [Fol_formula.Logicvar] |
|
basename [Fol_formula.LTypeinfo] |
|
basename [Fol_formula.Arrayinfo] |
|
basename [Fol_formula.Compinfo] |
|
basename [Fol_formula.Fieldinfo] |
|
basename [Fol_formula.Varinfo] |
|
basename [Fol.Var] |
|
basename [Ctypes] |
|
basename_of_var [Formula.S] |
|
basename_of_var [Fol_formula] |
|
basetype [Ctypes] |
|
behavior_name_of_config [WpAnnot] |
|
behavior_name_of_strategy [WpStrategy] |
|
bhv_from_hyps [WpFroms] |
|
bind [Fol_let] |
|
bind_formals [Translate_prop.Create] |
|
bind_fresh [Translate_prop.Create] |
|
bind_lvar [Translate_prop.Create] |
|
bind_lvars [Translate_prop.Create] |
|
bindings [Map.S] |
Return the list of all bindings of the given map.
|
binop [LogicLang] |
|
binop [Fol_formula] |
|
bits_and [Mint.S] |
|
bits_and [Mint_natural.Create] |
|
bits_lshift [Mint.S] |
|
bits_lshift [Mint_natural.Create] |
|
bits_not [Mint.S] |
|
bits_not [Mint_natural.Create] |
|
bits_of_value [Runtime_mem.Create.Data] |
|
bits_of_value [Runtime_mem.Create] |
|
bits_or [Mint.S] |
|
bits_or [Mint_natural.Create] |
|
bits_rshift [Mint.S] |
|
bits_rshift [Mint_natural.Create] |
|
bits_xor [Mint.S] |
|
bits_xor [Mint_natural.Create] |
|
bkind_sid [Cil2cfg] |
|
bkind_stmt [Cil2cfg] |
|
blit [String] |
String.blit src srcoff dst dstoff len copies len characters
from string src , starting at character number srcoff , to
string dst , starting at character number dstoff .
|
block_length [Mlogic.S] |
block_length m l t return the block_length
of the location l .
|
block_length [Hoare_mem.Create] |
|
block_length [Store_mem.Create] |
|
block_length [Runtime_mem.Create.RtLib] |
|
block_length [Runtime_mem.Create] |
|
block_length [Funvar_mem.Create] |
|
blocks_closed_by_edge [Cil2cfg] |
|
bool_and [Fol_decl] |
|
bool_not [Fol_decl] |
|
bool_of_option [Translate_prop.Create] |
|
bool_or [Fol_decl] |
|
boolean_of_data [Translate_prop.Create] |
|
boolean_of_float [Translate_expr.Create] |
|
boolean_of_int [Translate_expr.Create] |
|
boolean_of_integer [Translate_expr.Create] |
|
boolean_of_loc [Translate_expr.Create] |
|
boolean_of_value [Translate_expr.Create] |
|
bracket_exp [Variables_analysis] |
|
bracket_term [Variables_analysis] |
|
brackets_and_stars_lv_typ [Funvar_mem.Create] |
|
brackets_and_stars_lv_typ [Variables_analysis] |
|
brackets_and_stars_typ [Funvar_mem.Create] |
|
brackets_and_stars_typ [Variables_analysis] |
|
brackets_and_stars_var_type_typ [Variables_analysis] |
|
brackets_lv_typ [Variables_analysis] |
|
brackets_off [Variables_analysis] |
|
brackets_toff [Variables_analysis] |
|
brackets_typ [Variables_analysis] |
brackets_typ typ returns the numbre of brackets of the type typ .
|
brackets_var_type_typ [Variables_analysis] |
|
build_bhv_strategy [WpAnnot] |
|
build_configs [WpAnnot] |
|
build_elem [WpFroms] |
see build_elem_opt above.
|
build_elem_opt [WpFroms] |
Build the lvalue \at (mlab, * (\at (addrlab, & elem))) .
|
build_fimpl_eq [WpFroms] |
Build out = f_n (inputs) .
|
build_post_output [WpFroms] |
Build the left part of a contract assigns property
Process \result and \exit_status according to termination_kind .
|
build_prop_of_from [Mcfg.S] |
build p => alpha(p) for functional dependencies verification.
|
build_prop_of_from [CfgWeakestPrecondition.Create] |
|
build_prop_of_from [Cfgpropid.Create] |
|
build_wpos [CfgProof.Create] |
|
by_array_reference [Variables_analysis] |
|
by_array_reference_pattern [Variables_analysis] |
|
by_array_reference_pattern_term [Variables_analysis] |
|
by_array_reference_usage [Variables_analysis] |
|
by_array_reference_usage_term [Variables_analysis] |
|
by_pointer_reference_pattern [Variables_analysis] |
|
by_pointer_reference_pattern_term [Variables_analysis] |
|
by_pointer_reference_usage [Variables_analysis] |
|
by_pointer_reference_usage_term [Variables_analysis] |
|
by_ptr_reference [Variables_analysis] |
|
C |
c_bool [Fol] |
|
c_bool [Ctypes] |
Returns the type of int
|
c_char [Ctypes] |
Returns the type of char
|
c_float [Fol] |
|
c_float [Ctypes] |
Conforms to
|
c_float_of_str [Fol] |
|
c_int [Fol] |
|
c_int [Ctypes] |
Conforms to
|
c_int_all [Ctypes] |
|
c_int_bounds [Ctypes] |
|
c_int_of_str [Fol] |
|
c_int_of_typ [Translate_expr.Create] |
|
c_label [Clabels] |
Assumes the logic label only comes from normalized labels.
|
c_ptr [Ctypes] |
Returns the type of pointers
|
call [Mcfg.S] |
|
call [CfgWeakestPrecondition.Create] |
|
call [Cfgpropid.Create] |
|
call_exit [Translate_prop.Create] |
|
call_exit_only [CfgWeakestPrecondition.Create] |
|
call_goal_precond [Mcfg.S] |
|
call_goal_precond [CfgWeakestPrecondition.Create] |
|
call_goal_precond [Cfgpropid.Create] |
|
call_normal_only [CfgWeakestPrecondition.Create] |
|
call_post [Translate_prop.Create] |
|
call_pre [Translate_prop.Create] |
|
callenv [CfgWeakestPrecondition.Create] |
|
calls_collection_computed [Variables_analysis] |
|
capitalize [String] |
Return a copy of the argument, with the first character set to uppercase.
|
cardinal [Hoare_mem.Create] |
|
cardinal [Store_mem.Create] |
|
cardinal [Map.S] |
Return the number of bindings of a map.
|
cardinal [Set.S] |
Return the number of elements of a set.
|
case_of [Fol] |
|
case_of_exp [CfgWeakestPrecondition.Create] |
|
case_of_optimization [Variables_analysis] |
|
cast [CfgWeakestPrecondition.Create] |
|
cast [Translate_prop.Create] |
|
cast_int_to_loc [Mvalues.Model] |
|
cast_int_to_loc [Hoare_mem.Create.Model] |
|
cast_int_to_loc [Store_mem.Create.Model] |
|
cast_int_to_loc [Runtime_mem.Create.Model] |
|
cast_int_to_loc [Funvar_mem.Create.Model] |
|
cast_int_to_loc [Datalib.Cvalues] |
|
cast_loc_to_int [Mvalues.Model] |
|
cast_loc_to_int [Hoare_mem.Create.Model] |
|
cast_loc_to_int [Store_mem.Create.Model] |
|
cast_loc_to_int [Runtime_mem.Create.Model] |
|
cast_loc_to_int [Funvar_mem.Create.Model] |
|
cast_loc_to_int [Datalib.Cvalues] |
|
cast_loc_to_loc [Mvalues.S] |
cast_loc_to_loc t1 t2 l returns the casted location of type t2
from the location l of type t1
|
cast_loc_to_loc [Hoare_mem.Create] |
|
cast_loc_to_loc [Store_mem.Create] |
|
cast_loc_to_loc [Runtime_mem.Create] |
|
cast_loc_to_loc [Funvar_mem.Create] |
|
cat [Prover] |
|
catch_label_error [NormAtLabels] |
|
cfg_block [Cil2cfg] |
|
cfg_dot [Cil2cfg] |
|
cfg_from_definition [Cil2cfg] |
|
cfg_from_proto [Cil2cfg] |
|
cfg_graph [Cil2cfg] |
|
cfg_kf [Cil2cfg] |
|
cfg_of_strategy [WpStrategy] |
|
cfg_spec_only [Cil2cfg] |
returns true is this CFG is degenerated (no code available)
|
cfg_start [Cil2cfg] |
|
cfg_stmt [Cil2cfg] |
|
cfg_stmts [Cil2cfg] |
build the nodes for the stmts , connect the last one with next ,
and return the node of the first stmt.
|
cfg_switch [Cil2cfg] |
|
change_exp_in_pred [Fol] |
apply do_exp on each sub expression of the predicate.
|
change_in_exp [Fol] |
Apply do_var in term subexpressions.
|
change_mode_if_needed [Calculus.Cfg.R] |
If needed, clear wp table to compute Pass2.
|
char [Ctypes] |
|
check [Prover.Coq] |
|
check [Prover.AltErgo] |
|
check [Prover.SMT] |
|
check [Prover] |
|
check_assigns [CfgWeakestPrecondition.Create] |
|
check_by [Prover] |
|
check_cpt [Fol.Var] |
|
check_names [Wp_parameters] |
|
check_pred [Fol] |
|
check_term [Fol] |
|
choose [Map.S] |
Return one binding of the given map, or raise Not_found if
the map is empty.
|
choose [Proof] |
|
choose [Set.S] |
Return one element of the given set, or raise Not_found if
the set is empty.
|
cil_field_info [Runtime_mem.Create] |
|
cil_field_offset [Runtime_mem.Create] |
|
cil_field_size [Runtime_mem.Create] |
|
clean [Prover.Logs] |
|
clean_graph [Cil2cfg] |
|
clear [Hook.S] |
Clear the hook.
|
clear [Formula.S.Declarator] |
|
clear [Formula.S] |
|
clear [LogicId] |
|
clear [Fol_formula.Declarator] |
|
clear [Fol_formula] |
|
clear [Wpo.Results] |
|
clear [Hashtbl.S] |
|
clear [Wpo] |
|
clear [Proof] |
|
clear [Cil2cfg.HEsig] |
|
clear [Cil2cfg.HE] |
|
clear [State_builder.Hashtbl] |
Clear the table.
|
clear [State_builder.Ref] |
Reset the reference to its default value.
|
close [Formula.Logic] |
|
close [Mcfg.S] |
|
close [CfgWeakestPrecondition.Create] |
|
close [Cfgpropid.Create] |
|
close [Datalib.Create] |
|
close [Prover.Logs] |
|
close [Script] |
|
close_out [Prover.Logs] |
|
close_property [CfgWeakestPrecondition.Create] |
|
closed [Formula.Logic] |
|
closed [Datalib.Create] |
|
cmdline_run [Register] |
|
cnst_mult [Runtime_mem.Create.Aint] |
|
cnst_mult_size [Runtime_mem.Create.Tint] |
|
code_annot_names [WpPropId] |
|
coerce_arr [Store_mem.Create] |
|
coerce_comp [Store_mem.Create] |
|
coercion [Fol] |
|
cofix [LogicDef.Cofix] |
|
collect_and [LogicPretty] |
|
collect_and [Fol_coq] |
|
collect_and [Fol_ergo] |
|
collect_and [Fol_pretty] |
|
collect_apps [Variables_analysis] |
|
collect_apps_builtin [Variables_analysis] |
|
collect_apps_rec [Variables_analysis] |
|
collect_arg_array_call [Variables_analysis] |
|
collect_arg_ptr_call [Variables_analysis] |
|
collect_assoc [Fol_coq] |
|
collect_assoc [Fol_ergo] |
|
collect_assoc [Fol_pretty] |
|
collect_calls [Variables_analysis] |
|
collect_calls_rec [Variables_analysis] |
|
collect_exists [LogicPretty] |
|
collect_forall [LogicPretty] |
|
collect_formal_array_call [Variables_analysis] |
|
collect_formal_ptr_call [Variables_analysis] |
|
collect_iff [Fol_coq] |
|
collect_iff [Fol_ergo] |
|
collect_iff [Fol_pretty] |
|
collect_implies [LogicPretty] |
|
collect_imply [Fol_coq] |
|
collect_imply [Fol_ergo] |
|
collect_imply [Fol_pretty] |
|
collect_labels [LogicPretty] |
|
collect_logic_vars [Translate_prop.Create] |
to be used to retreive variable add through add_logic_vars .
|
collect_or [LogicPretty] |
|
collect_or [Fol_coq] |
|
collect_or [Fol_ergo] |
|
collect_or [Fol_pretty] |
|
collect_refparams [Variables_analysis] |
|
collect_scripts [Proof] |
|
collect_sepstars [Variables_analysis] |
|
collect_signature [Translate_prop.Create] |
|
column_tbl [Po_navigator.Prover_Column] |
|
command [Prover.Logs] |
|
comment [Script] |
|
comp_compare [Fol_formula] |
|
compare [LogicRaw.VAR] |
|
compare [LogicId.S] |
|
compare [Fol_formula.LTinfo] |
|
compare [Fol.Var] |
|
compare [Map.S] |
Total ordering between maps.
|
compare [Wpo.WPO] |
|
compare [Set.S] |
Total ordering between sets.
|
compare [Cil2cfg.EL] |
|
compare [Cil2cfg.VL] |
|
compare [Ctypes.AinfoComparable] |
|
compare [Ctypes] |
|
compare [String] |
|
compare_c_float [Ctypes] |
|
compare_c_int [Ctypes] |
|
compare_edge_type [Cil2cfg.EL] |
|
compare_field [LogicTau] |
|
compare_item [Fol_formula] |
|
compare_prop_id [WpPropId] |
|
compare_sig [LogicTau] |
|
compare_tau [LogicTau] |
|
compare_token [LogicId] |
|
compatible [LogicDef.Cofix] |
|
compatible_signature [LogicDef.Cofix] |
|
compile [ACSL.Compiler] |
|
compile [Fol_norm] |
|
compile [Fol_eqs] |
|
compile [Fol_let] |
|
compile_and_define [Translate_prop.Create] |
|
compile_def [Fol_let] |
|
compile_function [Translate_prop.Create] |
|
compile_let_decl [Fol_formula] |
|
compile_let_item [Fol_formula] |
|
compile_predicate [Translate_prop.Create] |
|
compile_user_axiom [Translate_prop.Create] |
|
compile_user_axiom_labels [Translate_prop.Create] |
|
compiled [Prover.Coq] |
|
compute [Calculus.Cfg] |
|
compute [LogicDef.Cofix] |
|
compute [Variables_analysis] |
|
compute_calls_collection [Variables_analysis] |
|
compute_init_loc [CfgWeakestPrecondition.Create] |
|
compute_init_value [CfgWeakestPrecondition.Create] |
|
compute_int_mode [Runtime_mem.Create] |
|
compute_logic_params [Variables_analysis] |
|
compute_parameters_usage [Variables_analysis] |
|
compute_rte_for [WpAnnot] |
|
compute_wp_edge [Calculus.Cfg] |
|
computer [Register] |
|
concat [String] |
String.concat sep sl concatenates the list of strings sl ,
inserting the separator string sep between each.
|
cond [CfgWeakestPrecondition.Create] |
|
cond [Translate_expr.Create] |
cond mem e interprets e as a boolean
in memory mem .
|
cond_binop [Translate_expr.Create] |
|
cond_rec [Translate_expr.Create] |
|
cond_unop [Translate_expr.Create] |
|
constant [Fol_coq] |
|
constant [Fol_ergo] |
|
constant [Fol_pretty] |
|
constant [Ctypes] |
|
contains [String] |
String.contains s c tests if character c
appears in the string s .
|
contains_from [String] |
String.contains_from s start c tests if character c
appears in s after position start .
|
context [CfgProof.Description] |
Basename for environment files ; unique per updater
|
convert [Kreal] |
|
copy [LogicId] |
Duplicates a name space.
|
copy [Hashtbl.S] |
|
copy [String] |
Return a copy of the given string.
|
copy [Datatype.S] |
Deep copy: no possible sharing between x and copy x .
|
copy [Datatype.Set] |
|
coq_for_env [Wpo] |
|
coq_for_model [Wpo] |
|
coqc [Prover.Coq] |
|
coqc_for_model [Wpo] |
|
coqidelock [Prover.Coqide] |
|
create [CfgProof.Create] |
|
create [LogicId] |
Create a new fresh identifier with the given basename
|
create [Prover.Logs] |
|
create [Wpo.Results] |
|
create [Hashtbl.S] |
|
create [Cil2cfg.HEsig] |
|
create [Cil2cfg.HE] |
|
create [Cil2cfg] |
|
create [String] |
String.create n returns a fresh string of length n .
|
create_proof [WpAnnot] |
to be used only once for one of the related prop_id
|
create_tbl [WpStrategy] |
|
cur_fct_default_bhv [WpAnnot] |
|
current [LogicDef.Cofix] |
|
current [Wp_error] |
|
current_model [LogicDef] |
|
cut [LogicRaw.PRED] |
|
cut [Fol] |
|
cvar [Mvalues.S] |
|
cvar [Hoare_mem.Create] |
|
cvar [Store_mem.Create.Data] |
|
cvar [Runtime_mem.Create.Data] |
|
cvar [Funvar_mem.Create] |
|
cvar_of_var [Store_mem.Create.Data] |
|
cvc3 [Prover.SMT] |
|
D |
darray_name [ACSL] |
|
darray_of_arrayinfo [ACSL] |
|
data_binop [Translate_prop.Create] |
|
data_cmp [Translate_prop.Create] |
|
data_const [Translate_prop.Create] |
|
data_field [Translate_prop.Create] |
|
data_index [Translate_prop.Create] |
|
data_index_range [Translate_prop.Create] |
|
data_load [Translate_prop.Create] |
|
data_of_a [Store_mem.Create] |
|
data_of_addr [Store_mem.Create] |
|
data_of_assignable [Translate_prop.Create] |
|
data_of_boolean [Translate_prop.Create] |
|
data_of_float [Store_mem.Create] |
|
data_of_int [Store_mem.Create] |
|
data_of_integer [Translate_prop.Create] |
|
data_of_real [Translate_prop.Create] |
|
data_of_s [Store_mem.Create] |
|
data_of_term [Translate_prop.Create] |
|
data_rec [Translate_prop.Create] |
|
data_separated [Translate_prop.Create] |
|
data_shift [Translate_prop.Create] |
|
data_shift_range [Translate_prop.Create] |
|
data_startof [Translate_prop.Create] |
|
data_startof_set [Translate_prop.Create] |
|
data_unop [Translate_prop.Create] |
|
data_valid [Translate_prop.Create] |
|
debug [Calculus.Cfg] |
|
debug [Translate_prop] |
|
debug [Translate_expr] |
|
debug [Funvar_mem] |
|
debug [Variables_analysis] |
|
debug [WpAnnot] |
|
debug [WpStrategy] |
|
debug [Cil2cfg] |
|
debug2 [Cil2cfg] |
|
declarations [LogicDef] |
|
declare [Formula.S.Declarator] |
|
declare [LogicDef] |
Simple declaration.
|
declare [Fol_formula.Declarator] |
|
decode [Store_mem.Create] |
|
decr_addr_taken [Variables_analysis] |
|
decr_addr_taken_bool [Variables_analysis] |
|
def [Fol_let] |
|
default [LogicDef.Cofix] |
|
default [LogicDef] |
|
default [Prover.Coq] |
|
default [Cil2cfg.EL] |
|
default_edge_attributes [Cil2cfg.Printer] |
|
default_vertex_attributes [Cil2cfg.Printer] |
|
define [Formula.S.Registry] |
|
define [Translate_prop.Create.UserAxiomDefs] |
|
define [Translate_prop.Create.UserDefinition] |
|
define [LogicDef.Cofix] |
|
define [Fol_formula.Registry] |
|
define [Fol_formula.DRegister] |
|
define [Data_mem.Create.Compound] |
|
define_access [Data_mem.Create.LoadedCompound] |
|
define_array [Data_mem.Create.UpdatedCompound] |
|
define_array [Data_mem.Create.StoredCompound] |
|
define_array [Data_mem.Create.LoadedCompound] |
|
define_comp [Data_mem.Create.UpdatedCompound] |
|
define_comp [Data_mem.Create.StoredCompound] |
|
define_comp [Data_mem.Create.LoadedCompound] |
|
define_update [Data_mem.Create.StoredCompound] |
|
define_vinfo [Store_mem.Create.Data] |
|
delta_array [Variables_analysis] |
|
delta_array_term [Variables_analysis] |
|
delta_ptr [Variables_analysis] |
|
delta_ptr_term [Variables_analysis] |
|
depend [LogicRaw.PRED] |
|
depend [LogicRaw.TERM] |
|
depend [LogicTau] |
|
dependencies [LogicDef] |
|
dependencies [WpAnnot] |
|
deq_ctype [ACSL] |
|
deref [Variables_analysis] |
|
descr [Datatype.Set] |
|
dhas_ctype [ACSL] |
|
diff [Set.S] |
Set difference.
|
different [LogicRaw.TERM] |
|
different [LogicRaw.VAR] |
|
dimension [Ctypes] |
|
dispatch [Register] |
|
dispatch [Fol_split] |
|
dispatch_cvar [Variables_analysis] |
dispatch_cvar v returns the var_kind associated to the C variable v
according the current optimisations activated.
|
dispatch_lvar [Variables_analysis] |
dispatch_lvar v returns the var_kind associated to the logic variable v
according the current optimisations activated.
|
dispatch_var [Variables_analysis] |
|
div_int [Fol_decl] |
|
dkey [CfgProof] |
|
dkey [Calculus.Cfg] |
|
dkey [Translate_expr] |
|
dkey [LogicPretty] |
|
dkey [LogicRaw] |
|
dkey [Fol_split] |
|
dkey [Runtime_mem] |
|
dkey [Variables_analysis] |
|
dkey [WpAnnot] |
|
dkey [WpFroms] |
|
dkey [WpStrategy] |
|
dkey [Cil2cfg] |
|
dnode_cpt [Cfgpropid.Create] |
|
do_check_feedback [Register] |
|
do_compute [Register] |
|
do_export [Fol_formula] |
|
do_finally [Register] |
|
do_hypothesis [CfgWeakestPrecondition.Create] |
|
do_labels [Calculus.Cfg] |
Before storing something at a program point, we have to process the label
at that point.
|
do_prop [CfgWeakestPrecondition.Create] |
|
do_properties [CfgWeakestPrecondition.Create] |
|
do_return [CfgWeakestPrecondition.Create] |
|
do_wp_check [Register] |
|
do_wp_checks [Register] |
|
do_wp_checks_for [Register] |
|
do_wp_passes [Register] |
|
do_wp_print [Register] |
|
do_wp_print_for [Register] |
|
do_wp_proof [Register] |
|
do_wp_proofs [Register] |
|
do_wp_proofs_for [Register] |
|
do_wpo_feedback [Register] |
|
dot_annots [Cil2cfg] |
dot_annots cfg bhv_name pp_annots
|
dot_cfg [Cil2cfg] |
Output the graph in a dot file and return its name *
|
dot_lannots [Register] |
|
dot_wp_res [Cil2cfg] |
dot_wp_res cfg model pp_wp_res
|
dtau_ctype [ACSL] |
|
dummy [Formula.S] |
|
dummy [LogicId] |
Only usable for represent in projectified definitions
|
dummy [Fol_formula] |
|
dump_scripts [Proof] |
dump_scripts f saves all scripts from the database into file f .
|
dzone_assigned [Mwp.S] |
|
dzone_assigned [Hoare_mem.Create] |
|
dzone_assigned [Store_mem.Create] |
|
dzone_assigned [Runtime_mem.Create] |
|
dzone_assigned [Funvar_mem.Create] |
|
dzone_empty [Mwp.S] |
|
dzone_empty [Hoare_mem.Create] |
|
dzone_empty [Store_mem.Create] |
|
dzone_empty [Runtime_mem.Create] |
|
dzone_empty [Funvar_mem.Create] |
|
dzone_subset [Mwp.S] |
|
dzone_subset [Hoare_mem.Create] |
|
dzone_subset [Store_mem.Create] |
|
dzone_subset [Runtime_mem.Create] |
|
dzone_subset [Funvar_mem.Create] |
|
dzone_union [Mwp.S] |
|
dzone_union [Hoare_mem.Create] |
|
dzone_union [Store_mem.Create] |
|
dzone_union [Runtime_mem.Create] |
|
dzone_union [Funvar_mem.Create] |
|
E |
e_access [Formula.S] |
|
e_access [LogicLang] |
|
e_access [LogicRaw.TERM] |
|
e_access [Fol_formula] |
|
e_access [Fol] |
|
e_and [Formula.S] |
|
e_and [LogicLang] |
|
e_and [LogicRaw.TERM] |
|
e_and [Fol_formula] |
|
e_app [Fol] |
|
e_app0 [Formula.S] |
|
e_app0 [Fol_formula] |
|
e_app1 [Formula.S] |
|
e_app1 [Fol_formula] |
|
e_app2 [Formula.S] |
|
e_app2 [Fol_formula] |
|
e_app3 [Formula.S] |
|
e_app3 [Fol_formula] |
|
e_app4 [Formula.S] |
|
e_app4 [Fol_formula] |
|
e_app5 [Formula.S] |
|
e_app5 [Fol_formula] |
|
e_band [Formula.S] |
|
e_band [LogicLang] |
|
e_band [Fol_formula] |
|
e_bigint [LogicLang] |
|
e_bind [LogicRaw.SUBST] |
|
e_bnot [Formula.S] |
|
e_bnot [LogicLang] |
|
e_bnot [Fol_formula] |
|
e_bool [Formula.S] |
|
e_bool [LogicLang] |
|
e_bool [Fol_formula] |
|
e_bor [Formula.S] |
|
e_bor [LogicLang] |
|
e_bor [Fol_formula] |
|
e_bxor [Formula.S] |
|
e_bxor [LogicLang] |
|
e_bxor [Fol_formula] |
|
e_call [Formula.S] |
|
e_call [LogicLang] |
|
e_call [LogicRaw.TERM] |
|
e_call [Fol_formula] |
|
e_closed [Fol] |
|
e_cnst [Fol] |
|
e_cond [Formula.S] |
|
e_cond [LogicLang] |
|
e_cond [LogicRaw.TERM] |
|
e_cond [Fol_formula] |
|
e_false [Formula.S] |
|
e_false [LogicLang] |
|
e_false [Fol_formula] |
|
e_false [Fol] |
|
e_float [Formula.S] |
|
e_float [LogicLang] |
|
e_float [Fol_formula] |
|
e_float [Fol] |
|
e_getfield [Formula.S] |
|
e_getfield [LogicLang] |
|
e_getfield [LogicRaw.TERM] |
|
e_getfield [Fol_formula] |
|
e_getfield [Fol] |
|
e_has_var [Fol] |
|
e_hasvar [LogicRaw.TERM] |
|
e_icmp [Formula.S] |
|
e_icmp [LogicLang] |
|
e_icmp [Fol_formula] |
|
e_icst [Formula.S] |
|
e_icst [LogicLang] |
|
e_icst [Fol_formula] |
|
e_if [Fol] |
|
e_ineg [Formula.S] |
|
e_ineg [LogicLang] |
|
e_ineg [Fol_formula] |
|
e_int [Formula.S] |
|
e_int [LogicLang] |
|
e_int [LogicRaw.TERM] |
|
e_int [Fol_formula] |
|
e_int [Fol] |
|
e_int64 [Formula.S] |
|
e_int64 [Fol_formula] |
|
e_int64 [Fol] |
|
e_int_of_real [LogicLang] |
|
e_iop [Formula.S] |
|
e_iop [LogicLang] |
|
e_iop [Fol_formula] |
|
e_let [LogicLang] |
|
e_let [LogicRaw.SUBST] |
|
e_let [Fol] |
|
e_lshift [Formula.S] |
|
e_lshift [LogicLang] |
|
e_lshift [Fol_formula] |
|
e_not [Formula.S] |
|
e_not [LogicLang] |
|
e_not [LogicRaw.TERM] |
|
e_not [Fol_formula] |
|
e_or [Formula.S] |
|
e_or [LogicLang] |
|
e_or [LogicRaw.TERM] |
|
e_or [Fol_formula] |
|
e_prim [LogicRaw.TERM] |
|
e_rcmp [Formula.S] |
|
e_rcmp [LogicLang] |
|
e_rcmp [Fol_formula] |
|
e_rcst [Formula.S] |
|
e_rcst [LogicLang] |
|
e_rcst [Fol_formula] |
|
e_real_of_int [LogicLang] |
|
e_rename [Formula.S] |
Requires domain to be disjoint from co-domain
|
e_rename [Fol_formula] |
|
e_rneg [Formula.S] |
|
e_rneg [LogicLang] |
|
e_rneg [Fol_formula] |
|
e_rop [Formula.S] |
|
e_rop [LogicLang] |
|
e_rop [Fol_formula] |
|
e_rshift [Formula.S] |
|
e_rshift [LogicLang] |
|
e_rshift [Fol_formula] |
|
e_setfield [Formula.S] |
|
e_setfield [LogicLang] |
|
e_setfield [LogicRaw.TERM] |
|
e_setfield [Fol_formula] |
|
e_setfield [Fol] |
|
e_shared [LogicLib] |
|
e_subst [Formula.S] |
|
e_subst [Fol_formula] |
|
e_true [Formula.S] |
|
e_true [LogicLang] |
|
e_true [Fol_formula] |
|
e_true [Fol] |
|
e_unfold [Fol_split] |
|
e_update [Formula.S] |
|
e_update [LogicLang] |
|
e_update [LogicRaw.TERM] |
|
e_update [Fol_formula] |
|
e_update [Fol] |
|
e_var [LogicLang] |
|
e_var [Fol] |
|
e_zero [LogicLang] |
|
e_zero [LogicRaw.TERM] |
|
eat [Script] |
|
edge_attributes [Cil2cfg.Printer] |
|
edge_dst [Cil2cfg] |
|
edge_key [Cil2cfg.HE] |
|
edge_key [Cil2cfg] |
|
edge_src [Cil2cfg] |
node and edges relations
|
edge_type [Cil2cfg] |
|
effect_supported [Mwp.S] |
|
effect_supported [Hoare_mem.Create] |
|
effect_supported [Store_mem.Create] |
|
effect_supported [Runtime_mem.Create] |
|
effect_supported [Funvar_mem.Create] |
|
elements [Set.S] |
Return the list of all elements of the given set.
|
elet_expansion [Fol_eval] |
|
empty [Formula.S] |
empty() returns the polymorphic empty set.
|
empty [Mcfg.S] |
|
empty [CfgWeakestPrecondition.Create] |
|
empty [Cfgpropid.Create] |
|
empty [Calculus.Cfg.R] |
|
empty [LogicHavoc] |
|
empty [Fol_formula] |
|
empty [Fol_let] |
|
empty [Map.S] |
The empty map.
|
empty [Set.S] |
The empty set.
|
empty_acc [WpStrategy] |
|
empty_alpha [Formula.S] |
|
empty_alpha [Fol_formula] |
|
empty_assigns_info [WpPropId] |
|
encode [Store_mem.Create] |
|
env [Translate_prop.Create] |
|
env_at [Translate_prop.Create] |
|
env_name [Wpo] |
|
epp_pred_atom [Fol_coq] |
|
epp_pred_atom [Fol_ergo] |
|
epp_pred_atom [Fol_pretty] |
|
epp_pred_named [Fol_pretty] |
|
epp_pred_vbox [Fol_coq] |
|
epp_pred_vbox [Fol_ergo] |
|
epp_pred_vbox [Fol_pretty] |
|
eq_array [Mvalues.Values] |
|
eq_array [Datalib.Cvalues] |
|
eq_array_definition [Datalib.Cvalues] |
|
eq_ctype [ACSL] |
|
eq_int [Fol_decl] |
|
eq_int_bool [Fol_decl] |
|
eq_logic_type [ACSL] |
|
eq_nodes [Cil2cfg.WeiMaoZouChenInput] |
|
eq_nodes [Cil2cfg.LoopInfo] |
|
eq_object [ACSL] |
|
eq_pred [Runtime_mem.Create.Aint] |
|
eq_preds [Fol] |
(partial) structural equality
|
eq_real [Fol_decl] |
|
eq_real_bool [Fol_decl] |
|
eq_record [Mvalues.Values] |
|
eq_record [Datalib.Cvalues] |
|
eq_record_definition [Datalib.Cvalues] |
2 struct or union objects are equal when all the fields are equal.
|
eq_tarray [ACSL] |
|
eq_terms [Fol] |
structural equality
|
eq_var [Formula.S] |
|
eq_var [Fol_formula] |
|
eq_zone [Runtime_mem.Create.Tint] |
|
equal [Mvalues.Values] |
|
equal [LogicRaw.TERM] |
|
equal [LogicRaw.VAR] |
|
equal [LogicId.S] |
|
equal [Fol_formula.LTinfo] |
|
equal [Fol_formula.HC_ArrayDim] |
|
equal [Fol_formula.HC_object] |
|
equal [Fol.Var] |
|
equal [Datalib.Cvalues] |
|
equal [Map.S] |
equal cmp m1 m2 tests whether the maps m1 and m2 are
equal, that is, contain equal keys and associate them with
equal data.
|
equal [Wpo.WPO] |
|
equal [Set.S] |
equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
equal [Cil2cfg.VL] |
|
equal [Ctypes.AinfoComparable] |
|
equal [Ctypes] |
|
equal_loc [Mvalues.Model] |
|
equal_loc [Hoare_mem.Create.Model] |
|
equal_loc [Store_mem.Create.Model] |
|
equal_loc [Runtime_mem.Create.Model] |
|
equal_loc [Funvar_mem.Create.Model] |
|
equal_loc [Datalib.Cvalues] |
|
equal_loc_bool [Mvalues.Model] |
equal_loc_bool p q is the boolean that is true when
locs p and q , that points to elements of type ty ,
are equal.
|
equal_loc_bool [Hoare_mem.Create.Model] |
|
equal_loc_bool [Store_mem.Create.Model] |
|
equal_loc_bool [Runtime_mem.Create.Model] |
|
equal_loc_bool [Funvar_mem.Create.Model] |
|
equal_loc_bool [Datalib.Cvalues] |
|
equal_rec [Datalib.Cvalues] |
|
equal_terms [Formula.S] |
Returns true when the two terms are syntactically equals
|
equal_terms [Fol_formula] |
|
eraise [Script] |
|
error [Kreal] |
|
error [Script] |
|
escaped [String] |
Return a copy of the argument, with special characters
represented by escape sequences, following the lexical
conventions of Objective Caml.
|
exists [Formula.Logic] |
|
exists [Datalib.Create] |
|
exists [Map.S] |
exists p m checks if at least one binding of the map
satisfy the predicate p .
|
exists [Set.S] |
exists p s checks if at least one element of
the set satisfies the predicate p .
|
exit_status [Translate_prop.Create] |
|
export [LogicDef] |
|
export [Prover] |
|
export [Cil2cfg] |
|
export_decl [Mwp.Export] |
|
export_decl [Mcfg.Export] |
|
export_decl [Fol_coq.ECoq] |
|
export_decl [Fol_ergo.Make] |
|
export_decl [Fol_ergo] |
|
export_decl [Fol_why.EWhy] |
|
export_depends_for_item [Fol_formula] |
|
export_depends_for_name [Fol_formula] |
|
export_depends_for_pred [Fol_formula] |
|
export_depends_for_term [Fol_formula] |
|
export_generated_axiomatics [Fol_ergo] |
|
export_generated_axiomatics [Fol_pretty] |
|
export_get_set_field [Fol_ergo] |
|
export_get_set_field [Fol_pretty] |
|
export_get_set_other [Fol_ergo] |
|
export_get_set_other [Fol_pretty] |
|
export_goal [Mwp.Export] |
|
export_goal [Mcfg.Export] |
|
export_goal [LogicDef] |
|
export_goal [Fol_coq.ECoq] |
|
export_goal [Fol_ergo.Make] |
|
export_goal [Fol_ergo] |
|
export_goal [Fol_why.EWhy] |
|
export_item [Fol_coq.ECoq] |
|
export_item [Fol_ergo] |
|
export_item [Fol_why.EWhy] |
|
export_items [LogicDef] |
|
export_pred [Fol_coq.ECoq] |
|
export_pred [Fol_ergo] |
|
export_pred [Fol_why.EWhy] |
|
export_section [Mcfg.Export] |
|
export_section [Fol_coq.ECoq] |
|
export_section [Fol_ergo.Make] |
|
export_section [Fol_why.EWhy] |
|
export_tau [Fol_coq.ECoq] |
|
export_tau [Fol_ergo.Make] |
|
export_tau [Fol_ergo] |
|
export_tau [Fol_why.EWhy] |
|
export_term [Fol_coq.ECoq] |
|
export_term [Fol_ergo] |
|
export_term [Fol_why.EWhy] |
|
export_wpo [CfgProof.Create] |
|
exported_macros [Fol_formula] |
|
expp [Fol_eval] |
|
expr [CfgWeakestPrecondition.Create] |
|
expr [Translate_expr.Create] |
expr mem e interprets the expressione as a value
in memory mem *
|
expr_binop [Translate_expr.Create] |
|
expr_cast [Translate_expr.Create] |
|
expr_cond_cmp [Translate_expr.Create] |
|
expr_cond_cmp_arith [Translate_expr.Create] |
|
expr_cond_cmp_ptr [Translate_expr.Create] |
|
expr_const [Translate_expr.Create] |
|
expr_float [Translate_expr.Create] |
|
expr_float_operator [Translate_expr.Create] |
|
expr_int [Translate_expr.Create] |
|
expr_int_operator [Translate_expr.Create] |
|
expr_rec [Translate_expr.Create] |
|
expr_rec_spec_null [Translate_expr.Create] |
|
expr_unop [Translate_expr.Create] |
|
expt [Fol_eval] |
|
extend [Hook.S] |
Add a new function to the hook.
|
extend [Po_navigator] |
|
extend [LogicId] |
|
extern [LogicId] |
|
extract_from_data [Translate_prop.Create] |
|
F |
f_cmp [Mfloat.S] |
|
f_cmp [Mfloat_natural.Create] |
|
f_convert [Ctypes] |
|
f_format [Runtime_mem.Create] |
|
f_neg [Mfloat.S] |
|
f_neg [Mfloat_natural.Create] |
|
f_op [Mfloat.S] |
|
f_op [Mfloat_natural.Create] |
|
f_sizeof [Ctypes] |
|
f_suffixe [Fol_pretty] |
|
fcmp_operator [Translate_expr.Create] |
|
fdx [Ctypes] |
|
field [Mvalues.S] |
|
field [Mvalues.Data] |
|
field [LogicHavoc] |
field fs f r is empty for all fs except f for which it is r
|
field [Fol_coq] |
|
field [Hoare_mem.Create] |
|
field [Store_mem.Create.Data] |
|
field [Runtime_mem.Create.Data] |
Even if union field has 0 offset, we have to use on operation because
the size of the location to be consider might change from one field to
another.
|
field [Funvar_mem.Create] |
|
field_of [ACSL] |
|
field_offset [Ctypes] |
|
fields [LogicHavoc] |
|
file_for_body [Wpo] |
Dynamically exported.
|
file_for_ctxt [Wpo] |
|
file_for_env [Wpo] |
|
file_for_goal [Wpo] |
|
file_for_head [Wpo] |
|
file_for_lang [Wpo] |
|
file_for_log_check [Wpo] |
|
file_for_log_proof [Wpo] |
|
file_for_log_proof_ [Wpo] |
|
file_for_model [Wpo] |
|
file_for_po [Wpo] |
|
fill [Script] |
|
fill [String] |
String.fill s start len c modifies string s in place,
replacing len characters by c , starting at start .
|
filter [Map.S] |
filter p m returns the map with all the bindings in m
that satisfy predicate p .
|
filter [Set.S] |
filter p s returns the set of all elements in s
that satisfy predicate p .
|
filter_both [WpStrategy] |
|
filter_precond [WpAnnot] |
|
filter_scope [Store_mem.Create] |
|
filter_status [WpAnnot] |
|
find [Calculus.Cfg.R] |
|
find [Map.S] |
find x m returns the current binding of x in m ,
or raises Not_found if no such binding exists.
|
find [Hashtbl.S] |
|
find [Cil2cfg.HEsig] |
|
find [Cil2cfg.HE] |
|
find [State_builder.Hashtbl] |
Return the current binding of the given key.
|
find_all [Hashtbl.S] |
|
find_all [Cil2cfg.HEsig] |
|
find_all [Cil2cfg.HE] |
|
find_all [State_builder.Hashtbl] |
Return the list of all data associated with the given key.
|
find_behaviors [WpAnnot] |
empty bhv_names means all (whatever ki is)
|
find_mem [Translate_prop.Create] |
|
find_script_for_goal [Proof] |
Retrieve script file for one specific goal.
|
find_script_for_keywords [Proof] |
Retrieve matchable script files for w.r.t provided keywords.
|
find_stmt_node [Cil2cfg] |
|
fixpoint [LogicDef.Cofix] |
|
fixpoint [LogicDef] |
Retrieve the definition of f if already defined.
|
flatten [Fol_split.SplitZoneInclusion] |
|
flatten_formals [Translate_prop.Create] |
|
flatten_references [Translate_prop.Create] |
|
float_of_data [Store_mem.Create] |
|
float_of_value [Translate_expr.Create] |
|
float_operator [Translate_expr.Create] |
|
flow [Wpo] |
|
flush [Formula.Logic] |
|
flush [Fol_eqs] |
|
flush [Datalib.Create] |
|
flush_context [Translate_prop.Create] |
|
fmemo [Ctypes] |
|
fold [Map.S] |
fold f m a computes (f kN dN ... (f k1 d1 a)...) ,
where k1 ... kN are the keys of all bindings in m
(in increasing order), and d1 ... dN are the associated data.
|
fold [Hashtbl.S] |
|
fold [Set.S] |
fold f s a computes (f xN ... (f x2 (f x1 a))...) ,
where x1 ... xN are the elements of s , in increasing order.
|
fold [State_builder.Hashtbl] |
|
fold_alpha [Formula.S] |
|
fold_alpha [Fol_formula] |
|
fold_and [LogicPretty] |
|
fold_assoc [LogicPretty] |
|
fold_bhv_post_cond [WpStrategy] |
apply f_normal on the Normal postconditions,
f_exits on the Exits postconditions, and warn on the others.
|
fold_hyp [LogicPretty] |
|
fold_implies [LogicPretty] |
|
fold_nodes [Cil2cfg] |
iterators
|
fold_or [LogicPretty] |
|
fold_pred [Cil2cfg] |
|
fold_pred_e [Cil2cfg] |
|
fold_succ [Cil2cfg.WeiMaoZouChenInput] |
apply the function on the node successors
|
fold_succ [Cil2cfg.LoopInfo] |
|
fold_succ [Cil2cfg] |
|
fold_succ_e [Cil2cfg] |
|
for_all [Map.S] |
for_all p m checks if all the bindings of the map
satisfy the predicate p .
|
for_all [Set.S] |
for_all p s checks if all elements of the set
satisfy the predicate p .
|
forall [Formula.Logic] |
|
forall [LogicHavoc] |
|
forall [Datalib.Create] |
|
forall_loc [Mvalues.Data] |
|
forall_loc [Store_mem.Create.Data] |
|
forall_loc [Runtime_mem.Create.Data] |
|
format_of_addr [Runtime_mem.Create] |
|
format_of_array [Runtime_mem.Create] |
|
format_of_compinfo [Runtime_mem.Create] |
|
fpp_decl [Fol_coq] |
|
fpp_decl [Fol_ergo] |
|
fpp_decl [Fol_pretty] |
|
fpp_f_let [Fol_coq] |
|
fpp_f_let [Fol_ergo] |
|
fpp_fields [Fol_coq] |
|
fpp_goal [Fol_coq] |
|
fpp_goal [Fol_ergo] |
|
fpp_goal [Fol_pretty] |
|
fpp_header [Fol_coq] |
|
fpp_header [Fol_ergo] |
|
fpp_header [Fol_pretty] |
|
fpp_item [Fol_coq] |
|
fpp_item [Fol_ergo] |
|
fpp_item [Fol_pretty] |
|
fpp_lf_let [Fol_coq] |
|
fpp_lf_let [Fol_ergo] |
|
fpp_pred [Fol_coq] |
|
fpp_pred [Fol_ergo] |
|
fpp_pred [Fol_pretty] |
|
fpp_term [Fol_coq] |
|
fpp_term [Fol_ergo] |
|
fpp_term [Fol_pretty] |
|
fpretty_term [Fol_pretty] |
|
fract_real [Fol_decl] |
|
free [Hoare_mem.Create] |
|
free [Runtime_mem.Create.RtLib] |
|
free_pred [Fol_formula] |
|
free_term [Fol_formula] |
|
free_vars [Fol_cc] |
|
free_vars [Hoare_mem.Create] |
|
free_vars [Store_mem.Create] |
|
freevars [Formula.S] |
|
freevars [Fol_formula] |
|
fresh [Formula.Logic] |
|
fresh [LogicLib] |
|
fresh [LogicLang] |
|
fresh [LogicRaw.VAR] |
|
fresh [Fol_eqs] |
|
fresh [Fol_let] |
|
fresh [Datalib.Create] |
|
fresh_addr [Translate_prop.Create] |
|
fresh_local [Translate_prop.Create] |
|
fresh_logic_var [Translate_prop.Create] |
|
fresh_name [Formula.S] |
|
fresh_name [Fol_formula] |
|
fresh_named_var [Fol.Var] |
|
fresh_params [Fol_let] |
|
fresh_var [Fol_formula] |
|
fresh_var [Fol.Var] |
|
fresh_vars [Store_mem.Create] |
|
fresh_vars_in_pred [Fol] |
|
freshen [LogicRaw.VAR] |
|
from_bits [Runtime_mem.Create.RtLib] |
|
fsort [LogicHavoc] |
|
full [LogicHavoc] |
|
fun_load [Funvar_mem.Create] |
|
G |
gaddress_of_cvar [Translate_prop.Create] |
|
gaddress_of_mem [Translate_prop.Create] |
|
gaddress_of_ref [Translate_prop.Create] |
|
gclear [Fol_formula] |
|
gdummy [Fol_formula] |
|
generic_compute [Register] |
|
get [Po_navigator.Prover_Column] |
|
get [Wpo.Results] |
|
get [Cil2cfg] |
|
get [String] |
String.get s n returns character number n in string s .
|
get [State_builder.Ref] |
Get the referenced value.
|
get_and_init [WpFroms.Vars] |
|
get_annots [WpStrategy] |
|
get_asgn_goal [WpStrategy] |
|
get_asgn_hyp [WpStrategy] |
|
get_assigns_method [Wp_parameters] |
|
get_behav [WpAnnot] |
Select in bhv_list the behavior that has to be processed
according to config and ki current statement.
|
get_behavior_annots [WpAnnot] |
Builds tables that give hypotheses and goals relative to b behavior
for edges of the cfg to consider during wp computation.
|
get_behavior_strategies [WpAnnot] |
Compute the strategy to prove all the properties of the behavior.
|
get_bhv_assumes [WpAnnot] |
|
get_bhv_pre [WpFroms] |
|
get_both_hyp_goals [WpStrategy] |
|
get_c_funvar [Funvar_mem.Create] |
|
get_call_annots [WpAnnot] |
|
get_call_asgn [WpStrategy] |
|
get_call_hyp [WpFroms] |
|
get_call_hyp [WpStrategy] |
To be used as hypotheses arround a call, (the pre are in
get_call_pre_goal )
|
get_call_out_edges [Cil2cfg] |
similar to succ_e g v
but gives the edge to VcallOut first and the edge to Vexit second.
|
get_call_pre [WpStrategy] |
Preconditions of a called function to be considered as hyp and goal
(similar to get_both_hyp_goals ).
|
get_call_pre_strategies [WpAnnot] |
|
get_called_assigns [WpAnnot] |
Properties for assigns of kf
|
get_called_exit_conditions [WpAnnot] |
|
get_called_kf [WpStrategy] |
|
get_called_post [WpFroms] |
Collect the \from hypotheses of the function spectication.
|
get_called_post_conditions [WpAnnot] |
|
get_called_postconds [WpAnnot] |
|
get_called_preconditions_at [WpAnnot] |
|
get_cfg [WpAnnot] |
|
get_cut [WpStrategy] |
the bool in get_cut results says if the property has to be
considered as a both goal and hyp (goal=true , or hyp only (goal=false )
|
get_cycle [LogicDef.Cofix] |
|
get_declaration [LogicDef] |
Raise Not_found if the symbol is undefined.
|
get_definition [Formula.S.Registry] |
|
get_definition [Translate_prop.Create] |
|
get_definition [Fol_formula.Registry] |
|
get_definition [Fol_formula.DRegister] |
|
get_description [LogicDef] |
Raise Not_found if the symbol is undefined.
|
get_edge_labels [Cil2cfg] |
|
get_edge_next_stmt [Cil2cfg] |
|
get_env [Wp_parameters] |
|
get_exit_edges [Cil2cfg] |
Find the edges e that goes to the Vexit node inside the statement
begining at node n
|
get_fct_bhv_from_annots [WpFroms] |
Collect all the annotations to be used to prove one \from property of
the function behavior *
|
get_fct_post_annots [WpAnnot] |
|
get_fct_pre_annots [WpAnnot] |
|
get_field [Fol_ergo] |
|
get_field [Fol_pretty] |
|
get_function_strategies [WpAnnot] |
Compute the strategies to prove all the properties of the selected function.
|
get_funvar [Funvar_mem.Create] |
|
get_gid [Wpo] |
Dynamically exported
|
get_goal_only [WpStrategy] |
|
get_hyp_only [WpStrategy] |
|
get_id_prop_strategies [WpAnnot] |
Compute the strategies to prove the selected property.
|
get_iloop_header [Cil2cfg.WeiMaoZouChenInput] |
get the node innermost loop header if any
|
get_iloop_header [Cil2cfg.LoopInfo] |
|
get_implicit_fun [WpFroms] |
Build the implicit function for the nth assign clause of behavior b
in the ki element of function kf.
|
get_ind [Formula.S.Indexed] |
|
get_ind [Fol_formula.Indexed] |
|
get_ind [Fol_formula.Dindex] |
|
get_induction [WpPropId] |
Quite don't understand what is going on here...
|
get_init_linfo [WpFroms] |
|
get_int [Ctypes] |
|
get_internal_edges [Cil2cfg] |
Find the edges e of the statement node n postcondition
and the set of edges that are inside the statement (e excluded).
|
get_item [LogicDef] |
Raise Not_found if the symbol is undefined.
|
get_kind_for_tk [WpPropId] |
|
get_linfo [WpFroms] |
Find the logic_info for the given name and signature.
|
get_local_depends [LogicDef] |
|
get_logic_funvar [Funvar_mem.Create] |
|
get_loop_annots [WpAnnot] |
Returns the annotations for the three edges of the loop node: loop_entry : goals for the edge entering in the loop, loop_back : goals for the edge looping to the entry point, loop_core : fix-point hypothesis for the edge starting the loop core
|
get_loop_assigns_for_froms [WpFroms] |
|
get_loop_stmt [WpPropId] |
find the outer loop in which the stmt is.
|
get_model [Wp_parameters] |
|
get_models [Wp_parameters] |
|
get_named_bhv [WpAnnot] |
find the behavior named name in the list
|
get_node [Cil2cfg] |
|
get_norm [Wp_parameters] |
|
get_only_succ [Calculus.Cfg] |
|
get_output [Wp_parameters] |
|
get_pos [Cil2cfg.WeiMaoZouChenInput] |
get the previously stored position of the node or 0 if nothing has been
stored
|
get_pos [Cil2cfg.LoopInfo] |
|
get_pos_if_traversed [Cil2cfg.WeiMaoZouChenInput] |
get the previously stored position of the node if any, or None
if set_pos hasn't been called already for this node.
|
get_pos_if_traversed [Cil2cfg.LoopInfo] |
|
get_post_edges [Cil2cfg] |
Find the edges where the postconditions of the node statement have to be
checked.
|
get_post_logic_label [Cil2cfg] |
Get the label to be used for the Post state of the node contract if any.
|
get_pre_edges [Cil2cfg] |
Find the edges where the precondition of the node statement have to be
checked.
|
get_precond_strategies [WpAnnot] |
|
get_pred_linfo [WpFroms] |
|
get_prop_id [Wpo] |
|
get_prop_strategies [WpAnnot] |
Similar to get_id_prop_strategies but with a named property.
|
get_provers [Wp_parameters] |
|
get_result [Wpo] |
Dynamically exported.
|
get_results [Wpo] |
|
get_share [Wp_parameters] |
|
get_stmt_annots [WpAnnot] |
|
get_stmt_hyp [WpFroms] |
|
get_stmt_node [Cil2cfg] |
In some cases (goto for instance) we have to create a node before having
processed if through cfg_stmt .
|
get_strategies [WpAnnot] |
|
get_strategies_for_froms [WpFroms] |
Build strategies to prove the from properties of the function.
|
get_strategy [Wp_gui] |
|
get_strategy_for_from [WpFroms] |
|
get_subgraph [Cil2cfg.Printer] |
|
get_switch_edges [Cil2cfg] |
similar to succ_e g v
but give the switch cases and the default edge
|
get_test_edges [Cil2cfg] |
Get the edges going out a test node with the then branch first
|
get_ufield [Fol_coq] |
|
get_value [ACSL.Register] |
|
get_var [Hoare_mem.Create] |
Get the wp variable of the C variable.
|
get_weakest_precondition [Calculus.Cfg] |
|
get_wp_edge [Calculus.Cfg] |
|
get_zrange_opt [Store_mem.Create] |
|
gfresh [Fol_formula] |
|
gid [Wpo] |
|
gindex [Fol_formula] |
|
gindexref [Fol_formula] |
|
global [Mvalues.S] |
|
global [Hoare_mem.Create] |
|
global [Store_mem.Create.Data] |
|
global [Runtime_mem.Create.Data] |
|
global [Funvar_mem.Create] |
|
global_axioms [WpStrategy] |
|
global_scope [Mwp.S] |
|
global_scope [Hoare_mem.Create] |
|
global_scope [Store_mem.Create] |
|
global_scope [Runtime_mem.Create] |
|
global_scope [Funvar_mem.Create] |
|
goal_to_select [WpAnnot] |
|
graph_attributes [Cil2cfg.Printer] |
|
gsection [Fol_formula] |
|
gstartof [Translate_prop.Create] |
|
gstartof_cvar [Translate_prop.Create] |
|
gstartof_mem [Translate_prop.Create] |
|
gstartof_value [Translate_prop.Create] |
|
gtoc [Fol_formula] |
|
guard [Formula.S] |
|
guard [Fol_formula] |
|
gui_provers [Wpo] |
|
H |
has_context_vars [Formula.Logic] |
|
has_context_vars [Datalib.Create] |
|
has_ctype [ACSL] |
|
has_declaration [Formula.S] |
|
has_declaration [Fol_formula] |
|
has_exit [Cil2cfg] |
wether an exit edge exists or not
|
has_ind [Formula.S.Indexed] |
|
has_ind [Fol_formula.Indexed] |
|
has_ind [Fol_formula.Dindex] |
|
has_object [ACSL] |
|
has_prefix [Clabels] |
|
has_reserved_prefix [Fol_decl] |
|
has_type [Formula.Logic] |
|
has_type [Datalib.Create] |
|
hash [LogicRaw.VAR] |
|
hash [LogicId.S] |
|
hash [Fol_formula.LTinfo] |
|
hash [Fol_formula.HC_ArrayDim] |
|
hash [Fol_formula.HC_object] |
|
hash [Wpo.WPO] |
|
hash [Cil2cfg.VL] |
|
hash [Ctypes.AinfoComparable] |
|
hash [Ctypes] |
|
hash [Datatype.Set] |
|
havoc [Runtime_mem.Create.RtLib] |
|
havoc_inductive [Formula.Logic] |
|
havoc_inductive [Datalib.Create] |
|
havoc_region [CfgWeakestPrecondition.Create] |
|
havoc_static [Formula.Logic] |
|
havoc_static [Datalib.Create] |
|
help_array_reference_pattern_term [Variables_analysis] |
|
help_by_array_reference_pattern [Variables_analysis] |
|
hooks [Wprop.Indexed] |
|
huge_pred [Formula.S] |
|
huge_pred [Fol_formula] |
|
huge_pred [Fol] |
|
huge_term [Formula.S] |
|
huge_term [Fol_formula] |
|
huge_term [Fol] |
|
I |
i_add [Formula.S] |
|
i_add [Fol_formula] |
|
i_apply [Fol] |
|
i_bool [LogicLang] |
|
i_bool [Fol_formula] |
|
i_cmp [Mint.S] |
|
i_cmp [Mint_natural.Create] |
|
i_compare [LogicRaw.PRED] |
|
i_compare [LogicRaw.TERM] |
|
i_compare [Fol] |
|
i_compute [LogicRaw.TERM] |
|
i_compute [Fol] |
|
i_convert [Formula.S] |
|
i_convert [Fol_formula] |
|
i_convert [Ctypes] |
|
i_format [Runtime_mem.Create] |
|
i_mult [Formula.S] |
|
i_mult [Fol_formula] |
|
i_neg [Mint.S] |
|
i_neg [Mint_natural.Create] |
|
i_one [Formula.S] |
|
i_one [Fol_formula] |
|
i_op [Mint.S] |
|
i_op [LogicLang] |
|
i_op [Fol_formula] |
|
i_op [Mint_natural.Create] |
|
i_pred [LogicLang] |
|
i_pred [Fol_formula] |
|
i_sizeof [Ctypes] |
All sizes are in bits
|
i_sub [Formula.S] |
|
i_sub [Fol_formula] |
|
i_zero [Formula.S] |
|
i_zero [Fol_formula] |
|
icmp_operator [Translate_expr.Create] |
|
id_prop_txt [WpPropId] |
TODO: this one should be in Properties_status.
|
ident [Script] |
|
ident_named_var [Fol.Var] |
|
identifier [Fol_decl] |
|
identify_loops [Cil2cfg.WeiMaoZouChen] |
|
idents [Script] |
|
idfree [LogicId] |
|
idref [LogicId] |
|
idx [Ctypes] |
|
imemo [Ctypes] |
|
in_range [ACSL] |
|
in_range [LogicHavoc] |
|
in_range [Data_mem.Create] |
|
included [Fol_split.SplitZoneInclusion] |
|
incr [Cil2cfg.LoopInfo] |
|
incr_addr_taken [Variables_analysis] |
|
incr_xi [Cil2cfg.WeiMaoZouChenInput] |
the unstructuredness coefficient k can be computed = 1+(xi+yi)/E
when E is the number of edge in the graph.
|
incr_xi [Cil2cfg.LoopInfo] |
|
incr_yi [Cil2cfg.WeiMaoZouChenInput] |
|
incr_yi [Cil2cfg.LoopInfo] |
|
index [Mvalues.S] |
index tab tau k computes the location
of tab[k] , where tab is an array with elements of type tau .
|
index [Mvalues.Data] |
|
index [Formula.S.Identifiable] |
|
index [LogicHavoc] |
|
index [Fol_formula.Identifiable] |
|
index [Fol_formula.LTinfoId] |
|
index [Fol_formula.ArrayDim] |
|
index [Fol_formula.Cobject] |
|
index [Fol_formula.Logicvar] |
|
index [Fol_formula.LTypeinfo] |
|
index [Fol_formula.Arrayinfo] |
|
index [Fol_formula.Compinfo] |
|
index [Fol_formula.Fieldinfo] |
|
index [Fol_formula.Varinfo] |
|
index [Hoare_mem.Create] |
|
index [Store_mem.Create.Data] |
|
index [Runtime_mem.Create.Data] |
|
index [Funvar_mem.Create] |
|
index [String] |
String.index s c returns the character number of the first
occurrence of character c in string s .
|
index_from [String] |
String.index_from s i c returns the character number of the
first occurrence of character c in string s after position i .
|
indice [LogicId] |
|
init [Cil2cfg.WeiMaoZouChenInput] |
build a new env from a graph,
and also return the entry point of the graph which has to be unique.
|
init [Cil2cfg.LoopInfo] |
|
init_cfg [Cil2cfg] |
|
init_global_variable [Calculus.Cfg] |
|
init_range [Mcfg.S] |
init_range env lv t_elt a b wp :
put default values of type t_elt in lvk with a <= k < b
|
init_range [CfgWeakestPrecondition.Create] |
|
init_range [Cfgpropid.Create] |
|
init_value [Mcfg.S] |
init_value env lv t v_opt wp:
put value of type t (or default if None) in lv
|
init_value [CfgWeakestPrecondition.Create] |
|
init_value [Cfgpropid.Create] |
|
init_value_term [Datalib.Cvalues] |
|
init_value_term_rec [Datalib.Cvalues] |
|
inner_loc [Mlogic.S] |
inner_loc l returns the location corresponding
to l in the inner memory model in funvar.
|
inner_loc [Hoare_mem.Create] |
|
inner_loc [Store_mem.Create.Data] |
|
inner_loc [Runtime_mem.Create.Data] |
|
inner_loc [Funvar_mem.Create] |
|
insert_loop_node [Cil2cfg] |
|
int64_max [Ctypes] |
|
int_cmp [Translate_prop.Create] |
|
int_format [Runtime_mem.Create] |
|
int_format_for_hyp [Runtime_mem.Create] |
|
int_of_data [Store_mem.Create] |
|
int_of_value [Translate_expr.Create] |
|
int_op [Translate_prop.Create] |
|
int_operator [Translate_expr.Create] |
|
integer_of_data [Translate_prop.Create] |
|
integer_of_real [Formula.S] |
|
integer_of_real [Fol_formula] |
|
integer_of_real [Fol_decl] |
|
integer_of_value [Translate_prop.Create] |
|
integer_of_xaddr [Runtime_mem.Create.Tint] |
|
integers [Fol_formula] |
|
inter [Formula.S] |
inter s0 s1 returns the intersection set of s0 and s1 .
|
inter [Fol_formula] |
|
inter [Set.S] |
Set intersection.
|
internal_function_behaviors [WpAnnot] |
|
internal_pretty_code [Datatype.Set] |
|
interval [Formula.S] |
range l h returns the integer set s such as { i in s | l <=
i <= h }.
|
interval [Fol_formula] |
|
inv_of_loop_from [WpFroms] |
Build the from hyp for the loop assigns
|
ip_complete [WpAnnot] |
|
ip_disjoint [WpAnnot] |
|
isHoare [Register.HCriteria] |
|
isHoare [Register.MCriteria] |
|
isHoare [Funvar_mem.Criteria] |
|
isVarTypePointerType [Variables_analysis] |
|
is_annot_for_config [WpAnnot] |
(see test_behav_res above).
|
is_array [Formula.Logic] |
|
is_array [Datalib.Create] |
|
is_assigns [WpPropId] |
|
is_atomic [LogicLang] |
|
is_atomic [LogicRaw.SUBST] |
|
is_back_edge [Cil2cfg] |
|
is_comp [Formula.Logic] |
|
is_comp [Datalib.Create] |
|
is_composed [WpAnnot] |
whether a proof needs several lemma to be complete
|
is_darray [ACSL] |
|
is_defined [Translate_prop.Create.UserAxiomDefs] |
|
is_empty [Hook.S] |
Is no function already registered in the hook?
|
is_empty [CfgWeakestPrecondition.Create] |
|
is_empty [Map.S] |
Test whether a map is empty or not.
|
is_empty [Set.S] |
Test whether a set is empty or not.
|
is_error [Prover.Logs] |
|
is_false [Formula.S] |
|
is_false [Fol_formula] |
|
is_false [Fol] |
|
is_formal_var_type [Variables_analysis] |
|
is_havoc [LogicHavoc] |
|
is_havoc [Runtime_mem.Create.RtLib] |
|
is_incl_comp [Fol_formula] |
|
is_int [ACSL] |
|
is_interactive [Wpo] |
|
is_irreducible [Cil2cfg.LoopInfo] |
|
is_lformal [Variables_analysis] |
|
is_macro [Fol_formula] |
|
is_macro_section [Fol_formula] |
|
is_main_init [WpStrategy] |
The function is the main entry point AND it is not a lib entry
|
is_memvar [Variables_analysis] |
|
is_null [Mvalues.Model] |
Take a term representing an address and returns a
term of type bool .
|
is_null [Hoare_mem.Create.Model] |
|
is_null [Store_mem.Create.Model] |
|
is_null [Runtime_mem.Create.Model] |
|
is_null [Funvar_mem.Create.Model] |
|
is_null [Datalib.Cvalues] |
|
is_out [Wp_parameters] |
|
is_pass1 [Calculus.Cfg.R] |
|
is_proved [WpAnnot] |
wether all partial proofs have been accumulated or not
|
is_pure_logic [Variables_analysis] |
|
is_ref [Variables_analysis] |
|
is_requires [WpPropId] |
|
is_rte_generated [Wp_gui] |
|
is_rte_precond [Wp_gui] |
|
is_simple [Fol_let] |
|
is_stable [LogicDef.Cofix] |
|
is_to_scope [Variables_analysis] |
is_to_scope v returns true if v has to been scoped into the inner
memory model : cvar of ref
|
is_true [Formula.S] |
|
is_true [Fol_formula] |
|
is_true [Fol] |
|
is_user_formal_in_builtin [Variables_analysis] |
is_user_formal_in_builtins lv tests if the address
of the by-reference formal lv of user definition is an argument
of (one or more) ACSL builtin predicate(s) or function :
valid and family, separated, block_length, initialized
|
is_valid [Wpo] |
true if the result is valid.
|
is_void [Ctypes] |
|
is_zone [Fol_split] |
|
iter [LogicRaw.PRED] |
|
iter [LogicRaw.TERM] |
|
iter [LogicId] |
|
iter [Map.S] |
iter f m applies f to all bindings in map m .
|
iter [Wpo.Results] |
|
iter [Hashtbl.S] |
|
iter [Wpo] |
|
iter [Set.S] |
iter f s applies f in turn to all elements of s .
|
iter [String] |
String.iter f s applies function f in turn to all
the characters of s .
|
iter [State_builder.Hashtbl] |
|
iter_all [Formula.S] |
|
iter_all [Fol_formula] |
|
iter_description [Cfgpropid.Create] |
|
iter_dnodes [Cfgpropid] |
|
iter_edges [Cil2cfg] |
|
iter_edges_e [Cil2cfg.Printer] |
|
iter_nodes [Cil2cfg] |
|
iter_on_goals [Wpo] |
Dynamically exported.
|
iter_pred_e [Cil2cfg] |
|
iter_succ [LogicDef.Components.G] |
|
iter_succ [Cil2cfg] |
|
iter_succ_e [Cil2cfg] |
|
iter_vertex [Cil2cfg.Printer] |
|
J |
job [Wp_parameters] |
|
K |
kernel_functions_separation_hyps [Variables_analysis] |
|
key [Script] |
|
keywords [Script] |
|
kill [Formula.Logic] |
|
kill [Datalib.Create] |
|
kill_context [Translate_prop.Create] |
|
kind_equal [Translate_prop.Create] |
|
kind_of [Translate_prop.Create] |
|
kind_of_data [Translate_prop.Create] |
|
kind_of_formal [Variables_analysis] |
|
kind_of_property [Wp_gui] |
|
kind_of_typ [Translate_prop.Create] |
|
kind_of_var [Formula.S] |
|
kind_of_var [Fol_formula] |
|
kind_of_var [Fol.Var] |
|
kind_order [WpPropId] |
|
kind_to_select [WpAnnot] |
|
L |
label [Mcfg.S] |
|
label [CfgWeakestPrecondition.Create] |
|
label [Cfgpropid.Create] |
|
label [Clabels] |
|
label_of_kind [WpPropId] |
|
label_of_prop_id [WpPropId] |
Short description of the kind of PO
|
labels_assert_after [NormAtLabels] |
|
labels_assert_before [NormAtLabels] |
|
labels_axiom [NormAtLabels] |
|
labels_empty [NormAtLabels] |
|
labels_fct_assigns [NormAtLabels] |
|
labels_fct_post [NormAtLabels] |
|
labels_fct_pre [NormAtLabels] |
|
labels_loop_assigns [NormAtLabels] |
|
labels_loop_inv [NormAtLabels] |
|
labels_predicate [NormAtLabels] |
|
labels_stmt_assigns [NormAtLabels] |
|
labels_stmt_post [NormAtLabels] |
|
labels_stmt_pre [NormAtLabels] |
|
language_of_name [Wpo] |
Dynamically exported.
|
language_of_prover [Wpo] |
|
language_of_prover_name [Wpo] |
|
le_int [Fol_decl] |
|
le_int_bool [Fol_decl] |
|
le_loc [Mvalues.Model] |
le_loc p q is the less than or equal comparison
of locs p and q , that points to elements of type ty ,
ie.
|
le_loc [Hoare_mem.Create.Model] |
|
le_loc [Store_mem.Create.Model] |
|
le_loc [Runtime_mem.Create.Model] |
|
le_loc [Funvar_mem.Create.Model] |
|
le_loc [Datalib.Cvalues] |
|
le_loc_bool [Mvalues.Model] |
le_loc_bool p q is the less than or equal comparison
of locs p and q , that points to elements of type ty ,
ie.
|
le_loc_bool [Hoare_mem.Create.Model] |
|
le_loc_bool [Store_mem.Create.Model] |
|
le_loc_bool [Runtime_mem.Create.Model] |
|
le_loc_bool [Funvar_mem.Create.Model] |
|
le_loc_bool [Datalib.Cvalues] |
|
le_real [Fol_decl] |
|
le_real_bool [Fol_decl] |
|
length [Hook.S] |
Number of registered functions.
|
length [Hashtbl.S] |
|
length [String] |
Return the length (number of characters) of the given string.
|
length [State_builder.Hashtbl] |
Length of the table.
|
let_pred [Fol] |
Build a predicate equivalent to let v = e in p but may use the
substitution in some simple cases (like substitute a variable by another
variable for instance).
|
letter [LogicId] |
|
lib_is_int [ACSL] |
|
lib_to_int [ACSL] |
|
library [LogicId] |
Returns an id for an external symbol
|
link [LogicId] |
Link the identifier to some absolute name.
|
list_of [Translate_prop.Create] |
|
load [Mvalues.S] |
|
load [Hoare_mem.Create] |
|
load [Store_mem.Create] |
|
load [Runtime_mem.Create.RtLib] |
|
load [Runtime_mem.Create] |
|
load [Funvar_mem.Create] |
|
load_mem [Mvalues.Data] |
|
load_mem [Store_mem.Create.Data] |
|
load_mem [Store_mem.Create] |
|
load_mem [Runtime_mem.Create.Data] |
Read a data of type te at loc and returns it as a logic value.
|
load_rec [Store_mem.Create.Data] |
|
load_with [Store_mem.Create] |
|
loaded [Data_mem.Create] |
|
loadscripts [Proof] |
Load scripts from -wp-script f .
|
loc_of_data [Translate_prop.Create] |
|
loc_of_term [Mvalues.Model] |
|
loc_of_term [Hoare_mem.Create.Model] |
|
loc_of_term [Store_mem.Create.Model] |
|
loc_of_term [Runtime_mem.Create.Model] |
|
loc_of_term [Funvar_mem.Create.Model] |
|
loc_of_term [Datalib.Cvalues] |
|
loc_of_value [Translate_expr.Create] |
|
loc_offset [Translate_prop.Create] |
|
loc_range [Fol_formula] |
|
local [Wpo] |
|
local_scope [Mwp.S] |
local_scope m l transforms the predicate p at the
enter-point of a block or function that
declares the local variables in the list.
|
local_scope [Hoare_mem.Create] |
|
local_scope [Store_mem.Create] |
|
local_scope [Runtime_mem.Create] |
|
local_scope [Funvar_mem.Create] |
|
location [Formula.S.Identifiable] |
|
location [Fol_formula.Identifiable] |
|
location [Fol_formula.LTinfoId] |
|
location [Fol_formula.ArrayDim] |
|
location [Fol_formula.Cobject] |
|
location [Fol_formula.Logicvar] |
|
location [Fol_formula.LTypeinfo] |
|
location [Fol_formula.Arrayinfo] |
|
location [Fol_formula.Compinfo] |
|
location [Fol_formula.Fieldinfo] |
|
location [Fol_formula.Varinfo] |
|
lock [Translate_prop.Create.UserDefinition] |
|
lock [LogicDef] |
|
locked [Fol_formula] |
|
log_status [Prover.Logs] |
|
logic_of_value [Mvalues.Values] |
|
logic_of_value [Datalib.Cvalues] |
|
logic_offset [Translate_prop.Create] |
|
logic_param_memory_info [Variables_analysis] |
|
lookup [LogicDef.Cofix] |
|
lookup [LogicDef] |
|
lookup [Clabels] |
lookup bindings lparam retrieves the actual label
for the label in bindings for label parameter lparam .
|
lookup_called_preconditions_at [WpAnnot] |
|
loop_head_label [Clabels] |
|
loop_nodes [Cil2cfg] |
|
loop_with_cut [Calculus.Cfg] |
|
lowercase [String] |
Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
|
lt_int [Fol_decl] |
|
lt_int_bool [Fol_decl] |
|
lt_loc [Mvalues.Model] |
lt_loc p q is the less than comparison
of locs p and q , that points to elements of type ty ,
ie.
|
lt_loc [Hoare_mem.Create.Model] |
|
lt_loc [Store_mem.Create.Model] |
|
lt_loc [Runtime_mem.Create.Model] |
|
lt_loc [Funvar_mem.Create.Model] |
|
lt_loc [Datalib.Cvalues] |
|
lt_loc_bool [Mvalues.Model] |
lt_loc_bool p q is the less than comparison
of locs p and q , that points to elements of type ty ,
ie.
|
lt_loc_bool [Hoare_mem.Create.Model] |
|
lt_loc_bool [Store_mem.Create.Model] |
|
lt_loc_bool [Runtime_mem.Create.Model] |
|
lt_loc_bool [Funvar_mem.Create.Model] |
|
lt_loc_bool [Datalib.Cvalues] |
|
lt_real [Fol_decl] |
|
lt_real_bool [Fol_decl] |
|
lvar [Mlogic.S] |
lvar m lv p returns a location associated to the
location variable lv with variable root name x .
|
lvar [Translate_prop.Create] |
|
lvar [Hoare_mem.Create] |
|
lvar [Store_mem.Create.Data] |
|
lvar [Runtime_mem.Create.Data] |
|
lvar [Funvar_mem.Create] |
|
M |
main [Wp_gui] |
|
main [Register] |
|
make [Prover.PO] |
|
make [String] |
String.make n c returns a fresh string of length n ,
filled with the character c .
|
make_array [Funvar_mem.Create] |
|
make_c_float [Ctypes] |
|
make_c_int [Ctypes] |
|
make_goal [Cfgpropid.Create] |
|
make_gui_dir [Wp_parameters] |
|
make_logic_info [WpFroms] |
Build a logic_info with fname and the signature given by
(out_type, in_types) (see WpFroms.mk_linfo_type )
TODO: should be Cil_const.make_logic_info when it be finished.
|
make_output_dir [Wp_parameters] |
|
make_panel [Po_navigator] |
|
make_tmp_dir [Wp_parameters] |
|
map [Map.S] |
map f m returns a map with same domain as m , where the
associated value a of all bindings of m has been
replaced by the result of the application of f to a .
|
mapi [Map.S] |
Same as Map.S.map , but the function receives as arguments both the
key and the associated value for each binding of the map.
|
mark [LogicId] |
|
mark_history [LogicDef] |
|
mark_loops [Cil2cfg] |
|
massigned [Funvar_mem.Create] |
|
matrix [LogicHavoc] |
|
max_binding [Map.S] |
|
max_elt [Set.S] |
Same as Set.S.min_elt , but returns the largest element of the
given set.
|
mcvar [Funvar_mem.Create.Lookup] |
|
mem [Mvalues.S] |
|
mem [Hoare_mem.Create] |
|
mem [Store_mem.Create.Data] |
|
mem [Runtime_mem.Create] |
|
mem [Funvar_mem.Create] |
|
mem [Map.S] |
mem x m returns true if m contains a binding for x ,
and false otherwise.
|
mem [Hashtbl.S] |
|
mem [Set.S] |
mem x s tests whether x belongs to the set s .
|
mem [Wprop.Indexed2] |
|
mem [State_builder.Hashtbl] |
|
mem [Wprop.Indexed] |
|
mem_at [Translate_prop.Create] |
|
mem_at_env [Translate_prop.Create] |
|
mem_project [Datatype.Set] |
|
memo [Datatype.Hashtbl] |
memo tbl k f returns the binding of k in tbl .
|
memo [State_builder.Hashtbl] |
Memoization.
|
memory_offset [Translate_prop.Create] |
|
merge [Mcfg.S] |
|
merge [CfgWeakestPrecondition.Create] |
|
merge [Cfgpropid.Create] |
|
merge [LogicHavoc] |
|
merge [Map.S] |
merge f m1 m2 computes a map whose keys is a subset of keys of m1
and of m2 .
|
merge_acc [WpStrategy] |
|
merge_assign_info [WpPropId] |
|
merge_assigns [CfgWeakestPrecondition.Create] |
|
merge_fields [LogicHavoc] |
|
merge_property [CfgWeakestPrecondition.Create] |
|
merge_signature [LogicHavoc] |
|
merge_with [CfgWeakestPrecondition.Create] |
|
min_binding [Map.S] |
Return the smallest binding of the given map
(with respect to the Ord.compare ordering), or raise
Not_found if the map is empty.
|
min_elt [Set.S] |
Return the smallest element of the given set
(with respect to the Ord.compare ordering), or raise
Not_found if the set is empty.
|
minus_loc [Mvalues.Model] |
minus_loc ty p q is the arithmetics difference of
locs p and q , that points to elements of type ty ,
ie.
|
minus_loc [Hoare_mem.Create.Model] |
|
minus_loc [Store_mem.Create.Model] |
|
minus_loc [Runtime_mem.Create.Model] |
|
minus_loc [Funvar_mem.Create.Model] |
|
minus_loc [Datalib.Cvalues] |
|
missing_rte [WpAnnot] |
|
mk [Fol.Var] |
|
mk_annot_id [WpPropId] |
|
mk_aref [Funvar_mem.Create] |
|
mk_assert_id [WpPropId] |
|
mk_assign_post [WpFroms] |
Build P(out) where out is the left part of the assigns property.
|
mk_assign_pre [WpFroms] |
Build xi = Init (i) /\ ... forall inputs part of the assigns property.
|
mk_assigns_info [WpPropId] |
|
mk_axiom_id [WpPropId] |
axiom identification
|
mk_axiom_info [WpPropId] |
|
mk_bhv_from_id [WpPropId] |
\from property of function or statement behavior assigns
|
mk_bhv_implicit_fun_name [WpFroms] |
|
mk_call_pre_id [WpAnnot] |
|
mk_call_pre_id [WpPropId] |
mk_call_pre_id called_kf s_call called_pre
|
mk_code_annot_id [WpPropId] |
|
mk_compl_bhv_id [WpPropId] |
complete behaviors property.
|
mk_decrease_id [WpPropId] |
|
mk_def [Fol_cc] |
|
mk_disj_bhv_id [WpPropId] |
disjoint behaviors property.
|
mk_empty [Fol_decl] |
|
mk_establish_id [WpPropId] |
Invariant establishment
|
mk_fct_assigns_id [WpPropId] |
function assigns
|
mk_fct_from_id [WpPropId] |
|
mk_fct_post_id [WpPropId] |
|
mk_fformat [Runtime_mem.Create] |
|
mk_fguard [Fol_decl] |
|
mk_iformat [Runtime_mem.Create] |
|
mk_iguard [Fol_decl] |
|
mk_imodulo [Fol_decl] |
|
mk_integers [Fol_decl] |
|
mk_inter [Fol_decl] |
|
mk_inv_hyp_id [WpPropId] |
Invariant used as hypothesis
|
mk_kf_any_assigns_info [WpPropId] |
|
mk_kf_assigns_desc [WpPropId] |
|
mk_linfo_type [WpFroms] |
Build the logic type of the function that takes parameters of in_types
and return an out_type result (None for a predicate)
|
mk_logic_label [Clabels] |
create a virtual label to a statement (it can have no label)
|
mk_loop_any_assigns_info [WpPropId] |
|
mk_loop_assigns_desc [WpPropId] |
|
mk_loop_assigns_id [WpPropId] |
|
mk_loop_from_id [WpPropId] |
\from property of loop assigns
|
mk_loop_implicit_fun_name [WpFroms] |
|
mk_loop_label [Clabels] |
|
mk_name [WpFroms] |
Build a full qualified name for logic_info about the nth from in the b
behavior of the kf function.
|
mk_new [WpFroms.Vars] |
|
mk_part [WpPropId] |
mk_part pid (k, n) build the identification for the k/n part of pid .
|
mk_path [Funvar_mem.Create] |
|
mk_pre_id [WpPropId] |
|
mk_pred_info [WpPropId] |
|
mk_pref [Funvar_mem.Create] |
|
mk_preserve_id [WpPropId] |
Invariant preservation
|
mk_prop [WpPropId] |
|
mk_radd [Fol_decl] |
|
mk_range [Fol_decl] |
|
mk_range_inf [Fol_decl] |
|
mk_range_sup [Fol_decl] |
|
mk_remove [Fol_decl] |
|
mk_rmult [Fol_decl] |
|
mk_rneg [Fol_decl] |
|
mk_singleton [Fol_decl] |
|
mk_stmt_any_assigns_info [WpPropId] |
|
mk_stmt_assigns_desc [WpPropId] |
|
mk_stmt_assigns_id [WpPropId] |
|
mk_stmt_label [Clabels] |
|
mk_stmt_post_id [WpPropId] |
|
mk_strategy [WpStrategy] |
|
mk_strategy_for_fct_from [WpFroms] |
|
mk_union [Fol_decl] |
|
mk_var_decr_id [WpPropId] |
Variant decrease
|
mk_var_pos_id [WpPropId] |
Variant positive
|
mk_variant_properties [WpStrategy] |
|
mk_xzone [Runtime_mem.Create.Tint] |
|
mloc_of_loc [Funvar_mem.Create.Model] |
|
mloc_of_path [Funvar_mem.Create.Lookup] |
|
mod_int [Fol_decl] |
|
model_access_range [Store_mem.Create] |
|
model_addr [Store_mem.Create] |
|
model_addr_shift [Store_mem.Create] |
|
model_age [LogicDef] |
|
model_alloc [Store_mem.Create] |
|
model_base [Hoare_mem.Create] |
|
model_base [Store_mem.Create] |
|
model_block [Store_mem.Create] |
|
model_free [Store_mem.Create] |
|
model_included [Store_mem.Create] |
|
model_isfresh [Store_mem.Create] |
|
model_ishavoc [Store_mem.Create] |
|
model_names [Wp_parameters] |
|
model_of_name [Wp_parameters] |
|
model_offset [Hoare_mem.Create] |
|
model_offset [Store_mem.Create] |
|
model_ptr [Hoare_mem.Create] |
|
model_range [Hoare_mem.Create] |
|
model_range_of_ptr [Hoare_mem.Create] |
|
model_range_of_ptr_range [Hoare_mem.Create] |
|
model_rbase [Hoare_mem.Create] |
|
model_roffset [Hoare_mem.Create] |
|
model_separated [Hoare_mem.Create] |
|
model_separated [Store_mem.Create] |
|
model_shift [Hoare_mem.Create] |
|
model_update_havoc [Store_mem.Create] |
|
model_update_range [Store_mem.Create] |
|
model_valid [Hoare_mem.Create] |
|
model_valid [Store_mem.Create] |
|
model_zempty [Store_mem.Create] |
|
model_zrange [Store_mem.Create] |
|
model_zrange_of_addr_range [Store_mem.Create] |
|
model_zunion [Store_mem.Create] |
|
modulo [Formula.S] |
|
modulo [Fol_formula] |
|
most_suitable [Proof] |
|
mul_int [Fol_decl] |
|
mul_real [Fol_decl] |
|
mult [Runtime_mem.Create.Aint] |
|
mult_set [Formula.S] |
|
mult_set [Fol_formula] |
|
mvalue_of_value [Funvar_mem.Create] |
|
N |
n_size [Hoare_mem.Create] |
|
n_size [Store_mem.Create] |
|
name [CfgProof.Description] |
Public name for user feedback
|
name [ACSL.Compiler] |
|
name [LogicId] |
Assigns a unique string to an identifier in the space.
|
name [Wp_error] |
|
name [Datatype.Set] |
|
name_of_adt [Fol_decl.Tau] |
|
name_of_asked_bhv [WpAnnot] |
|
name_of_field [Runtime_mem.Create] |
|
name_of_prop_id [WpPropId] |
Short description of the PO
|
name_of_var [Formula.S] |
|
name_of_var [Fol_formula] |
|
name_of_var [Runtime_mem.Create] |
|
names_at [Clabels] |
|
ne_int [Fol_decl] |
|
ne_int_bool [Fol_decl] |
|
ne_real [Fol_decl] |
|
ne_real_bool [Fol_decl] |
|
needback [Proof] |
|
needsave [Proof] |
|
neg_int [Fol_decl] |
|
neg_interval [Translate_prop.Create] |
|
neg_real [Fol_decl] |
|
neg_set [Formula.S] |
|
neg_set [Fol_formula] |
|
new_cfg_env [Cil2cfg] |
|
new_env [Mcfg.S] |
optionally init env with user logic variables
|
new_env [CfgWeakestPrecondition.Create] |
|
new_env [Cfgpropid.Create] |
|
new_env [Wpo] |
Generates a fresh environment name.
|
new_fname [Fol_eval] |
|
new_frame [Translate_prop.Create] |
|
new_loop_computation [WpStrategy] |
|
new_name [Fol_cc] |
|
new_vars [WpFroms.Vars] |
|
newline [Script] |
|
next_edge [Cil2cfg] |
|
no_infinite_array [Ctypes] |
|
no_quantif_do_exp [Fol] |
|
node_after [Cil2cfg] |
Find the node that follows the input node statement.
|
node_id [Cil2cfg] |
|
node_stmt_exn [Cil2cfg] |
|
node_stmt_opt [Cil2cfg] |
|
node_type [Cil2cfg] |
|
node_type_id [Cil2cfg] |
gives a identifier to each CFG node in order to hash them
|
not_arg_computed [Variables_analysis] |
|
not_computed [Variables_analysis] |
|
not_half_computed [Variables_analysis] |
|
not_of_float [Translate_expr.Create] |
|
not_of_int [Translate_expr.Create] |
|
not_of_integer [Translate_expr.Create] |
|
not_of_loc [Translate_expr.Create] |
|
not_of_value [Translate_expr.Create] |
|
not_param_computed [Variables_analysis] |
|
not_yet_implemented [Wp_error] |
|
notexists_vars [Hoare_mem.Create] |
|
notexists_vars [Store_mem.Create] |
|
null [Mvalues.Model] |
null return the special location of the memory model designing
the null loc.
|
null [Hoare_mem.Create.Model] |
|
null [Store_mem.Create.Model] |
|
null [Runtime_mem.Create.Model] |
|
null [Funvar_mem.Create.Model] |
|
null [Datalib.Cvalues] |
|
num_of_bhv_from [WpPropId] |
|
O |
object_array_of_root [Funvar_mem.Create.Lookup] |
|
object_of [Ctypes] |
|
object_of_array_elem [Ctypes] |
Utilities
|
object_of_loc [Store_mem.Create.Model] |
|
object_of_n_pointed [Funvar_mem.Create.Lookup] |
|
object_of_n_pointed_opt [Funvar_mem.Create.Lookup] |
|
object_of_pointed [Translate_prop.Create] |
|
object_of_pointed [Ctypes] |
c_objects of elements pointed to by pointer or array.
|
object_of_pointed_opt [Funvar_mem.Create.Lookup] |
|
object_of_root [Funvar_mem.Create.Lookup] |
|
obtain [ACSL.Register] |
Projectified and memoized C.compile .
|
obtain [LogicDef.Cofix] |
|
of_int [Runtime_mem.Create.Aint] |
|
of_int64 [Runtime_mem.Create.Aint] |
|
of_name [Prover.SMT] |
|
of_term [Runtime_mem.Create.Aint] |
|
offset [Hoare_mem.Create.Model] |
|
offset [Hoare_mem.Create] |
|
offset [Store_mem.Create.Data] |
|
offset [Store_mem.Create.Model] |
|
offset_of_field [Hoare_mem.Create] |
|
offset_of_field [Store_mem.Create] |
|
ok_array_term [Variables_analysis] |
|
ok_array_term_arg [Variables_analysis] |
|
ok_array_term_formal [Variables_analysis] |
|
ok_pointer_term [Variables_analysis] |
|
ok_ptr_term_arg [Variables_analysis] |
|
ok_ptr_term_formal [Variables_analysis] |
|
on_all_functions [Register] |
|
on_array [Data_mem.Create.Compound] |
|
on_clear [Formula.S] |
|
on_clear [Fol_formula] |
|
on_context [CfgWeakestPrecondition.Create] |
|
on_definition [Formula.S.Registry] |
|
on_definition [Register] |
|
on_definition [Fol_formula.Registry] |
|
on_definition [Fol_formula.DRegister] |
|
on_function [Register] |
|
on_function_names [Register] |
|
on_model [LogicDef] |
|
on_record [Data_mem.Create.Compound] |
|
on_reset [Wp_parameters] |
|
once [Prover.Coq] |
|
only_one_region [LogicHavoc] |
|
op_loc [Funvar_mem.Create.Model] |
|
open_file [Script] |
|
operator_atomic [LogicPretty] |
|
option [Register] |
|
oracle [Funvar_mem] |
|
oracle [Variables_analysis] |
|
output [Prover.Logs] |
|
output_dir [Wp_parameters] |
|
P |
p_alpha_cv [Formula.S] |
easier to use when doing a simple alpha conversion.
|
p_alpha_cv [Fol_formula] |
|
p_alpha_cv [Fol] |
|
p_and [Formula.S] |
|
p_and [LogicLang] |
|
p_and [LogicRaw.PRED] |
|
p_and [Fol_formula] |
|
p_and [Fol] |
|
p_app [Fol] |
|
p_app0 [Formula.S] |
|
p_app0 [Fol_formula] |
|
p_app1 [Formula.S] |
|
p_app1 [Fol_formula] |
|
p_app2 [Formula.S] |
|
p_app2 [Fol_formula] |
|
p_app3 [Formula.S] |
|
p_app3 [Fol_formula] |
|
p_app4 [Formula.S] |
|
p_app4 [Fol_formula] |
|
p_app5 [Formula.S] |
|
p_app5 [Fol_formula] |
|
p_bind [LogicRaw.SUBST] |
|
p_bool [Formula.S] |
|
p_bool [LogicLang] |
|
p_bool [LogicRaw.PRED] |
|
p_bool [Fol_formula] |
|
p_call [Formula.S] |
|
p_call [LogicLang] |
|
p_call [LogicRaw.PRED] |
|
p_call [Fol_formula] |
|
p_closed [Fol] |
|
p_cond [Formula.S] |
|
p_cond [LogicLang] |
|
p_cond [LogicRaw.PRED] |
|
p_cond [Fol_formula] |
|
p_conj [Formula.S] |
|
p_conj [LogicLang] |
|
p_conj [Fol_formula] |
|
p_conj [Fol] |
|
p_disj [Formula.S] |
|
p_disj [LogicLang] |
|
p_disj [Fol_formula] |
|
p_disj [Fol] |
|
p_eq [Formula.S] |
|
p_eq [Fol_formula] |
|
p_eq [Fol] |
|
p_equal [LogicLang] |
|
p_exists [Formula.S] |
|
p_exists [LogicLang] |
|
p_exists [LogicRaw.PRED] |
|
p_exists [Fol_formula] |
|
p_exists [Fol] |
|
p_exists_vars [Fol] |
|
p_false [Formula.S] |
|
p_false [LogicLang] |
|
p_false [Fol_formula] |
|
p_forall [Formula.S] |
|
p_forall [LogicLang] |
|
p_forall [LogicRaw.PRED] |
|
p_forall [Fol_formula] |
|
p_forall [Fol] |
|
p_forall_vars [Fol] |
|
p_fresh [Formula.S] |
|
p_fresh [Fol_formula] |
|
p_freshen [Formula.S] |
|
p_freshen [Fol_formula] |
|
p_goal [LogicLang] |
|
p_has_var [Fol] |
|
p_hasvar [LogicRaw.PRED] |
|
p_hide [LogicLang] |
|
p_icmp [Formula.S] |
|
p_icmp [LogicLang] |
|
p_icmp [Fol_formula] |
|
p_if [Fol] |
|
p_iff [Formula.S] |
|
p_iff [LogicLang] |
|
p_iff [LogicRaw.PRED] |
|
p_iff [Fol_formula] |
|
p_iff [Fol] |
|
p_implies [Formula.S] |
|
p_implies [LogicLang] |
|
p_implies [LogicRaw.PRED] |
|
p_implies [Fol_formula] |
|
p_implies [Fol] |
|
p_let [LogicLang] |
|
p_let [LogicRaw.SUBST] |
|
p_let [LogicRaw.PRED] |
|
p_let [Fol] |
|
p_more_alpha_cv [Formula.S] |
alpha', p' = p_more_alpha_cv alpha p build p' from p by renaming
all the variable v into v' according to the mapping alpha.
|
p_more_alpha_cv [Fol_formula] |
|
p_named [Formula.S] |
|
p_named [LogicLang] |
|
p_named [Fol_formula] |
|
p_named [Fol] |
|
p_neq [Formula.S] |
|
p_neq [LogicLang] |
|
p_neq [Fol_formula] |
|
p_neq [Fol] |
|
p_not [Formula.S] |
|
p_not [LogicLang] |
|
p_not [LogicRaw.PRED] |
|
p_not [Fol_formula] |
|
p_not [Fol] |
|
p_or [Formula.S] |
|
p_or [LogicLang] |
|
p_or [LogicRaw.PRED] |
|
p_or [Fol_formula] |
|
p_or [Fol] |
|
p_prim [LogicRaw.PRED] |
|
p_rcmp [Formula.S] |
|
p_rcmp [LogicLang] |
|
p_rcmp [Fol_formula] |
|
p_shared [LogicLib] |
|
p_subst [Formula.S] |
|
p_subst [Fol_formula] |
|
p_true [Formula.S] |
|
p_true [LogicLang] |
|
p_true [Fol_formula] |
|
p_unfold [Fol_split] |
|
p_xor [Formula.S] |
|
p_xor [LogicLang] |
|
p_xor [LogicRaw.PRED] |
|
p_xor [Fol_formula] |
|
p_xor [Fol] |
|
packed_descr [Datatype.Set] |
|
parse_coqproof [Proof] |
parse_coqproof f parses a coq-file f and fetch the first proof.
|
parse_scripts [Proof] |
parse_scripts f parses all scripts from file f and put them in the database.
|
part_of_item [Fol_formula] |
|
partition [Map.S] |
partition p m returns a pair of maps (m1, m2) , where
m1 contains all the bindings of s that satisfy the
predicate p , and m2 is the map with all the bindings of
s that do not satisfy p .
|
partition [Set.S] |
partition p s returns a pair of sets (s1, s2) , where
s1 is the set of all the elements of s that satisfy the
predicate p , and s2 is the set of all the elements of
s that do not satisfy p .
|
parts_of_id [WpPropId] |
get the 'part' infomation.
|
pcmp_operator [Translate_expr.Create] |
|
pcmp_rel [Translate_expr.Create] |
|
pint_cmp [Translate_prop.Create] |
|
plet_expansion [Fol_eval] |
|
plus [Translate_prop.Create] |
|
plus_interval [Translate_prop.Create] |
|
plus_interval_interval [Translate_prop.Create] |
|
pointed_of_arity [Funvar_mem.Create] |
|
pointed_of_n_path [Funvar_mem.Create.Lookup] |
|
pointed_of_path [Funvar_mem.Create.Lookup] |
|
pool [Formula.Logic] |
|
pool [Formula.S] |
|
pool [LogicLang] |
|
pool [LogicRaw.VAR] |
|
pool [Fol_formula] |
|
pool [Datalib.Create] |
|
pop [Formula.Logic] |
|
pop [LogicDef.Cofix] |
|
pop [LogicId] |
|
pop [Datalib.Create] |
|
pop [Datalib.Collector] |
|
post_of_spec_assigns [WpFroms] |
For each behavior of the specification, and for each \from in the behavior,
return a predicate which is assumes => out_i = implicit_fun_i (inputs) .
|
pp_addr [Runtime_mem.Create.Tint] |
|
pp_annots [WpStrategy] |
|
pp_apply_call [LogicPretty] |
Printts "(f x1 ... xn)" of "f" for empty list.
|
pp_args [Fol_coq] |
|
pp_args [Fol_ergo] |
|
pp_asked_prop [WpAnnot] |
|
pp_assign_info [WpPropId] |
|
pp_assigns [Wp_error] |
|
pp_assigns_desc [WpPropId] |
|
pp_assigns_id [WpPropId] |
|
pp_assigns_mode [WpAnnot] |
|
pp_assoc [LogicPretty] |
pp_assoc "0" "+" produces "x1 + x2 + ... + xn" and "0" for empty list
|
pp_axiom_info [WpPropId] |
|
pp_axiomdef_descr [Translate_prop.Create.UserAxiomDefs] |
|
pp_axiomdef_title [Translate_prop.Create.UserAxiomDefs] |
|
pp_bkind [Cil2cfg] |
|
pp_block [Fol_coq] |
|
pp_block [Fol_ergo] |
|
pp_block [Fol_pretty] |
|
pp_block_implies [Fol_pretty] |
|
pp_call [Variables_analysis] |
|
pp_call_style [LogicPretty] |
|
pp_chaincall [Variables_analysis] |
|
pp_closure [Mlogic.S] |
|
pp_closure [Hoare_mem.Create] |
|
pp_closure [Store_mem.Create] |
|
pp_closure [Runtime_mem.Create] |
|
pp_closure [Funvar_mem.Create] |
|
pp_closures [Translate_prop.Create] |
|
pp_coma [LogicPretty] |
pp_coma "," produces "x1, x2, ... xn"
|
pp_command [Prover.Logs] |
|
pp_ctype [Fol_formula] |
|
pp_current [Prover.Logs] |
|
pp_data [Translate_prop.Create] |
|
pp_decl [Formula.S] |
|
pp_decl [Fol_formula] |
|
pp_depend [Wpo] |
|
pp_dependency [Wpo] |
|
pp_descr [Formula.S.Identifiable] |
|
pp_descr [Cfgpropid.Create] |
|
pp_descr [Fol_formula.Identifiable] |
|
pp_descr [Fol_formula.LTinfoId] |
|
pp_descr [Fol_formula.ArrayDim] |
|
pp_descr [Fol_formula.Cobject] |
|
pp_descr [Fol_formula.Logicvar] |
|
pp_descr [Fol_formula.LTypeinfo] |
|
pp_descr [Fol_formula.Arrayinfo] |
|
pp_descr [Fol_formula.Compinfo] |
|
pp_descr [Fol_formula.Fieldinfo] |
|
pp_descr [Fol_formula.Varinfo] |
|
pp_dim [Fol_formula] |
|
pp_dnode [Cfgpropid] |
|
pp_edge [Cil2cfg] |
|
pp_environment [Wpo] |
|
pp_err [WpFroms] |
|
pp_float [Ctypes] |
|
pp_flow [Fol_coq] |
|
pp_flow [Fol_ergo] |
|
pp_flow [Fol_pretty] |
|
pp_fold_apply [LogicPretty] |
pp_fold_apply "e" "f" prints "(f x (f...(f y z)))" or "e" .
|
pp_fold_call [LogicPretty] |
pp_fold_call "e" "f" prints "f(x,f(...,f(y,z)))" or "e" .
|
pp_fold_op [LogicPretty] |
pp_fold_op "0" "+" prints "x+(...(y+z))" or "0" .
|
pp_formal [Mlogic.S] |
|
pp_formal [Hoare_mem.Create] |
|
pp_formal [Store_mem.Create] |
|
pp_formal [Runtime_mem.Create] |
|
pp_formal [Funvar_mem.Create] |
|
pp_formal_simple [Funvar_mem.Create] |
|
pp_formals [Translate_prop.Create] |
|
pp_formals [Variables_analysis] |
|
pp_function [Wpo] |
|
pp_goal [Formula.S] |
|
pp_goal [Cfgpropid.Create] |
|
pp_goal [Fol_formula] |
|
pp_goal [Wpo] |
|
pp_goal_flow [Wpo] |
|
pp_goal_kind [WpPropId] |
|
pp_goal_part [WpPropId] |
|
pp_goalx [Cfgpropid.Create] |
|
pp_id [LogicId] |
Combines name and Format .
|
pp_id_name [WpPropId] |
|
pp_info_of_strategy [WpStrategy] |
|
pp_int [Ctypes] |
|
pp_interval [Formula.S] |
|
pp_interval [Fol_formula] |
|
pp_kind [Translate_prop.Create] |
|
pp_labels [Translate_prop.Create.UserAxiomDefs] |
|
pp_language [Wpo] |
|
pp_list [Cfgpropid] |
|
pp_list [Fol_coq] |
|
pp_list [Fol_ergo] |
|
pp_list [Fol_pretty] |
|
pp_loc [Mvalues.Model] |
|
pp_loc [Hoare_mem.Create.Model] |
|
pp_loc [Store_mem.Create.Model] |
|
pp_loc [Runtime_mem.Create.Model] |
|
pp_loc [Funvar_mem.Create.Model] |
|
pp_loc [Datalib.Cvalues] |
|
pp_logic_label [Wp_error] |
|
pp_names [WpPropId] |
|
pp_node [Cil2cfg] |
|
pp_node_type [Cil2cfg] |
|
pp_object [Ctypes] |
|
pp_param [Fol_coq] |
|
pp_param [Fol_ergo] |
|
pp_param [Fol_pretty] |
|
pp_path [Funvar_mem.Create.Lookup] |
|
pp_pred [Formula.S] |
|
pp_pred [LogicLang] |
|
pp_pred [Fol_formula] |
|
pp_pred_atom [Fol_formula] |
|
pp_pred_atom [Fol_coq.ECoq] |
|
pp_pred_atom [Fol_ergo] |
|
pp_pred_atom [Fol_why.EWhy] |
|
pp_pred_debug [Fol_formula] |
|
pp_pred_info [WpPropId] |
|
pp_pred_of_pred_info [WpPropId] |
|
pp_pred_vbox [Fol_formula] |
|
pp_prover [Wpo] |
|
pp_ref [Funvar_mem.Create.Model] |
|
pp_result [Wpo] |
|
pp_root [Funvar_mem.Create.Lookup] |
|
pp_section [Formula.S] |
|
pp_section [Fol_formula] |
|
pp_section [Fol_pretty] |
|
pp_status [Prover.Logs] |
|
pp_strategy_info [WpAnnot] |
|
pp_string [LogicPretty] |
The %t printer that print the string
|
pp_string_list [Wp_error] |
|
pp_tau [Mvalues.Values] |
|
pp_tau [Formula.S] |
Be careful, this one is only used for debuging message!
Do not use for extraction
|
pp_tau [LogicLang] |
|
pp_tau [Fol_formula] |
|
pp_tau [Fol_pretty] |
|
pp_tau [Fol_decl.Tau] |
|
pp_tau [Datalib.Cvalues] |
|
pp_term [Formula.S] |
|
pp_term [LogicLang] |
|
pp_term [Fol_formula] |
|
pp_term [Fol] |
|
pp_title [Formula.S.Identifiable] |
|
pp_title [Fol_formula.Identifiable] |
|
pp_title [Fol_formula.LTinfoId] |
|
pp_title [Fol_formula.ArrayDim] |
|
pp_title [Fol_formula.Cobject] |
|
pp_title [Fol_formula.Logicvar] |
|
pp_title [Fol_formula.LTypeinfo] |
|
pp_title [Fol_formula.Arrayinfo] |
|
pp_title [Fol_formula.Compinfo] |
|
pp_title [Fol_formula.Fieldinfo] |
|
pp_title [Fol_formula.Varaddr] |
|
pp_title [Fol_formula.Varinfo] |
|
pp_token [Script] |
|
pp_tuple [LogicPretty] |
pp_tuple produces "(x1, x2, ... )" and "()" for empty list
|
pp_tuple_call [LogicPretty] |
Prints "f(x1,...,xn)" and "f()" for empty list.
|
pp_typelist [Fol_coq] |
|
pp_userdef_descr [Translate_prop.Create.UserDefinition] |
|
pp_userdef_title [Translate_prop.Create.UserDefinition] |
|
pp_userformals [Translate_prop.Create.UserDefinition] |
|
pp_value [Mvalues.Values] |
|
pp_value [Datalib.Cvalues] |
|
pp_var [Formula.S] |
|
pp_var [Fol_formula] |
|
pp_var [Fol_coq] |
|
pp_var [Fol_ergo] |
|
pp_var [Fol_pretty] |
|
pp_var_type [Variables_analysis] |
|
pp_vars [CfgWeakestPrecondition.Create] |
|
pp_vkind [Formula.S] |
|
pp_vkind [Fol_formula] |
|
pp_warning [Wpo] |
|
pp_xzone [Runtime_mem.Create.Tint] |
|
pre_cond_id [WpAnnot] |
|
preal_cmp [Translate_prop.Create] |
|
precondition_compute [Variables_analysis] |
precondition_compute () adds warnings and precondition suitable
to the current optimisations which are activated
|
pred [Fol_eqs] |
|
pred [Fol_let] |
|
pred_alpha_cv [Fol] |
pred_alpha_c data_alpha alpha p -> alpha', p'
|
pred_calls [Formula.S] |
|
pred_calls [Fol_formula] |
|
pred_calls [Fol] |
|
pred_closed [Formula.S] |
|
pred_closed [Fol_formula] |
|
pred_cmp [Translate_prop.Create] |
|
pred_e [Cil2cfg] |
|
pred_filter [Translate_prop.Create] |
|
pred_has_var [Formula.S] |
|
pred_has_var [Fol_formula] |
|
pred_info_id [WpPropId] |
|
pred_replace [Fol] |
|
predicate [CfgWeakestPrecondition.Create] |
|
predicate_kind_txt [WpPropId] |
|
predop [LogicLang] |
|
predop [Fol_formula] |
|
prefix [Formula.S.Identifiable] |
|
prefix [Fol_formula.Identifiable] |
|
prefix [Fol_formula.LTinfoId] |
|
prefix [Fol_formula.ArrayDim] |
|
prefix [Fol_formula.Cobject] |
|
prefix [Fol_formula.Logicvar] |
|
prefix [Fol_formula.LTypeinfo] |
|
prefix [Fol_formula.Arrayinfo] |
|
prefix [Fol_formula.Compinfo] |
|
prefix [Fol_formula.Fieldinfo] |
|
prefix [Fol_formula.Varaddr] |
|
prefix [Fol_formula.Varinfo] |
|
preproc_annot [NormAtLabels] |
|
preproc_assigns [NormAtLabels] |
|
preproc_label [NormAtLabels] |
|
pretty [Mcfg.S] |
|
pretty [CfgWeakestPrecondition.Create] |
|
pretty [Cfgpropid.Create] |
|
pretty [LogicLang] |
|
pretty [LogicRaw.VAR] |
|
pretty [LogicId.S] |
|
pretty [WpPropId] |
|
pretty [Cil2cfg.EL] |
|
pretty [Cil2cfg.VL] |
|
pretty [Clabels] |
|
pretty [Ctypes] |
|
pretty [Datatype.Set] |
|
pretty_code [Datatype.Set] |
|
pretty_context [WpPropId] |
|
pretty_node [Cil2cfg.WeiMaoZouChenInput] |
|
pretty_node [Cil2cfg.LoopInfo] |
|
pretty_raw_stmt [Cil2cfg.Printer] |
|
process_global_init [Calculus.Cfg] |
|
process_unreached_annots [WpAnnot] |
|
promote [Ctypes] |
|
proof [Prover.Coq] |
|
proof [Script] |
|
prop [Translate_prop.Create] |
prop e p interprets an ACSL predicate as a logic predicats
in memory model environment e .
|
prop [Translate_expr.Create] |
prop mem e interprets the expressione as a predicate
in memory mem *
|
prop_binop [Translate_expr.Create] |
|
prop_body [Translate_prop.Create] |
|
prop_cast [Translate_expr.Create] |
|
prop_cmp [Translate_expr.Create] |
|
prop_cmp_ptr [Translate_expr.Create] |
|
prop_const [Translate_expr.Create] |
|
prop_icmp [Translate_expr.Create] |
|
prop_id_name [WpPropId] |
|
prop_of_float [Translate_expr.Create] |
|
prop_of_int [Translate_expr.Create] |
|
prop_of_integer [Translate_expr.Create] |
|
prop_of_loc [Translate_expr.Create] |
|
prop_of_value [Translate_expr.Create] |
|
prop_rcmp [Translate_expr.Create] |
|
prop_rec [Translate_expr.Create] |
|
prop_unop [Translate_expr.Create] |
|
property [Wprop.Info] |
|
property [Wprop.Indexed2] |
|
property [Wprop.Indexed] |
|
property_of_id [Register] |
|
property_of_id [WpPropId] |
returns the annotation which lead to the given PO.
|
protect [Wp_error] |
|
protect_function [Wp_error] |
|
protect_map [Wp_error] |
|
protect_translation [Wp_error] |
|
protect_translation3 [Wp_error] |
|
protect_translation4 [Wp_error] |
|
protect_translation5 [Wp_error] |
|
protect_warning [Wp_error] |
|
protected [Wp_error] |
|
prove [Prover.Coqide] |
|
prove [Prover.Coq] |
|
prove [Prover.AltErgo] |
|
prove [Prover.SMT] |
|
prove [Prover] |
|
prover_names [Wp_parameters] |
|
prover_of_name [Wpo] |
|
ptr [Hoare_mem.Create.Model] |
|
ptr_cmp [Translate_prop.Create] |
|
ptr_reference [Variables_analysis] |
|
ptr_rel [Translate_prop.Create] |
|
push [Formula.Logic] |
|
push [LogicDef.Cofix] |
|
push [LogicId] |
|
push [Datalib.Create] |
|
push [Datalib.Collector] |
|
push_context [Translate_prop.Create] |
|
Q |
quantify [Mwp.S] |
|
quantify [Hoare_mem.Create] |
|
quantify [Store_mem.Create] |
|
quantify [Runtime_mem.Create] |
|
quantify [Funvar_mem.Create] |
|
R |
r_bool [LogicLang] |
|
r_bool [Fol_formula] |
|
r_op [LogicLang] |
|
r_op [Fol_formula] |
|
r_pred [LogicLang] |
|
r_pred [Fol_formula] |
|
r_zero [Formula.S] |
|
r_zero [Fol_formula] |
|
range [LogicHavoc] |
|
range_inf [Fol_formula] |
|
range_of_assignable [Hoare_mem.Create] |
|
range_sup [Fol_formula] |
|
rcontains_from [String] |
String.rcontains_from s stop c tests if character c
appears in s before position stop+1 .
|
real_cmp [Translate_prop.Create] |
|
real_format [Runtime_mem.Create] |
|
real_from_bits [Runtime_mem.Create] |
|
real_of_data [Translate_prop.Create] |
|
real_of_integer [Formula.S] |
|
real_of_integer [Fol_formula] |
|
real_of_integer [Fol_decl] |
|
real_of_value [Translate_prop.Create] |
|
real_op [Translate_prop.Create] |
|
rec_apply_function [Translate_prop.Create] |
|
rec_apply_predicate [Translate_prop.Create] |
|
record_format [Data_mem.Create] |
|
record_of [ACSL] |
|
record_of_data [Translate_prop.Create] |
|
recursive [LogicDef.Cofix] |
|
redef [Fol_let] |
|
reference_parameter_usage [Variables_analysis] |
|
reference_parameter_usage_lval [Variables_analysis] |
|
reference_parameter_usage_term [Variables_analysis] |
|
refresh_current_wpo [Po_navigator] |
|
refresh_panel [Po_navigator] |
To be called when the set of POs has changed
|
refresh_panel_callback [Po_navigator] |
|
refresh_status [Po_navigator] |
To be called when the status of POs has changed
|
refresh_status_callback [Po_navigator] |
|
region [Store_mem.Create] |
|
register [Po_navigator.Prover_Column] |
|
register [LogicDef] |
|
register_prefix [Fol_decl] |
|
register_script [Proof] |
|
rel_op [Translate_prop.Create] |
|
release_env [Wpo] |
Releases the last generated environment name.
|
remove [Formula.S] |
remove s0 s1 returns a set s' such as {b in s' | b in s0
and !(b in s1) }.
|
remove [Fol_formula] |
|
remove [Map.S] |
remove x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
|
remove [Wpo.Results] |
|
remove [Hashtbl.S] |
|
remove [Cil2cfg.HEsig] |
|
remove [Cil2cfg.HE] |
|
remove [Set.S] |
remove x s returns a set containing all elements of s ,
except x .
|
remove [State_builder.Hashtbl] |
|
remove_array_reference_arg [Variables_analysis] |
|
remove_array_reference_param [Variables_analysis] |
|
remove_edge [Cil2cfg] |
|
remove_ptr_reference_arg [Variables_analysis] |
|
remove_ptr_reference_param [Variables_analysis] |
|
replace [Wpo.Results] |
|
replace [Hashtbl.S] |
|
replace [Cil2cfg.HEsig] |
|
replace [Cil2cfg.HE] |
|
replace [State_builder.Hashtbl] |
Add a new binding.
|
reprs [ACSL.Compiler] |
|
reprs [Datatype.Set] |
|
require_env [Prover.Coq] |
|
require_model [Prover.Coq] |
|
require_wp [Prover.Coq] |
|
reserve1 [LogicId] |
|
reserved [LogicId] |
Reserves the given names to avoid clash with generated ones.
|
reserved_prefix_tbl [Fol_decl] |
|
reset [Wp_parameters] |
|
reset_pos [Cil2cfg.WeiMaoZouChenInput] |
reset the position (set the position to 0), but should keep the
information that the node has been seen already.
|
reset_pos [Cil2cfg.LoopInfo] |
|
resetdemon [Wp_parameters] |
|
resolve_addr_taken [Variables_analysis] |
|
resolved_call_chain_arg [Variables_analysis] |
|
resolved_call_chain_param [Variables_analysis] |
|
result [Translate_prop.Create] |
|
result [Prover] |
|
result_compile [Prover.Coq] |
|
result_type [Translate_prop.Create] |
|
return [Mcfg.S] |
|
return [CfgWeakestPrecondition.Create] |
|
return [Cfgpropid.Create] |
|
revert_on_error [Prover.Coq] |
|
rindex [String] |
String.rindex s c returns the character number of the last
occurrence of character c in string s .
|
rindex_from [String] |
String.rindex_from s i c returns the character number of the
last occurrence of character c in string s before position i+1 .
|
root_equal [Funvar_mem.Create.Model] |
|
rt_format_of_ctype [Runtime_mem.Create] |
|
rt_global [Runtime_mem.Create.RtLib] |
|
rt_vsize [Runtime_mem.Create.RtLib] |
|
rte_divMod_status [WpAnnot] |
|
rte_downCast_status [WpAnnot] |
|
rte_find [WpAnnot] |
|
rte_generated [WpAnnot] |
|
rte_memAccess_status [WpAnnot] |
|
rte_precond_status [WpAnnot] |
|
rte_signedOv_status [WpAnnot] |
|
rte_unsignedOv_status [WpAnnot] |
|
rte_wp [WpAnnot] |
|
run [Register] |
Use options to know what to do
|
run_and_prove [Wp_gui] |
|
run_coqide [Prover.Coqide] |
|
S |
s_index [Fol_formula] |
|
s_of_data [Store_mem.Create] |
|
same_edge [Cil2cfg] |
|
same_node [Cil2cfg] |
|
savescripts [Proof] |
If necessary, dump the scripts database into the file
specified by -wp-script f .
|
scc_roots [LogicDef.Components] |
|
scope [Mcfg.S] |
|
scope [CfgWeakestPrecondition.Create] |
|
scope [Cfgpropid.Create] |
|
script_for [Prover.Coq] |
|
scriptbase [Proof] |
|
scriptfile [Proof] |
|
section [Formula.S.Declarator] |
|
section [Fol_formula.Declarator] |
|
seed [Fol_formula] |
|
select_by_name [WpPropId] |
test if the prop_id has to be selected for the asked name.
|
select_call_pre [WpPropId] |
test if the prop_id has to be selected when we want to select the call
precondition the the stmt call (None means all the call preconditions).
|
separated [Mlogic.S] |
|
separated [Hoare_mem.Create] |
|
separated [Store_mem.Create] |
|
separated [Runtime_mem.Create] |
|
separated [Funvar_mem.Create] |
|
server [Prover] |
|
set [Calculus.Cfg.R] |
store the result p for the computation of the edge e.
|
set [String] |
String.set s n c modifies string s in place,
replacing the character number n by c .
|
set [State_builder.Ref] |
Change the referenced value.
|
set_back_edge [Cil2cfg] |
|
set_field [Fol_ergo] |
|
set_field [Fol_pretty] |
|
set_iloop_header [Cil2cfg.WeiMaoZouChenInput] |
set_iloop_header env b h store h as the innermost loop header for b.
|
set_iloop_header [Cil2cfg.LoopInfo] |
|
set_model [Wp_error] |
|
set_of [Translate_prop.Create] |
|
set_of_list [Formula.S] |
|
set_of_list [Fol_formula] |
|
set_po_result [Wpo] |
|
set_pos [Cil2cfg.WeiMaoZouChenInput] |
store the position for the node and also the fact that the node has
been seen
|
set_pos [Cil2cfg.LoopInfo] |
|
set_range_index [Formula.S] |
|
set_range_index [Fol_formula] |
|
set_range_index [Fol_decl] |
|
set_result [Wpo] |
|
set_stable [LogicDef.Cofix] |
|
set_ufield [Fol_coq] |
|
set_unreachable [WpAnnot] |
|
setup_precondition_proxy [WpAnnot] |
|
shared [CfgProof.Description] |
Shared resource basename for the model
|
shift [Mvalues.S] |
shift ptr tau k computes the location
of ptr+k , where ptr is a pointer to a value of type tau .
|
shift [LogicHavoc] |
|
shift [Hoare_mem.Create] |
|
shift [Store_mem.Create.Data] |
|
shift [Runtime_mem.Create.Data] |
|
shift [Funvar_mem.Create] |
|
shift_field [Runtime_mem.Create.Tint] |
|
shift_loc [Translate_expr.Create] |
|
shift_n_elem [Runtime_mem.Create.Tint] |
|
signed [Ctypes] |
true if ikind is signed
|
signed_in_bound [Fol] |
|
simpl [LogicRaw] |
|
simpl [Fol] |
|
simplify [Mcfg.Splitter] |
|
simplify [Fol_split] |
|
simplify [Prover.SMT] |
|
singleton [Formula.S] |
singleton a returns the singleton set containning a .
|
singleton [Fol_formula] |
|
singleton [Map.S] |
singleton x y returns the one-element map that contains a binding y
for x .
|
singleton [Set.S] |
singleton x returns the one-element set containing only x .
|
size_of_int [Runtime_mem.Create.Tint] |
|
size_of_int64 [Runtime_mem.Create.Tint] |
|
sizeof [Hoare_mem.Create] |
|
sizeof [Store_mem.Create] |
|
sizeof_c_object [Runtime_mem.Create] |
|
sizeof_loc [Store_mem.Create.Model] |
|
sizeof_object [Ctypes] |
|
sizeof_path [Funvar_mem.Create.Lookup] |
|
sizeof_poffset [Funvar_mem.Create.Lookup] |
|
skip [Script] |
|
space [LogicLang] |
|
space [LogicId] |
Creates an empty name space (but with the external names).
|
split [Mcfg.Splitter] |
|
split [Fol_split] |
First, unfold zones when method is effect-assigns.
|
split [Map.S] |
split x m returns a triple (l, data, r) , where
l is the map with all the bindings of m whose key
is strictly less than x ;
r is the map with all the bindings of m whose key
is strictly greater than x ;
data is None if m contains no binding for x ,
or Some v if m binds v to x .
|
split [WpAnnot] |
splits a prop_id goals into prop_id parts for each sub-goals
|
split [Set.S] |
split x s returns a triple (l, present, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
present is false if s contains no element equal to x ,
or true if s contains an element equal to x .
|
stack [LogicDef.Cofix] |
|
stack [Datalib.Collector] |
|
stars_exp [Variables_analysis] |
|
stars_lv_typ [Variables_analysis] |
|
stars_term [Variables_analysis] |
|
stars_typ [Variables_analysis] |
|
stars_var_type_typ [Variables_analysis] |
|
start_edge [Cil2cfg] |
get the starting edges
|
start_stmt_of_node [Cil2cfg] |
|
startof [Mvalues.S] |
startof return a pointer to the first element of an array
|
startof [Translate_expr.Create] |
|
startof [Hoare_mem.Create] |
|
startof [Store_mem.Create] |
|
startof [Runtime_mem.Create] |
|
startof [Funvar_mem.Create] |
|
status [Translate_prop.Create] |
|
store [Runtime_mem.Create.RtLib] |
|
store [Runtime_mem.Create] |
|
store [Funvar_mem.Create] |
|
store_mem [Mvalues.Data] |
|
store_mem [Store_mem.Create.Data] |
|
store_mem [Store_mem.Create] |
|
store_mem [Runtime_mem.Create.Data] |
|
store_rec [Store_mem.Create.Data] |
|
store_with [Store_mem.Create] |
|
stored [Data_mem.Create] |
|
strange_loops [Cil2cfg] |
detect is there are non natural loops or natural loops where we didn't
manage to compute back edges (see mark_loops ).
|
strategy_has_asgn_goal [WpStrategy] |
|
strategy_has_prop_goal [WpStrategy] |
|
strategy_kind [WpStrategy] |
|
string_addr [Variables_analysis] |
|
string_of_termination_kind [WpPropId] |
TODO: should probably be somewhere else
|
sub [Runtime_mem.Create.Aint] |
|
sub [String] |
String.sub s start len returns a fresh string of length len ,
containing the substring of s that starts at position start and
has length len .
|
sub_c_float [Ctypes] |
|
sub_c_int [Ctypes] |
|
sub_int [Fol_decl] |
|
sub_real [Fol_decl] |
|
subproof_idx [WpPropId] |
subproof index of this propr_id
|
subproofs [WpPropId] |
About proofs
|
subset [Set.S] |
subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
subst [Formula.Logic] |
|
subst [Datalib.Create] |
|
subst_havoc [Mwp.S] |
Binds the free variables in
the wp representing the memory locations that live in zone .
|
subst_havoc [Hoare_mem.Create] |
|
subst_havoc [Store_mem.Create] |
|
subst_havoc [Runtime_mem.Create] |
|
subst_havoc [Funvar_mem.Create] |
|
subst_in_pred [Fol] |
Specialized version of subst_vars_in_pred to substitute one variable v
by and expression exp in a predicate p .
|
subst_lval [Mwp.S] |
|
subst_lval [Hoare_mem.Create] |
|
subst_lval [Store_mem.Create] |
|
subst_lval [Runtime_mem.Create] |
|
subst_lval [Funvar_mem.Create] |
|
subst_result [Translate_prop.Create] |
|
subst_vars_in_pred [Fol] |
Similar to change_vars_in_exp but on predicates.
|
succ_e [Cil2cfg] |
|
suitable [Proof] |
|
switch [Mcfg.S] |
|
switch [CfgWeakestPrecondition.Create] |
|
switch [Cfgpropid.Create] |
merge the switch branches :
|
symb_is_init [Mvalues.Values] |
|
symb_is_init [Datalib.Cvalues] |
|
symb_is_init_range [Mvalues.Values] |
|
symb_is_init_range [Datalib.Cvalues] |
|
system [Wpo] |
|
T |
t_alloc [Hoare_mem.Create] |
|
t_alloc [Store_mem.Create] |
|
t_alloc [Runtime_mem.Create] |
|
t_data [Store_mem.Create] |
|
t_mbits [Runtime_mem.Create] |
|
t_mem [Runtime_mem.Create] |
|
t_memory [Store_mem.Create] |
|
tag [Mcfg.S] |
|
tag [CfgWeakestPrecondition.Create] |
|
tag [Cfgpropid.Create] |
|
tag_named [Fol_ergo] |
|
tag_named [Fol_pretty] |
|
target [WpAnnot] |
|
tarray_dim [ACSL] |
|
tarray_elt [ACSL] |
|
tarray_name [ACSL] |
|
tarray_of_arrayinfo [ACSL] |
|
tarray_of_typ [ACSL] |
|
task_for [Prover] |
|
tau_of_ctype [ACSL] |
|
tau_of_ctype [Fol_decl.Tau] |
|
tau_of_ctype [Datalib.Cvalues] |
|
tau_of_ctype_logic [Register.Tr] |
|
tau_of_ctype_logic [Register.Ts] |
|
tau_of_ctype_logic [Register.Th] |
|
tau_of_ctype_logic [Fol_decl.Tau] |
|
tau_of_ctype_logic [Datalib.Cvalues] |
|
tau_of_darray [ACSL] |
|
tau_of_dzone [Mwp.S] |
|
tau_of_dzone [Hoare_mem.Create] |
|
tau_of_dzone [Store_mem.Create] |
|
tau_of_dzone [Runtime_mem.Create] |
|
tau_of_dzone [Funvar_mem.Create] |
|
tau_of_loc [Mvalues.Model] |
|
tau_of_loc [Hoare_mem.Create.Model] |
|
tau_of_loc [Store_mem.Create.Model] |
|
tau_of_loc [Runtime_mem.Create.Model] |
|
tau_of_loc [Funvar_mem.Create.Model] |
|
tau_of_loc [Datalib.Cvalues] |
|
tau_of_logic_type [Mvalues.Values] |
|
tau_of_logic_type [ACSL] |
|
tau_of_logic_type [Fol_decl.Tau] |
|
tau_of_logic_type [Datalib.Cvalues] |
|
tau_of_mem [Mvalues.Data] |
|
tau_of_mem [Store_mem.Create.Data] |
|
tau_of_mem [Runtime_mem.Create.Data] |
|
tau_of_object [Mvalues.Values] |
|
tau_of_object [ACSL] |
|
tau_of_object [Fol_decl.Tau] |
|
tau_of_object [Datalib.Cvalues] |
|
tau_of_object_array [Mvalues.Values] |
|
tau_of_object_array [Datalib.Cvalues] |
|
tau_of_tarray [ACSL] |
|
tau_of_var [Formula.S] |
|
tau_of_var [LogicLang] |
|
tau_of_var [LogicRaw.VAR] |
|
tau_of_var [Fol_formula] |
|
tbits_of_var [Runtime_mem.Create] |
|
tcomp_of_comp [Runtime_mem.Create] |
|
term [Translate_prop.Create] |
term e t interprets the C terms t in memory model environment e
as a logic term.*
|
term [Fol_eqs] |
|
term [Fol_let] |
|
term_alpha_cv [Fol] |
|
term_calls [Formula.S] |
|
term_calls [Fol_formula] |
|
term_calls [Fol] |
|
term_closed [Formula.S] |
|
term_closed [Fol_formula] |
|
term_filter [Translate_prop.Create] |
|
term_has_var [Formula.S] |
|
term_has_var [Fol_formula] |
|
term_of_data [Translate_prop.Create] |
|
term_of_loc [Mvalues.Model] |
|
term_of_loc [Hoare_mem.Create.Model] |
|
term_of_loc [Store_mem.Create.Model] |
|
term_of_loc [Runtime_mem.Create.Model] |
|
term_of_loc [Funvar_mem.Create.Model] |
|
term_of_loc [Datalib.Cvalues] |
|
term_of_xaddr [Runtime_mem.Create.Tint] |
|
term_of_xsize [Runtime_mem.Create.Tint] |
|
term_of_xzone [Runtime_mem.Create.Tint] |
|
term_replace [Fol] |
|
term_such_that [Formula.Logic] |
|
term_such_that [Datalib.Create] |
|
terms_alpha_cv [Fol] |
|
test [Mcfg.S] |
|
test [CfgWeakestPrecondition.Create] |
|
test [Cfgpropid.Create] |
|
test_edge_loop_ok [Calculus.Cfg] |
|
the_model [LogicDef] |
|
to_bits [Runtime_mem.Create.RtLib] |
|
to_int [ACSL] |
|
to_term [Runtime_mem.Create.Aint] |
|
toffset_of_field [Runtime_mem.Create.Tint] |
|
token [Kreal] |
|
token [Script] |
|
touch [LogicId] |
Count the identifier in the space.
|
tracelog [Register] |
|
trail [Kreal] |
|
translate [Prover.SMT] |
|
translate_assigned [CfgWeakestPrecondition.Create] |
|
translate_assigned_targets [CfgWeakestPrecondition.Create] |
|
tsize_of_field [Runtime_mem.Create.Tint] |
|
ty [Datatype.Set] |
|
typ_of_elements [Translate_prop.Create] |
|
typeOf_array_elem [Translate_expr.Create] |
|
U |
ufield [Fol_coq] |
|
unalloc [LogicId] |
|
uncapitalize [String] |
Return a copy of the argument, with the first character set to lowercase.
|
union [Formula.S] |
union s0 s1 returns the union set of s0 and s1 .
|
union [Fol_formula] |
|
union [Set.S] |
Set union.
|
union_data [Translate_prop.Create] |
|
union_map [Translate_prop.Create] |
|
unions [Formula.S] |
|
unions [Fol_formula] |
|
unique [LogicId] |
Reserves the identifier to be assigned its basename as name, if possible.
|
unlet [Fol_cc] |
|
unlet_pred [Fol_cc] |
|
unlet_term [Fol_cc] |
|
unlock [Translate_prop.Create.UserDefinition] |
|
unlock [LogicDef] |
|
unmark [LogicId] |
|
unop [LogicLang] |
|
unop [Fol_formula] |
|
unreachable_nodes [Cil2cfg] |
|
unsigned_in_bound [Fol] |
|
unstructuredness [Cil2cfg.LoopInfo] |
|
unsupported [Hoare_mem.Create] |
|
unsupported [Store_mem.Create] |
|
unsupported [Runtime_mem] |
|
unsupported [Wp_error] |
|
unwrap [Formula.S] |
|
unwrap [Fol_formula] |
|
upd_base [Store_mem.Create.Model] |
|
upd_field [Formula.S] |
Takes a record term of type (tau_of F.fcomp) and
a new term of type (tau_of F) for its field 'F'
and return the updated record.
|
upd_field [Fol_formula] |
|
upd_index [Formula.S] |
|
upd_index [Fol_formula] |
|
upd_obj [Store_mem.Create.Model] |
|
upd_off [Store_mem.Create.Model] |
|
update [Mwp.S] |
|
update [LogicDef.Cofix] |
|
update [LogicDef] |
|
update [Hoare_mem.Create] |
|
update [Store_mem.Create] |
|
update [Runtime_mem.Create] |
|
update [Funvar_mem.Create] |
|
update_offset [Funvar_mem.Create] |
|
updater [CfgProof.Description] |
Unique name for the internal updater
|
uppercase [String] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set.
|
urecord_of_data [Translate_prop.Create] |
|
use_assigns [Mcfg.S] |
use_assigns env hid kind assgn goal performs the havoc on the goal.
|
use_assigns [CfgWeakestPrecondition.Create] |
|
use_assigns [Cfgpropid.Create] |
|
use_loop_assigns [Calculus.Cfg] |
|
user_axiomlabels [Translate_prop.Create] |
|
user_axioms [Translate_prop.Create] |
|
user_default_label [Translate_prop.Create] |
|
user_definitions [Translate_prop.Create] |
|
user_env [Translate_prop.Create] |
|
user_frame [Translate_prop.Create] |
|
user_prop_names [WpPropId] |
This is used to give the name of the property that the user can give
to select it from the command line (-wp-prop option)
|
userdef_is_ref_param [Mlogic.S] |
userdef_ref_param p tests if p is a by reference logic
formal parameter.
|
userdef_is_ref_param [Hoare_mem.Create] |
|
userdef_is_ref_param [Store_mem.Create] |
|
userdef_is_ref_param [Runtime_mem.Create] |
|
userdef_is_ref_param [Funvar_mem.Create] |
|
userdef_mem_apply [Mlogic.S] |
|
userdef_mem_apply [Hoare_mem.Create] |
|
userdef_mem_apply [Store_mem.Create] |
|
userdef_mem_apply [Runtime_mem.Create] |
|
userdef_mem_apply [Funvar_mem.Create] |
|
userdef_mem_signature [Mlogic.S] |
|
userdef_mem_signature [Hoare_mem.Create] |
|
userdef_mem_signature [Store_mem.Create] |
|
userdef_mem_signature [Runtime_mem.Create] |
|
userdef_mem_signature [Funvar_mem.Create] |
|
userdef_ref_apply [Mlogic.S] |
|
userdef_ref_apply [Hoare_mem.Create] |
|
userdef_ref_apply [Store_mem.Create] |
|
userdef_ref_apply [Runtime_mem.Create] |
|
userdef_ref_apply [Funvar_mem.Create] |
|
userdef_ref_has_cvar [Mlogic.S] |
userdef_ref_has_cvar p tests if the by reference
logic formal parameter p needs a C addresses.
|
userdef_ref_has_cvar [Hoare_mem.Create] |
|
userdef_ref_has_cvar [Store_mem.Create] |
|
userdef_ref_has_cvar [Runtime_mem.Create] |
|
userdef_ref_has_cvar [Funvar_mem.Create] |
|
userdef_ref_signature [Mlogic.S] |
|
userdef_ref_signature [Hoare_mem.Create] |
|
userdef_ref_signature [Store_mem.Create] |
|
userdef_ref_signature [Runtime_mem.Create] |
|
userdef_ref_signature [Funvar_mem.Create] |
|
V |
val_of [LogicRaw.PRED] |
|
val_of [Fol] |
|
valid [Mlogic.S] |
|
valid [Hoare_mem.Create] |
|
valid [Store_mem.Create] |
|
valid [Runtime_mem.Create.RtLib] |
|
valid [Runtime_mem.Create] |
|
valid [Funvar_mem.Create] |
|
valid [Prover.AltErgo] |
|
value_of_bits [Runtime_mem.Create.Data] |
|
value_of_bits [Runtime_mem.Create] |
Compute the logic value from bits interpreted with type t .
|
value_of_boolean [Translate_expr.Create] |
|
value_of_integer [Translate_expr.Create] |
|
value_of_logic [Mvalues.Values] |
|
value_of_logic [Datalib.Cvalues] |
|
value_of_mvalue [Funvar_mem.Create] |
|
vampire [Prover.SMT] |
|
var [Formula.S] |
|
var [Fol_formula] |
|
var_counter [Fol.Var] |
|
var_name [Fol.Var] |
|
var_type [Fol.Var] |
|
var_type_of_lvar [Variables_analysis] |
|
varinfo_of_xaddr [Runtime_mem.Create.Tint] |
|
varname [Datatype.Set] |
|
vertex_attributes [Cil2cfg.Printer] |
|
vertex_name [Cil2cfg.Printer] |
|
very_strange_loops [Cil2cfg] |
detect is there are natural loops where we didn't manage to compute
back edges (see mark_loops ).
|
vkind_of_var [Formula.Logic] |
|
vkind_of_var [Datalib.Create] |
|
W |
warning [Wp_parameters] |
|
whydp [Prover.SMT] |
|
wp_call [Calculus.Cfg] |
|
wp_compute [Register] |
|
wp_compute_call [Register] |
|
wp_dir [Wp_gui] |
|
wp_generation [Wp_parameters] |
|
wp_highlight [Wp_gui] |
|
wp_loop [Calculus.Cfg] |
Compute the result for edge e which goes to the loop node nloop .
|
wp_model [Register] |
|
wp_model [Wp_parameters] |
|
wp_model_menu [Wp_gui] |
|
wp_panel [Wp_gui] |
|
wp_po [Wp_parameters] |
|
wp_preconditions [WpAnnot] |
|
wp_prover [Wp_parameters] |
|
wp_prover_get [Wp_gui] |
|
wp_prover_menu [Wp_gui] |
|
wp_prover_set [Wp_gui] |
|
wp_scope [Calculus.Cfg] |
|
wp_script [Wp_gui] |
|
wp_select [Wp_gui] |
|
wp_stmt [Calculus.Cfg] |
|
wp_strategy [Wp_parameters] |
|
wp_unreachable [WpAnnot] |
|
wrap [Formula.S] |
|
wrap [Fol_formula] |
|
X |
xaddr_of_integer [Runtime_mem.Create.Tint] |
|
xaddr_of_var [Runtime_mem.Create.Tint] |
|
xsize_of_range [Runtime_mem.Create.Tint] |
|
xvar [Translate_prop.Create] |
|
xzone_assigned [Runtime_mem.Create] |
|
xzone_disj [Runtime_mem.Create.Tint] |
|
xzone_of_var [Runtime_mem.Create.Tint] |
|
Y |
yices [Prover.SMT] |
|
Z |
z3 [Prover.SMT] |
|
z_from_bits [Runtime_mem.Create] |
|
zenon [Prover.SMT] |
|
zip [CfgWeakestPrecondition.Create] |
|
zone_of_assignable [Store_mem.Create] |
|
zrange [Store_mem.Create] |
|
zs_empty [Runtime_mem.Create.RtLib] |
|
zs_incl [Runtime_mem.Create.RtLib] |
|
zs_singleton [Runtime_mem.Create.RtLib] |
|
zs_union [Runtime_mem.Create.RtLib] |
|
zunion [Fol_split.SplitZoneInclusion] |
|