A | |
add [Hashtbl.S] | |
add [Hashtbl] | Hashtbl.add tbl x y adds a binding of x to y in table tbl .
|
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 [Rte.GENERATED] | |
annotate_kf [Rte] | |
annotate_kf_with [Rte] | |
assertion_ge [Rte] | |
assertion_le [Rte] | |
C | |
cardinal [Set.S] |
Return the number of elements of a set.
|
choose [Set.S] |
Return one element of the given set, or raise
Not_found if
the set is empty.
|
clear [Hashtbl.S] | |
clear [Hashtbl] |
Empty a hash table.
|
clear [State_builder.Hashtbl] |
Clear the table.
|
compare [Set.S] |
Total ordering between sets.
|
compare [Rte.SkipId] | |
compute [Rte] | |
copy [Datatype.S] |
Deep copy: no possible sharing between
x and copy x .
|
copy [Hashtbl.S] | |
copy [Hashtbl] |
Return a copy of the given hashtable.
|
create [Hashtbl.S] | |
create [Hashtbl] | Hashtbl.create n creates a new, empty hash table, with
initial size n .
|
D | |
diff [Set.S] |
Set difference.
|
do_all_rte [Rte] | |
do_precond [Rte] | |
E | |
elements [Set.S] |
Return the list of all elements of the given set.
|
emit_status [Rte] | |
empty [Set.S] |
The empty set.
|
empty_gen [Rte.Parameter_map] | |
empty_other [Rte.Parameter_map] | |
end_msg [Register] | |
equal [Hashtbl.HashedType] |
The equality predicate used to compare keys.
|
equal [Set.S] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
exists [Set.S] | exists p s checks if at least one element of
the set satisfies the predicate p .
|
F | |
filter [Set.S] | filter p s returns the set of all elements in s
that satisfy predicate p .
|
find [Hashtbl.S] | |
find [Hashtbl] | Hashtbl.find tbl x returns the current binding of x in tbl ,
or raises Not_found if no such binding exists.
|
find [State_builder.Hashtbl] |
Return the current binding of the given key.
|
find_all [Hashtbl.S] | |
find_all [Hashtbl] | Hashtbl.find_all tbl x returns the list of all data
associated with x in tbl .
|
find_all [State_builder.Hashtbl] |
Return the list of all data associated with the given key.
|
find_current_gen_options [Rte.StateManager] | |
find_current_other_options [Rte.StateManager] | |
find_term_to_replace [Rte] | |
fmt_divisor_assert [Rte] | |
fmt_signed_overflow_assert [Rte] | |
fmt_unary_minus_assert [Rte] | |
fmt_unsigned_overflow_assert [Rte] | |
fmt_warn_bad_bitsize [Rte] | |
fmt_warn_bitsize_over_32 [Rte] | |
fmt_warn_bitsize_over_64 [Rte] | |
fmt_warn_no_valid_fptr_deref [Rte] | |
fmt_warn_shift_assert1 [Rte] | |
fmt_warn_shift_assert2 [Rte] | |
fmt_warn_shift_assert3 [Rte] | |
fmt_warn_shift_assert4 [Rte] | |
fmt_warn_signed_downcast_assert [Rte] | |
fold [Hashtbl.S] | |
fold [Hashtbl] | Hashtbl.fold f tbl init computes
(f kN dN ... (f k1 d1 init)...) ,
where k1 ... kN are the keys of all bindings in tbl ,
and d1 ... dN are the associated values.
|
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 [Abstract_interp.Int] | |
for_all [Set.S] | for_all p s checks if all elements of the set
satisfy the predicate p .
|
G | |
gen_from_command_line_options [Rte.Parameter_map] | |
generating_opts [Rte.Parameter_map] | |
get [Rte.Generated] | |
get [Rte.GENERATED] | |
get_all_status [Rte] | |
get_bitwise_lshift_unsigned_assertion [Rte] | |
get_bitwise_shift_assertion [Rte] | |
get_bitwise_shift_right_operand_assertion [Rte] | |
get_divMod_status [Rte] | |
get_divmod_assertion [Rte] | |
get_downCast_status [Rte] | |
get_downcast_assertion [Rte] | |
get_expr_val [Rte] | |
get_global_state [Rte] | |
get_lval_assertion [Rte] | |
get_memAccess_status [Rte] | |
get_multsubadd_assertion [Rte] | |
get_multsubadd_unsigned_assertion [Rte] | |
get_precond_state [Rte] | |
get_precond_status [Rte] | |
get_rte_state [Rte] | |
get_signedOv_status [Rte] | |
get_signed_div_assertion [Rte] | |
get_state [Rte.Generated] | |
get_state [Rte.PrecondAnnot_Proxy] | |
get_state [Rte.RTEAnnot_Proxy] | |
get_state [Rte.GENERATED] | |
get_state [Rte.PrecondAnnotTbl] | |
get_state [Rte.RteAnnotTbl] | |
get_state [Rte.RteGlobalTbl] | |
get_uminus_assertion [Rte] | |
get_unsignedOv_status [Rte] | |
H | |
hash [Hashtbl.HashedType] |
A hashing function on keys.
|
hash [Hashtbl] | Hashtbl.hash x associates a positive integer to any value of
any type.
|
hash_param [Hashtbl] | Hashtbl.hash_param n m x computes a hash value for x , with the
same properties as for hash .
|
help_msg [Rte_parameters] | |
I | |
inter [Set.S] |
Set intersection.
|
is_computed [Rte] | |
is_computed_kf [Rte] | |
is_empty [Set.S] |
Test whether a set is empty or not.
|
is_one_true [Rte.Parameter_map] | |
is_true [Rte.Parameter_map] | |
iter [Hashtbl.S] | |
iter [Hashtbl] | Hashtbl.iter f tbl applies f to all bindings in table tbl .
|
iter [Set.S] | iter f s applies f in turn to all elements of s .
|
iter [State_builder.Hashtbl] | |
L | |
label [Rte.KF] | |
length [Hashtbl.S] | |
length [Hashtbl] | Hashtbl.length tbl returns the number of bindings in tbl .
|
length [State_builder.Hashtbl] |
Length of the table.
|
M | |
main [Register] | |
max_elt [Set.S] |
Same as
Set.S.min_elt , but returns the largest element of the
given set.
|
mem [Hashtbl.S] | |
mem [Hashtbl] | Hashtbl.mem tbl x checks if x is bound in tbl .
|
mem [Set.S] | mem x s tests whether x belongs to the set s .
|
mem [State_builder.Hashtbl] | |
memo [State_builder.Hashtbl] |
Memoization.
|
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.
|
mk_term [Rte] | |
O | |
other_from_command_line_options [Rte.Parameter_map] | |
other_opts [Rte.Parameter_map] | |
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 .
|
precond_prefix [Rte] | |
pretty [Abstract_interp.Int] | |
print [Rte.Parameter_map] | |
R | |
remove [Hashtbl.S] | |
remove [Hashtbl] | Hashtbl.remove tbl x removes the current binding of x in tbl ,
restoring the previous binding if it exists.
|
remove [Set.S] | remove x s returns a set containing all elements of s ,
except x .
|
remove [State_builder.Hashtbl] | |
remove_annotations_kf [Rte] | |
replace [Hashtbl.S] | |
replace [Hashtbl] | Hashtbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y .
|
replace [State_builder.Hashtbl] |
Add a new binding.
|
replacement_visitor [Rte] | |
rte_prefix [Rte] | |
rte_warn [Rte] | |
S | |
self [Rte.Generated] | |
self [Rte.PrecondAnnot_Proxy] | |
self [Rte.RTEAnnot_Proxy] | |
self [Rte] | |
set [Rte.Generated] | |
set [Rte.GENERATED] | |
set_all_rte [Rte.Parameter_map] | |
set_precond [Rte.Parameter_map] | |
set_unsignedOv [Rte.Parameter_map] | |
singleton [Set.S] | singleton x returns the one-element set containing only x .
|
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 .
|
start_msg [Register] | |
subset [Set.S] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
|
T | |
tlval_fetcher_visitor [Rte] | |
translate_C_expr_to_term [Rte] | |
treat_pred [Rte] | |
treat_term [Rte] | |
treat_tlval [Rte] | |
U | |
union [Set.S] |
Set union.
|