A |
abort [Model2] |
|
abort [Model1] |
|
abort [Mvar.MV] |
|
abort [Model0] |
|
abort [Mmem.MT] |
|
abort [Lowlevel_model] |
|
access [Model1.M] |
|
access [Lowlevel_model.M] |
Access a stored value given a memory state.
|
acsl_base_addr [Why_ops] |
defined in acsl.why : 'a pointer -> char pointer
|
acsl_null [Why_ops] |
defined in acsl.why : -> 'a pointer
|
add [WpAnnot] |
|
add_all_field_eq_axiom [WpFol] |
|
add_annot [WpAnnot] |
|
add_assigns [WpAnnot] |
|
add_axiom [WpFol] |
|
add_behaviors_spec [WpAnnot] |
|
add_bhv_fct_assigns [WpAnnot] |
|
add_code_annot [WpAnnot] |
|
add_decl_hyp [Mvar.Mv_sig] |
|
add_decl_hyp [Model1.M] |
|
add_decl_hyp [Model0.M] |
|
add_edge [Cil2cfg] |
|
add_fct_post [WpAnnot] |
|
add_fct_pre [WpAnnot] |
|
add_field_array_length_axiom [WpFol] |
|
add_glob_decls [Toprop.T_for_Cfg] |
|
add_glob_decls [Toprop.T_no_call] |
|
add_glob_decls [Register] |
|
add_glob_decls [Mvar.MC] |
|
add_glob_decls [Mmem.MM] |
|
add_glob_decls [Calculus.Moblig] |
|
add_glob_decls [Calculus.Msimple] |
|
add_glob_decls [Calculus.Cfg] |
must be called to get the global definition/declaration
after having done computation with cfg .
|
add_glob_var [WpFol] |
|
add_goal [Toprop.T_for_Cfg] |
|
add_goal [Mvar.MV] |
|
add_goal [Mmem.MM] |
|
add_goal [Calculus.Moblig] |
|
add_goal [Calculus.Msimple] |
|
add_goals [Toprop.T_for_Cfg] |
|
add_goals [Calculus.Moblig] |
|
add_goals [Calculus.Msimple] |
|
add_hyp [Toprop.T_for_Cfg] |
|
add_hyp [Mvar.MV] |
|
add_hyp [Mmem.MM] |
|
add_hyp [Calculus.Moblig] |
|
add_hyp [Calculus.Msimple] |
|
add_id_prop [Calculus.Moblig] |
|
add_inv [WpAnnot] |
|
add_irreducible [Cil2cfg.WeiMaoZouChenInput] |
store the node as an irreducible loop header.
|
add_irreducible [Cil2cfg.LoopInfo] |
|
add_loop_header [Cil2cfg.WeiMaoZouChenInput] |
store the node as a loop header.
|
add_loop_header [Cil2cfg.LoopInfo] |
|
add_named_prop [Calculus.Moblig] |
|
add_neq_field_axioms [WpFol] |
|
add_node [Cil2cfg] |
|
add_reentry_edge [Cil2cfg.WeiMaoZouChenInput] |
store the edge between the two nodes (n1, n2) as a reentry edge.
|
add_reentry_edge [Cil2cfg.LoopInfo] |
|
add_spec_post [WpAnnot] |
|
add_spec_pre [WpAnnot] |
|
add_stmt_spec [WpAnnot] |
|
add_stmt_spec_post [WpAnnot] |
|
add_stmt_spec_pre [WpAnnot] |
|
addr_cvar [WpFol] |
|
addr_lvar [WpFol] |
|
array_access [Why_ops] |
defined in array.why : 'a array, int -> 'a
|
array_length [Why_ops] |
|
array_type [Types] |
|
array_update [Why_ops] |
defined in array.why : 'a array, int, 'a -> 'a array
|
assign [Toprop.T_for_Cfg] |
|
assign [Toprop.T_no_call] |
|
assign [Mvar.MC] |
|
assign [Mmem.MM] |
|
assign [Calculus.Moblig] |
|
assign [Calculus.Msimple] |
|
assign_exp [Mvar.MO_sig] |
|
assign_exp [Mvar.MC] |
|
assign_exp [Model1] |
|
assign_exp [Model0] |
|
assign_exp [Mmem.MM] |
|
assign_old_exp [Mvar.MO_sig] |
|
assign_old_exp [Mvar.MC] |
|
assign_old_exp [Model1] |
|
assign_old_exp [Model0] |
this is used for parallele assign : we must be careful that the
right side of the let depend only on the assigned variable
|
axiom_table [WpFol] |
|
B |
base_id [Why_ops] |
|
bool_cmp_binop [Why_ops] |
Comparison between two terms having the same type ty .
|
bool_term_to_predicate [Why_ops] |
|
bool_type [Types] |
|
build_cfg_annots [Calculus.Cfg] |
|
build_guard [Model1] |
|
build_mu [Model1] |
|
build_obligs [Register] |
|
build_why_file [Why_output] |
prove basename prelude p
First call output (see above) and generate a tmp file with
basename and return its name
|
builtin_why_file [Why_ops] |
build a WHY file with the builtin functions declarations.
|
C |
call [Toprop.T_for_Cfg] |
|
call [Toprop.T_with_call] |
|
call [Call.WithPrePost] |
Process call using pre/post and outputs
|
call [Calculus.Moblig] |
|
call [Calculus.Msimple] |
|
call_add_pre_and_do_args [Mvar.MC] |
|
call_add_pre_and_do_args [Mmem.MM] |
|
call_add_pre_and_do_args [Call.T_for_call] |
call_add_pre_and_do_args args formals pre p
|
call_do_body [Mvar.MC] |
Process call assigns : abort if no assigns because we need them
|
call_do_body [Mmem.MM] |
|
call_do_body [Call.T_for_call] |
|
call_res_and_add_post [Mvar.MC] |
|
call_res_and_add_post [Mmem.MM] |
|
call_res_and_add_post [Call.T_for_call] |
call_res_and_add_post called_kf lval_res post p
|
cast_op [Why_ops] |
(t1)(e)
TODO : change that when we'll have different interger and reels.
|
cfg [Calculus.Cfg] |
|
cfg_blk_in [Cil2cfg] |
|
cfg_blk_out [Cil2cfg] |
|
cfg_block [Cil2cfg] |
|
cfg_dot [Register] |
|
cfg_exit [Cil2cfg] |
|
cfg_exit_id [Cil2cfg] |
|
cfg_fct_in [Cil2cfg] |
|
cfg_fct_in_id [Cil2cfg] |
|
cfg_fct_out [Cil2cfg] |
|
cfg_fct_out_id [Cil2cfg] |
|
cfg_graph [Cil2cfg] |
get the graph itself
|
cfg_kf [Cil2cfg] |
|
cfg_start [Cil2cfg] |
get the starting node
|
cfg_start_id [Cil2cfg] |
|
cfg_stmt [Cil2cfg] |
|
change_exp_in_pred [Fol] |
apply do_exp on each sub expression of the predicate.
|
change_in_exp [Fol] |
change_in_exp do_var do_data exp
|
change_vars_in_exp [Fol] |
|
check_acsl_name [Why_ops] |
TODO : better handling of ACSL predefined functions
|
cil_binop [Why_ops] |
|
cil_unop [Why_ops] |
Return a term which should have the type ty .
|
close [Toprop.T_for_Cfg] |
|
close [Toprop.T_no_call] |
the computation is over : finish (do formals, add hypotheses, ...
|
close [Mvar.MC] |
|
close [Mmem.MM] |
|
close [Calculus.Moblig] |
|
close [Calculus.Msimple] |
|
cmp_binop_neg [Why_ops] |
|
compare [Cil2cfg.EL] |
|
compare [Cil2cfg.VL] |
|
compare_prop_id [WpAnnot] |
|
complet_behaviors_props [WpAnnot] |
|
compute_edge [Calculus.Cfg] |
|
cond [Translate.ToGfol] |
|
conj_list [Fol] |
|
constant [Why_output] |
|
create [Cil2cfg.HEsig] |
|
create [Cil2cfg] |
|
create [Cil2cfg.HE] |
|
ctype_array_elem [Types] |
|
ctype_ptr [Types] |
|
ctype_ptr_subtype [Types] |
|
cur_mem [Model2.M] |
|
cur_mem [Mmem.MT] |
|
cur_mem [Lowlevel_model.M] |
|
cur_mem_var [Model2.M] |
|
cur_mem_var [Mmem.MT] |
|
cur_mem_var [Lowlevel_model.M] |
|
cvar_of_folvar [WpFol] |
|
cvar_of_folvar_opt [WpFol] |
|
cvar_to_folvar [WpFol] |
|
D |
decl [Why_output] |
|
default [Cil2cfg.EL] |
|
default_edge_attributes [Cil2cfg.Printer] |
|
default_vertex_attributes [Cil2cfg.Printer] |
|
disj_pointer [Why_ops] |
|
disjoint_behaviors_props [WpAnnot] |
|
display [Cil2cfg] |
output the graph in a dot file named file with optional text on the edges.
|
do_labels [Calculus.Cfg] |
|
dot_annots [Register] |
|
dot_cfg [Register] |
|
dot_lannots [Register] |
|
dummy_ctype [Types] |
|
dummy_ltype [Types] |
|
dummy_type [Types] |
|
E |
edge_attributes [Cil2cfg.Printer] |
|
edge_key [Cil2cfg.HE] |
|
empty_goals [Calculus.Moblig] |
|
eq_data [Toprop.T_data_mem] |
compare 2 data and tell if they are equal
|
eq_data [Model2.M] |
|
eq_data [Model1.M] |
|
eq_data [Model0.M] |
|
eq_data [Lowlevel_model.M] |
|
eq_epath [WpFol] |
|
eq_nodes [Cil2cfg.WeiMaoZouChenInput] |
|
eq_nodes [Cil2cfg.LoopInfo] |
|
eq_term [Fol] |
|
eq_var [Fol] |
|
equal [Cil2cfg.VL] |
|
export_and_clear [WpFol] |
|
export_and_clear_axioms [WpFol] |
|
export_and_clear_fields [WpFol] |
|
export_and_clear_globs [WpFol] |
|
export_fct_table [Translate.ToGfol] |
|
export_tables [WpFol] |
|
export_types [Types] |
|
expr [Translate.ToGfol] |
|
expr_cast [Toprop.T_data_mem] |
|
expr_cast [Model2.M] |
|
expr_cast [Model1.M] |
|
expr_cast [Model0.M] |
|
expr_cast [Lowlevel_model.M] |
|
F |
field_access [Why_ops] |
s.
|
field_name [WpFol] |
|
field_offset [Lowlevel_model.M] |
Calculate the address offset of a given field.
|
field_shift [Why_ops] |
ps.
|
field_table [WpFol] |
|
field_update [Why_ops] |
mu (s, .(field) -> v)
|
find [Cil2cfg.HEsig] |
|
find [Cil2cfg.HE] |
|
fol [Toprop.T_no_call] |
|
fol [Mvar.Mv_sig] |
|
fol [Mvar.MC] |
|
fol [Model2.M] |
|
fol [Model2] |
|
fol [Model1.M] |
|
fol [Model0.M] |
translate M0 predicate into Fol.predicate
|
fol [Mmem.Mm_sig] |
|
fol [Lowlevel_model.M] |
|
fol [Lowlevel_model] |
|
fol_ctype_sizeof [Lowlevel_model.M] |
|
fol_field_access [WpFol] |
s.
|
fol_field_shift [WpFol] |
ps is a structure address : build the address of ps.f ie ps.
|
fol_field_update [WpFol] |
mu (s, .(field) -> v)
|
fol_ltype_sizeof [Lowlevel_model.M] |
|
fol_offset_access [WpFol] |
t.
|
fol_offset_shift [WpFol] |
|
fol_offset_update [WpFol] |
|
fol_toffset_shift [WpFol] |
|
fold_data_in_exp [Fol] |
fold_data_in_exp do_var do_data acc exp
|
fold_exp_in_pred [Fol] |
fold_exp_in_pred do_exp acc p
|
fold_succ [Cil2cfg.WeiMaoZouChenInput] |
apply the function on the node successors
|
fold_succ [Cil2cfg.LoopInfo] |
|
forall_addr_cvar [Mmem.MT] |
|
forall_lv [Mmem.MT] |
|
forall_mem [Mmem.MT] |
|
forall_pred [Fol] |
forall_pred prop_in_data ~fresh v p
|
fresh_mem [Mmem.MT] |
|
fresh_mem [Lowlevel_model.M] |
|
fresh_named_var [Fol] |
|
fresh_var [Fol] |
|
fresh_var_in_pred [Fol] |
fresh_var_in_pred prop_in_data v p :
build a fresh var v' from v, and subst v -> v' in p
|
G |
generic_pointer_type [Types] |
|
get_addr_exp [Model2.M] |
|
get_all_annots [WpAnnot] |
return one environment per behavior
|
get_all_kf [Register] |
|
get_annot_opt [Wp_gui] |
|
get_annots [Register] |
|
get_at_vars [Mvar.MT] |
|
get_behav [WpAnnot] |
|
get_behav_option [Register] |
|
get_behavior_annots [WpAnnot] |
|
get_bhv_annots [WpAnnot] |
builds tables that give hypotheses and goals relative to b behavior
for edges of the cfg to consider during wp computation.
|
get_bhv_assumes [WpAnnot] |
|
get_env [Macros] |
|
get_ext_fct_assigns [WpAnnot] |
|
get_ext_postconditions [WpAnnot] |
|
get_ext_preconditions [WpAnnot] |
|
get_fct_assigns [WpAnnot] |
|
get_field [WpFol] |
|
get_iloop_header [Cil2cfg.WeiMaoZouChenInput] |
get the node innermost loop header if any
|
get_iloop_header [Cil2cfg.LoopInfo] |
|
get_kf_stmt_opt [Wp_gui] |
|
get_label_mem [Mmem.MT] |
|
get_loop_assigns [WpAnnot] |
the edge e is the one that is going into the loop.
|
get_loop_assigns [Calculus.Cfg] |
|
get_loop_invariant [WpAnnot] |
Have to process every AInvariant even if it is only to emit an alarm
|
get_model_option [Register] |
|
get_node [Cil2cfg] |
While building the CFG, it can happend that we need to create a node
without knowing its kind yet.
|
get_one_stmt_label [Macros] |
|
get_only_succ [Calculus.Cfg] |
|
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_postconditions [WpAnnot] |
|
get_preconditions [WpAnnot] |
|
get_read_addr [Model1] |
|
get_result [Calculus.Cfg] |
|
get_spec [WpAnnot] |
the definitions are saying that if a formal parameter x appears in a
postcondition, it has to be understood as \old(x).
|
get_stmt_annots [WpAnnot] |
|
get_stmt_node [Cil2cfg] |
|
get_subgraph [Cil2cfg.Printer] |
|
get_test_edges [Cil2cfg] |
Get the edges going out a test node with the then branch first
|
get_wp_edge [Calculus.Cfg] |
|
globals_table [WpFol] |
|
graph_attributes [Cil2cfg.Printer] |
|
guard_counter [Model1] |
|
gui_set_wp_bottom [Wp_gui] |
|
gui_set_wp_model [Wp_gui] |
|
H |
hash [Cil2cfg.VL] |
|
I |
id_of_prop [WpAnnot] |
|
identify_loops [Cil2cfg.WeiMaoZouChen] |
|
incr [Cil2cfg.LoopInfo] |
|
incr_xi [Cil2cfg.WeiMaoZouChenInput] |
the unstructuredness coefficient k can be computed = 1+(xi+yi)/E
when E is the number of edge in the graph.
|
incr_xi [Cil2cfg.LoopInfo] |
|
incr_yi [Cil2cfg.WeiMaoZouChenInput] |
|
incr_yi [Cil2cfg.LoopInfo] |
|
index_shift [Why_ops] |
p.
|
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] |
|
int_base_addr [Why_ops] |
defined in model1.why : 'a pointer -> int option
|
int_bool_cmp_binop_name [Why_ops] |
These are WHY names from library integers.why : int -> int -> bool
|
int_of_bool [Why_ops] |
|
int_zero [Why_ops] |
|
is_back_edge [Cil2cfg] |
|
is_bool_ltype [Types] |
|
is_irreducible [Cil2cfg.LoopInfo] |
|
is_on [Wp_parameters] |
|
is_ptr_ltype [Types] |
|
iter_edges_e [Cil2cfg.Printer] |
|
iter_vertex [Cil2cfg.Printer] |
|
K |
kf_var_res [Macros] |
TODO : put this somewhere else
|
kind_of_num [Register] |
|
L |
labels_assert [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_spec_post [NormAtLabels] |
|
labels_spec_pre [NormAtLabels] |
|
labels_stmt_spec [NormAtLabels] |
|
let_pred [Fol] |
let_pred prop_in_data ~fresh v e p
|
logic_label_name [Macros] |
|
loop_stmts [Cil2cfg] |
|
ltype_array_elem [Types] |
|
ltype_ptr [Types] |
|
ltype_ptr_subtype [Types] |
|
lv_to_fol_var [WpFol] |
|
lval_addr [Mmem.MM] |
|
lvar_of_variable [Fol] |
|
M |
main [Wp_gui] |
|
main [Register] |
|
map_named_prop [Calculus.Moblig] |
|
mark_loops [Cil2cfg] |
|
mem_access [Why_ops.M3] |
|
mem_access [Why_ops.M2] |
|
mem_update [Why_ops.M3] |
|
mem_update [Why_ops.M2] |
|
mem_update [Model2.M] |
|
mem_update [Mmem.Mm_sig] |
mem_update mem val_type ptr val
|
mem_update [Lowlevel_model.M] |
Update a stored value given a memory state.
|
memory_ltype [Macros] |
|
memory_lvar [Macros] |
|
memory_type [Types] |
|
memory_type_ltype [Macros] |
|
memory_type_ltype [Lowlevel_model.M] |
|
memory_type_lvar [Macros] |
|
memory_type_name [Lowlevel_model.M] |
|
merge [Calculus.Moblig] |
|
merge_id_prop [Calculus.Moblig] |
|
merge_named_prop [Calculus.Moblig] |
|
mk_access_pointer [Toprop.T_data_mem] |
mk_access_pointer p ty
where p is a pointer and ty the type of the pointed object,
represents p.* ie *p in C.
|
mk_access_pointer [Model2.M] |
|
mk_access_pointer [Model1.M] |
|
mk_access_pointer [Model0.M] |
|
mk_access_pointer [Lowlevel_model.M] |
|
mk_array_length [WpFol] |
build array_length t = sz when we know how to interpet the size sz
|
mk_ctype [Types] |
|
mk_ctype_ptr [Types] |
|
mk_cvar [Toprop.T_data_mem] |
build an expression that represent the C variable
|
mk_cvar [Model2.M] |
|
mk_cvar [Model1.M] |
|
mk_cvar [Model0.M] |
|
mk_cvar [Lowlevel_model.M] |
|
mk_cvar_addr [Toprop.T_data_mem] |
build an expression that represent the address of the C variable
|
mk_cvar_addr [Model2.M] |
|
mk_cvar_addr [Model1.M] |
|
mk_cvar_addr [Model0.M] |
|
mk_cvar_addr [Lowlevel_model.M] |
|
mk_field_access [Toprop.T_data_mem] |
mk_field_access s f
where s is a structure and f a field of this structure
represents s.f
|
mk_field_access [Model2.M] |
|
mk_field_access [Model1.M] |
|
mk_field_access [Model0.M] |
|
mk_field_access [Lowlevel_model.M] |
|
mk_field_shift [Toprop.T_data_mem] |
mk_field_shift ps f
where ps is the address of a structure,
represents ps+f
ie.
|
mk_field_shift [Model2.M] |
|
mk_field_shift [Model1.M] |
|
mk_field_shift [Model0.M] |
|
mk_field_shift [Lowlevel_model.M] |
|
mk_field_type [Types] |
|
mk_field_update [Toprop.T_data_mem] |
mk_field_update s f x
where s is a structure and f a field of this structure
represents mu (s, f -> x)
|
mk_field_update [Model2.M] |
|
mk_field_update [Model1.M] |
|
mk_field_update [Model0.M] |
|
mk_field_update [Lowlevel_model.M] |
|
mk_float_ctype [Types] |
|
mk_index_access [Toprop.T_data_mem] |
mk_index_access t ty i
where t is an array, and ty is the type of the array elements,
represents t.(i) ie.
|
mk_index_access [Model2.M] |
|
mk_index_access [Model1.M] |
|
mk_index_access [Model0.M] |
|
mk_index_access [Lowlevel_model.M] |
|
mk_index_shift [Toprop.T_data_mem] |
mk_index_shift pt ty i
where pt is the address of an array,
ty is the type of the array elements,
represents pt+(i)
ie.
|
mk_index_shift [Model2.M] |
|
mk_index_shift [Model1.M] |
|
mk_index_shift [Model0.M] |
|
mk_index_shift [Lowlevel_model.M] |
because we don't care of term type,
mk_index_shift and mk_shift_pointer are the same
|
mk_index_update [Toprop.T_data_mem] |
mk_index_update t i x
where t is an array and i an index in this array,
represents mu (t, (i) -> x)
|
mk_index_update [Model2.M] |
|
mk_index_update [Model1.M] |
|
mk_index_update [Model0.M] |
|
mk_index_update [Lowlevel_model.M] |
|
mk_int_ctype [Types] |
TODO : use machine configuration from Cil ?
|
mk_let [Mvar.Mv_sig] |
|
mk_let [Model1.M] |
|
mk_let [Mvar.MV] |
build forall v', v' = exp => p[v <- v']
Don't build a new variable v' if fresh=false (just use v )
but be careful that in that case, v must not appear in exp !
|
mk_let [Model0.M] |
build let except if exp is a var addr : direct substitution
|
mk_let_vi [Mvar.MV] |
|
mk_ltype [Types] |
|
mk_ltype_ptr [Types] |
|
mk_lvar [Toprop.T_data_mem] |
build an expression that represent the logic_var
|
mk_lvar [Model2.M] |
|
mk_lvar [Model1.M] |
|
mk_lvar [Model0.M] |
|
mk_lvar [Lowlevel_model.M] |
|
mk_lvar_addr [Toprop.T_data_mem] |
build an expression that represent the address of the logic_var
|
mk_lvar_addr [Model2.M] |
|
mk_lvar_addr [Model1.M] |
|
mk_lvar_addr [Model0.M] |
|
mk_lvar_addr [Lowlevel_model.M] |
|
mk_lvar_variable [Fol] |
|
mk_memory_ctype [Lowlevel_model.M] |
|
mk_memory_float_ctype [Lowlevel_model.M] |
|
mk_memory_int_ctype [Lowlevel_model.M] |
|
mk_memory_ltype [Lowlevel_model.M] |
|
mk_memory_type_var [Lowlevel_model.M] |
|
mk_minus_pointer [Translate.MT_sig] |
mk_minus_pointer p1 p2 represents p1 - p2
|
mk_minus_pointer [Mvar.MT] |
|
mk_minus_pointer [Mmem.MT] |
|
mk_minus_pointer [Lowlevel_model.M] |
|
mk_offset_update [Mvar.MV] |
build something like : mu (base, off -> e)
If env , we don't want to have modifiable variables in off ,
so if there are some indexes idx , we build a \old(idx) term instead
(and store it in env ).
|
mk_ptr_update [Model1.M] |
|
mk_shift_pointer [Toprop.T_data_mem] |
mk_shift_pointer p ty i
where p is a pointer on an element,
and ty the type of the element,
represents p#(i)
ie.
|
mk_shift_pointer [Model2.M] |
|
mk_shift_pointer [Model1.M] |
|
mk_shift_pointer [Model0.M] |
|
mk_shift_pointer [Lowlevel_model.M] |
|
mk_toffset_access [WpFol] |
|
model_name [Toprop.T_for_Cfg] |
|
model_name [Toprop.T_no_call] |
|
model_name [Toprop.T_data_mem] |
|
model_name [Register] |
|
model_name [Mvar.MC] |
|
model_name [Model2.M] |
|
model_name [Model2] |
|
model_name [Model1.M] |
|
model_name [Model0.M] |
|
model_name [Lowlevel_model.M] |
|
model_name [Lowlevel_model] |
|
model_name [Calculus.Moblig] |
|
model_name [Calculus.Msimple] |
|
N |
name_of_default_behavior [Macros] |
|
nb_var_in_pred [Fol] |
|
neq_field [Why_ops] |
|
new_cfg_env [Cil2cfg] |
|
new_env [Translate.MT_sig] |
|
new_env [Toprop.T_for_Cfg] |
|
new_env [Toprop.T_no_call] |
|
new_env [Mvar.MC] |
|
new_env [Mvar.MT] |
|
new_env [Mmem.MM] |
|
new_env [Mmem.MT] |
|
new_env [Calculus.Moblig] |
|
new_env [Calculus.Msimple] |
|
node_type_id [Cil2cfg] |
gives a number to each CFG node in order to hash them
|
none [Why_ops] |
defined in acsl.why : -> 'a option
|
O |
output [Why_output] |
Output to file file the given predicate in why syntax
|
P |
pand [Fol] |
|
pands [Fol] |
|
papp [Fol] |
|
pbot [Why_ops] |
defined in acsl.why : this is a predicate
|
pbot [Mvar.MV] |
|
pbot [Mmem.MM] |
|
pexists [Fol] |
|
pforall [Fol] |
|
pif [Why_ops] |
|
pif [Fol] |
|
piff [Fol] |
|
pimplies [Fol] |
|
plet [Fol] |
|
pnot [Why_ops] |
|
pnot [Fol] |
|
pointer_access [Why_ops.M1] |
p.
|
pointer_type [Types] |
|
pointer_update [Why_ops.M1] |
|
por [Fol] |
|
pors [Fol] |
|
post_at_end [Mvar.MC] |
|
post_at_end [Mmem.MM] |
|
pp_assign [Macros] |
|
pp_assigns [Macros] |
|
pp_bhv_names [WpAnnot] |
|
pp_data [Toprop.T_data_mem] |
pretty printer for the data expressions
|
pp_data [Model2.M] |
|
pp_data [Model1.M] |
|
pp_data [Model0.M] |
|
pp_data [Lowlevel_model.M] |
|
pp_data0 [Model0] |
|
pp_data1 [Model1] |
|
pp_data2 [Model2] |
|
pp_epath [Model2] |
|
pp_epath [Model1] |
|
pp_epath [Model0] |
|
pp_exp [Translate.MT_sig] |
|
pp_exp [Mvar.MT] |
|
pp_exp [Mmem.MT] |
|
pp_exp0 [Model0] |
|
pp_exp1 [Model1] |
|
pp_exp2 [Model2] |
|
pp_id [WpAnnot] |
|
pp_logic_label [Macros] |
|
pp_lv [WpFol] |
|
pp_no_data [Why_output] |
|
pp_pred [Translate.MT_sig] |
|
pp_pred [Why_output] |
|
pp_pred [Mvar.MT] |
|
pp_pred [Mmem.MT] |
|
pp_term [Why_output] |
|
pp_var [Why_output] |
|
pp_var_type [Why_output] |
|
pred_eq [Why_ops] |
|
pred_forall [Translate.MT_sig] |
|
pred_forall [Mvar.MT] |
|
pred_forall [Mmem.MT] |
|
pred_forall_cv [Mvar.MV] |
|
pred_neq [Why_ops] |
|
pred_of_prop [WpAnnot] |
|
predicate [Why_output] |
|
predicate [Translate.ToGfol] |
|
prelude [Register] |
|
preproc_annot [NormAtLabels] |
|
preproc_assigns [NormAtLabels] |
|
pretty [Toprop.T_for_Cfg] |
|
pretty [Toprop.T_no_call] |
|
pretty [Mvar.MV] |
|
pretty [Mmem.MM] |
|
pretty [Cil2cfg.EL] |
|
pretty [Cil2cfg.VL] |
|
pretty [Calculus.Moblig] |
|
pretty [Calculus.Msimple] |
|
pretty_edge [Cil2cfg] |
|
pretty_node [Cil2cfg.WeiMaoZouChenInput] |
|
pretty_node [Cil2cfg.LoopInfo] |
|
pretty_pred [Toprop.T_no_call] |
|
pretty_pred [Mvar.MV] |
|
pretty_pred [Mmem.MM] |
|
pretty_raw_stmt [Cil2cfg.Printer] |
|
process_at_vars [Toprop.T_for_Cfg] |
|
process_at_vars [Calculus.Moblig] |
|
process_at_vars [Calculus.Msimple] |
|
process_ex [Register] |
Process exceptions for all external functions.
|
prop_in_data [Toprop.T_data_mem] |
apply the function to the expressions used in the data
|
prop_in_data [Model2.M] |
|
prop_in_data [Model1.M] |
propagate expression transformation do_exp in the data d
|
prop_in_data [Model0.M] |
apply do_exp on every expressions in the data d representation.
|
prop_in_data [Lowlevel_model.M] |
|
prop_named_pred [WpAnnot] |
|
prop_txt [WpAnnot] |
|
prop_type [Types] |
|
prove [Register] |
|
ptr_bool_cmp_binop [Why_ops] |
|
ptrue [Toprop.T_for_Cfg] |
|
ptrue [Mvar.MV] |
|
ptrue [Mmem.MM] |
|
ptrue [Calculus.Moblig] |
|
ptrue [Calculus.Msimple] |
|
pure_type [Why_output] |
|
pxor [Fol] |
|
Q |
quantif_locals [Toprop.T_for_Cfg] |
|
quantif_locals [Toprop.T_no_call] |
|
quantif_locals [Mvar.MC] |
Quantify kf local variables in p ,
and add hypotheses on the size of local arrays if any.
|
quantif_locals [Mmem.MM] |
|
quantif_locals [Calculus.Moblig] |
|
quantif_locals [Calculus.Msimple] |
|
quantify_assigns [Mvar.MC] |
the property p is related to a program point Lo and we want to move
it to a program point Li .
|
quantify_assigns [Mmem.MM] |
the property p is related to a program point Lo and we want to move
it to a program point Li .
|
quantify_at_vars [Toprop.T_for_Cfg] |
|
quantify_at_vars [Toprop.T_no_call] |
see replace_at_vars : same but quantify instead of substitute.
|
quantify_at_vars [Mvar.MC] |
|
quantify_at_vars [Mmem.MM] |
|
quantify_at_vars [Calculus.Moblig] |
|
quantify_at_vars [Calculus.Msimple] |
|
quantify_effects [Lowlevel_model] |
|
quantify_loop_assigns [Toprop.T_no_call] |
quantify the object over the assigns list in order to move it before loop.
|
quantify_loop_assigns [Mvar.MC] |
quantify the stmt assigns : return None if no assigns annotation.
|
quantify_loop_assigns [Mmem.MM] |
|
quantify_loop_assigns [Lowlevel_model] |
|
R |
real_bool_cmp_binop_name [Why_ops] |
These are WHY names from library real.why : real -> real -> bool
|
replace [Cil2cfg.HEsig] |
|
replace [Cil2cfg.HE] |
|
replace_at_vars [Toprop.T_no_call] |
examine the label and look for it in env .
|
replace_at_vars [Mvar.MC] |
Build the substitution function to restore \at stmt expressions.
|
replace_at_vars [Mmem.MM] |
|
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] |
|
result_var [Macros] |
|
return [Toprop.T_for_Cfg] |
|
return [Toprop.T_no_call] |
|
return [Mvar.MC] |
|
return [Mmem.MM] |
|
return [Calculus.Moblig] |
|
return [Calculus.Msimple] |
|
run_and_prove [Wp_gui] |
|
S |
selector [Wp_gui] |
|
set_back_edge [Cil2cfg] |
|
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_pos [Cil2cfg.WeiMaoZouChenInput] |
store the position for the node and also the fact that the node has
been seen
|
set_pos [Cil2cfg.LoopInfo] |
|
set_wp_edge [Calculus.Cfg] |
store the result p for the computation of the edge e.
|
shift_offset [Why_ops.M3] |
|
shift_pointer [Why_ops] |
p.
|
show_cfg [Wp_gui] |
|
some [Why_ops] |
defined in acsl.why : 'a -> 'a option
|
sort_id_prop [Calculus.Moblig] |
|
sort_named_prop [Calculus.Moblig] |
|
stmt [Cil2cfg.VL] |
|
stmt_opt [Cil2cfg.VL] |
|
struct_field_type [Types] |
|
sub_pointer [Why_ops] |
|
subst_exp_mem [Mmem.MT] |
|
subst_in_exp [Fol] |
subst_in_exp prop_in_data x e exp
|
subst_in_pred [Fol] |
subst_in_pred prop_in_data x exp p
|
subst_in_predicate [Fol] |
|
subst_pred_mem [Mmem.MT] |
|
subst_res_var [Model2.M] |
|
subst_res_var [Mmem.Mm_sig] |
used to change \result by a fresh variable in a postcondition
from a called function
|
subst_res_var [Lowlevel_model.M] |
|
subst_var [Mvar.MV] |
|
subst_vars [Mvar.MV] |
|
subst_vars_in_pred [Fol] |
subst_vars_in_pred prop_in_data var_subst p
|
subst_vars_in_predicate [Fol] |
|
T |
tcond [Mmem.MM] |
|
term [Why_output] |
|
term_at [Translate.MT_sig] |
translate \at(exp,L) (or \old(exp) if the label is None)
|
term_at [Mvar.MT] |
build a new variable
and store in env that this variable is equal to e at label label .
|
term_at [Mmem.MT] |
|
test [Toprop.T_for_Cfg] |
|
test [Toprop.T_no_call] |
|
test [Mvar.MC] |
|
test [Mmem.MM] |
|
test [Calculus.Moblig] |
|
test [Calculus.Msimple] |
|
test_behav [WpAnnot] |
|
texpr [Mvar.MC] |
|
texpr [Mmem.MM] |
|
translate [Toprop.T_no_call] |
Translate a predicate in order to add it as a goal or and hypothesis
|
translate [Mvar.MC] |
|
translate [Mmem.MM] |
|
translate_data_in_pred [Fol] |
|
translate_data_in_term [Fol] |
translate_data_in_term do_data exp
|
try_or_bot [Calculus.Msimple] |
|
type_table [Types] |
|
U |
union_field_type [Types] |
|
unstructuredness [Cil2cfg.LoopInfo] |
|
use_bottom [Calculus] |
|
V |
valid_pointer [Why_ops] |
|
var_addr [WpFol] |
table to store for each lv (identified by its lv_id) the corresponding
addr_var.
|
var_counter [Fol] |
|
var_name [Fol] |
|
var_type [Fol] |
|
vardata2type [Model2] |
|
vertex_attributes [Cil2cfg.Printer] |
|
vertex_name [Cil2cfg.Printer] |
|
visit_exp_in_data [Mvar.Mv_sig] |
|
visit_exp_in_data [Model1.M] |
|
visit_exp_in_data [Model0.M] |
|
W |
why_file [Register] |
|
why_keyword [Why_ops] |
|
why_prelude [Model2] |
|
why_prelude [Model1] |
|
why_prelude [Model0] |
|
why_prelude [Lowlevel_model] |
|
wp_call [Calculus.Cfg] |
|
wp_cfg_dot [Register] |
build the CFG dot file, and return its name if everythink is OK.
|
wp_cfg_fun [Register] |
|
wp_loop [Toprop.T_for_Cfg] |
|
wp_loop [Calculus.Moblig] |
|
wp_loop [Calculus.Msimple] |
|
wp_panel [Wp_gui] |
|
wp_stmt [Calculus.Cfg] |
|
wp_why_file [Register] |
build the WHY file and return its name if everythink is OK.
|