Index of values


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.