A | |
| accumulate_vertex [FixpointStd] |
Compute the least upper bound of the current value of the
vertex/variable with the values propagated by the incoming
hyperedges belonging to the working set.
|
| add [Hashhe.Compare] | |
| add [Hashhe.S] | |
| add [Hashhe] | add tbl x y adds a binding of x to y in table tbl.
|
| add [Sette.Compare] | |
| add [Sette.S] | add x s returns a set containing all elements of s,
plus x.
|
| add [Sette] | add x s returns a set containing all elements of s,
plus x.
|
| add_active_hedges [FixpointGuided] | |
| add_hedge [SHGraph.Compare] | |
| add_hedge [SHGraph.S] | |
| add_hedge [SHGraph] |
Add an hyperedge.
|
| add_vertex [SHGraph.Compare] | |
| add_vertex [SHGraph.S] | |
| add_vertex [SHGraph] |
Add a vertex
|
| analysis [FixpointDyn] | |
| analysis [FixpointGuided] |
Same as
FixpointStd.analysis, but with the technique of
Gopan and Reps published in Static Anlaysis Symposium,
SAS'2007.
|
| analysis [FixpointStd] |
Main user function:
analysis manager equation_graph sinit
strategy takes a graph giving the structure of the equation
system, a manager indicating how to interpret the equation
system, a (super)set of the variables to be initialized to a
non-empty value, and an iteration strategy.
|
| analysis_dyn [Fixpoint] |
Dynamic analysis.
|
| analysis_guided [Fixpoint] |
Same as
Fixpoint.analysis_std, but with the technique of
Gopan and Reps published in Static Anlaysis Symposium,
SAS'2007.
|
| analysis_std [Fixpoint] |
Performs initialization, fixpoint analysis and descending,
and measures the global analysis time.
|
| append [Ilist] |
Append two lists
|
| array [Print] |
Print an array
|
| atome [Ilist] |
Create a list element from a single element.
|
| attrhedge [SHGraph.Compare] | |
| attrhedge [SHGraph.S] | |
| attrhedge [SHGraph] | attrhedge graph hedge returns the information associated to the
hyperedge hedge
|
| attrvertex [SHGraph.Compare] | |
| attrvertex [SHGraph.S] | |
| attrvertex [SHGraph] | attrvertex graph vertex returns the information associated to the
vertex vertex
|
C | |
| cardinal [Sette.S] |
Return the number of elements of a set.
|
| cardinal [Sette] |
Return the number of elements of a set.
|
| cfc [SHGraph.Compare] | |
| cfc [SHGraph.S] | |
| cfc [SHGraph] |
Decomposition of the graph into Strongly Connected Components,
|
| cfc_multi [SHGraph.Compare] | |
| cfc_multi [SHGraph.S] | |
| cfc_multi [SHGraph] |
idem, but from several initial vertices.
|
| choose [Sette.S] |
Return one element of the given set, or raise
Not_found if
the set is empty.
|
| choose [Sette] |
Return one element of the given set, or raise
Not_found if the set
is empty.
|
| clear [SHGraph.S] | |
| clear [SHGraph] |
Remove all vertices and hyperedges of the graph.
|
| clear [Hashhe.S] | |
| clear [Hashhe] |
Empty a hash table.
|
| compare [Sette.Compare] | |
| compare [Sette.S] |
Total ordering between sets.
|
| compare [Sette] |
Total ordering between sets.
|
| cons [Ilist] |
Adding a new list element at the begining of the list
|
| copy [SHGraph.S] | |
| copy [SHGraph] |
Copy an hypergraph, using the given functions to duplicate the
attributes associated to the elements of the graph.
|
| copy [Hashhe.S] | |
| copy [Hashhe] |
Return a copy of the given hashtable.
|
| create [SHGraph.S] | |
| create [SHGraph] | create n data creates an hypergraph, using n for the initial size
of internal hashtables, and data for the user information
|
| create [Hashhe.S] | |
| create [Hashhe] | create n creates a new, empty hash table, with
initial size n.
|
D | |
| depth [Ilist] |
Return the (maximal) depth of the list.
|
| descend [FixpointStd] |
(Rather internal)
|
| descend_strategy [FixpointStd] |
Internal functions
|
| diff [Sette.Compare] | |
| diff [Sette.S] |
Set difference.
|
| diff [Sette] |
Union, intersection and set difference.
|
| dot_graph [FixpointType] |
Prints internal graph on the (optional) formatter
man.dot_fmt, see type FixpointType.manager.
|
E | |
| elements [Sette.S] |
Return the list of all elements of the given set.
|
| elements [Sette] |
Return the list of all elements of the given set.
|
| empty [Sette.S] |
The empty set.
|
| empty [Sette] |
The empty set.
|
| equal [Hashhe.HashedType] |
The equality predicate used to compare keys.
|
| equal [Sette.Compare] | |
| equal [Sette.S] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
| equal [Sette] | equal s1 s2 tests whether the sets s1 and s2 are
equal, that is, contain equal elements.
|
| equation_of_graph [Fixpoint] |
Generate from a graph a function of type
('vertex,
'hedge) equation or dynamically exploring the graph.
|
| equation_of_graph [FixpointDyn] | |
| escaped [Print] |
Escape a string, replacing line breaks by
linebreak (default
'\n').
|
| exists [Ilist] |
Existence test
|
| exists [Sette.S] | exists p s checks if at least one element of
the set satisfies the predicate p.
|
| exists [Sette] | exists p s checks if at least one element of
the set satisfies the predicate p.
|
F | |
| filter [Sette.Compare] | |
| filter [Sette.S] | filter p s returns the set of all elements in s
that satisfy predicate p.
|
| filter [Sette] | filter p s returns the set of all elements in s
that satisfy predicate p.
|
| find [Hashhe.Compare] | |
| find [Hashhe.S] | |
| find [Hashhe] | find tbl x returns the current binding of x in tbl,
or raises Not_found if no such binding exists.
|
| find_all [Hashhe.Compare] | |
| find_all [Hashhe.S] | |
| find_all [Hashhe] | find_all tbl x returns the list of all data
associated with x in tbl.
|
| fixpoint [FixpointDyn] | |
| flatten [Ilist] |
Flatten the recursive list, only starting from the given
|
| fold [Hashhe.S] | |
| fold [Hashhe] | 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 [Sette.S] | fold f s a computes (f xN ... (f x2 (f x1 a))...),
where x1 ... xN are the elements of s.
|
| fold [Sette] | fold f s a computes (f xN ... (f x2 (f x1 a))...),
where x1 ... xN are the elements of s.
|
| fold_hedge [SHGraph.S] | |
| fold_hedge [SHGraph] | |
| fold_left [Ilist] |
Ordinary fold function for atoms, from left to right.
|
| fold_right [Ilist] |
Ordinary fold function for atoms, from right to left.
|
| fold_vertex [SHGraph.S] | |
| fold_vertex [SHGraph] | |
| for_all [Sette.S] | for_all p s checks if all elements of the set
satisfy the predicate p.
|
| for_all [Sette] | for_all p s checks if all elements of the set
satisfy the predicate p.
|
G | |
| graph_of_equation [Fixpoint] |
Generate from an equation a graph, using
make_attrvertex, make_attrhedge and info.
|
| graph_of_equation [FixpointDyn] | |
H | |
| hash [Hashhe.HashedType] |
A hashing function on keys.
|
| hash [Hashhe] | hash x associates a positive integer to any value of
any type.
|
| hash [Print] |
Print an hashtable
|
| hash_param [Hashhe] | hash_param n m x computes a hash value for x, with the
same properties as for hash.
|
| hd [Ilist] |
Return the head of the list.
|
| hedge_dummy [SHGraph.T] |
A dummy (never used) value for hyperedge identifiers (used for
the functions
XXX_multi)
|
| hedge_dummy [SHGraph.S] | |
I | |
| ilist_map_condense [FixpointType] | |
| inference [FixpointThreshold] |
Inference functions, taking a standard manager, a
threshold manager, an equation graph, and an iteration
strategy.
|
| info [SHGraph.S] | |
| info [SHGraph] | info g returns the user-information attached to the graph g
|
| init [FixpointDyn] | |
| init [FixpointStd] | init manager input sinit creates the internal graph
structure (from the equation graph input) and initialize the
working sets (from the set of initial points sinit) (stored
in the info field of the internal graph).
|
| inter [Sette.Compare] | |
| inter [Sette.S] |
Set intersection.
|
| inter [Sette] | |
| is_empty [SHGraph.S] | |
| is_empty [SHGraph] |
Is the graph empty ?
|
| is_empty [Sette.S] |
Test whether a set is empty or not.
|
| is_empty [Sette] |
Test whether a set is empty or not.
|
| is_hedge [SHGraph.Compare] | |
| is_hedge [SHGraph.S] | |
| is_hedge [SHGraph] | |
| is_tvertex [FixpointStd] |
Does the array of vertices belong to the graph, all with
non bottom values ?
|
| is_vertex [SHGraph.Compare] | |
| is_vertex [SHGraph.S] | |
| is_vertex [SHGraph] | |
| iter [Ilist] |
Ordinary iteration function for atoms
|
| iter [Hashhe.S] | |
| iter [Hashhe] | iter f tbl applies f to all bindings in table tbl.
|
| iter [Sette.S] | iter f s applies f in turn to all elements of s.
|
| iter [Sette] | iter f s applies f in turn to all elements of s.
|
| iter_hedge [SHGraph.S] | |
| iter_hedge [SHGraph] |
Iterates the function
f hedge attrhedge succvertices predvertices to
all hyperedges of the graph.
|
| iter_vertex [SHGraph.S] | |
| iter_vertex [SHGraph] |
Iterates the function
f vertex attrvertex succhedges predhedges to all
vertices of the graph.
|
L | |
| length [Ilist] |
Return the ength of the list.
|
| length [Hashhe.S] | |
| length [Hashhe] | length tbl returns the number of bindings in tbl.
|
| list [Ilist] |
Create a list element from a list.
|
| list [Print] |
Print a list
|
M | |
| make_strategy_default [Fixpoint] |
Build a "default" strategy, with the following options:
|
| make_strategy_default [FixpointType] |
Build a "default" strategy, with the following options:
|
| make_strategy_iteration [FixpointType] | |
| map [SHGraph.S] | |
| map [SHGraph] | |
| map [Ilist] |
Ordinary map function
|
| map [Hashhe.S] | |
| map [Hashhe] | map f tbl applies f to all bindings in table tbl and creates
a new hashtable associating the results of f to the same key type.
|
| max [SHGraph.Compare] | |
| max [SHGraph.S] | |
| max [SHGraph] |
Return the set of vertices without successor hyperedges
|
| max_elt [Sette.S] |
Same as
Sette.S.min_elt, but returns the largest element of the
given set.
|
| max_elt [Sette] |
Same as
min_elt, but returns the largest element of the given
set.
|
| mem [Ilist] |
Membership test.
|
| mem [Hashhe.Compare] | |
| mem [Hashhe.S] | |
| mem [Hashhe] | mem tbl x checks if x is bound in tbl.
|
| mem [Sette.Compare] | |
| mem [Sette.S] | mem x s tests whether x belongs to the set s.
|
| mem [Sette] | mem x s tests whether x belongs to the set s.
|
| min [SHGraph.Compare] | |
| min [SHGraph.S] | |
| min [SHGraph] |
Return the set of vertices without predecessor hyperedges
|
| min_elt [Sette.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.
|
| min_elt [Sette] |
Return the smallest element of the given set (with respect to the
Ord.compare ordering), or raise Not_found if the set is empty.
|
O | |
| obj [Sette.S] | |
| of_list [Ilist] |
Create a recursive list from a regular list
|
| option [Print] |
Print an optional element
|
| output_of_graph [FixpointStd] |
(Rather internal function)
|
P | |
| pair [Print] |
Print a pair
|
| partition [Sette.Compare] | |
| partition [Sette.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.
|
| partition [Sette] | 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.
|
| pred_vertex [SHGraph.Compare] | |
| pred_vertex [SHGraph.S] | |
| pred_vertex [SHGraph] |
Predecessor vertices of a vertex by any hyperedge
|
| predhedge [SHGraph.Compare] | |
| predhedge [SHGraph.S] | |
| predhedge [SHGraph] |
Predecessor hyperedges of a vertex
|
| predvertex [SHGraph.Compare] | |
| predvertex [SHGraph.S] | |
| predvertex [SHGraph] |
Predecessor vertices of an hyperedge
|
| print [SHGraph.Compare] | |
| print [SHGraph.S] | |
| print [SHGraph] |
Print a graph in textual format on the given formatter, using the given
functions to resp.
|
| print [Ilist] |
Printing function.
|
| print [Hashhe.S] | |
| print [Hashhe] | |
| print [Sette.S] | |
| print [Sette] | |
| print_arc [FixpointType] | |
| print_attr [FixpointType] | |
| print_dot [SHGraph.S] | |
| print_dot [SHGraph] |
Output the graph in DOT format on the given formatter, using the given
functions to resp print:
|
| print_graph [FixpointType] |
Prints internal graph.
|
| print_info [FixpointType] | |
| print_of_string [Print] |
Transforms a conversion-to-string function to a printing function.
|
| print_output [Fixpoint] |
Prints the result of an analysis.
|
| print_output [FixpointType] |
Prints the result of an analysis.
|
| print_stat [Fixpoint] |
Prints statistics
|
| print_stat [FixpointType] |
Prints statistics
|
| print_stat_iteration [FixpointType] | |
| print_stat_iteration_ilist [FixpointType] | |
| print_strategy [Fixpoint] | print_strategy_vertex man fmt sv prints an object of type
strategy, using the manager man for printing vertices and
hyperedges.
|
| print_strategy [FixpointType] | print_strategy_vertex man fmt sv prints an object of type
strategy, using the manager man for printing vertices and
hyperedges.
|
| print_strategy_iteration [FixpointType] | |
| print_strategy_vertex [Fixpoint] | print_strategy_vertex man fmt sv prints an object of type
strategy_vertex, using the manager man for printing vertices and
hyperedges.
|
| print_strategy_vertex [FixpointType] | print_strategy_vertex man fmt sv prints an object of type
strategy_vertex, using the manager man for printing vertices and
hyperedges.
|
| print_workingsets [FixpointType] | |
| process_strategy [FixpointStd] | |
| process_toplevel_strategy [FixpointStd] |
(Rather internal function)
|
| process_vertex [FixpointStd] | |
| propagate [FixpointDyn] | |
| propagate_vertex [FixpointStd] | |
R | |
| reachable [SHGraph.Compare] | |
| reachable [SHGraph.S] | |
| reachable [SHGraph] |
Returns the set of vertices and hyperedges that are *NOT* reachable from
the given root vertex.
|
| reachable_multi [SHGraph.Compare] | |
| reachable_multi [SHGraph.S] | |
| reachable_multi [SHGraph] | |
| remove [Hashhe.Compare] | |
| remove [Hashhe.S] | |
| remove [Hashhe] | remove tbl x removes the current binding of x in tbl,
restoring the previous binding if it exists.
|
| remove [Sette.Compare] | |
| remove [Sette.S] | remove x s returns a set containing all elements of s,
except x.
|
| remove [Sette] | remove x s returns a set containing all elements of s, except
x.
|
| remove_hedge [SHGraph.Compare] | |
| remove_hedge [SHGraph.S] | |
| remove_hedge [SHGraph] |
Remove the hyperedge from the graph.
|
| remove_vertex [SHGraph.Compare] | |
| remove_vertex [SHGraph.S] | |
| remove_vertex [SHGraph] |
Remove the vertex from the graph, as well as all related hyperedges.
|
| replace [Hashhe.Compare] | |
| replace [Hashhe.S] | |
| replace [Hashhe] | replace tbl x y replaces the current binding of x
in tbl by a binding of x to y.
|
| replace_attrhedge [SHGraph.Compare] | |
| replace_attrhedge [SHGraph.S] | |
| replace_attrhedge [SHGraph] |
Change the attribute of an existing hyperedge
|
| replace_attrvertex [SHGraph.Compare] | |
| replace_attrvertex [SHGraph.S] | |
| replace_attrvertex [SHGraph] |
Change the attribute of an existing vertex
|
| repr [Sette.S] | |
| resize [Hashhe.Compare] | |
| rev [Ilist] |
Recursively reverse the recursive list
rev [a;[b;[c];d];e;[f]] = [[f];e;[d;[c];b];a]
|
S | |
| scfc [SHGraph.Compare] | |
| scfc [SHGraph.S] | |
| scfc [SHGraph] |
Decomposition of the graph into Strongly Connected Sub-Components,
|
| scfc_multi [SHGraph.Compare] | |
| scfc_multi [SHGraph.S] | |
| scfc_multi [SHGraph] |
idem, but from several initial vertices.
|
| singleton [Sette.S] | singleton x returns the one-element set containing only x.
|
| singleton [Sette] | singleton x returns the one-element set containing only x.
|
| size [SHGraph.S] | |
| size [SHGraph] | size graph returns (nbvertex,nbhedge,nbedgevh,nbedgehv)
|
| size_edgehv [SHGraph.S] | |
| size_edgehv [SHGraph] |
Number of edges (hyperedge,vertex) in the hypergraph
|
| size_edgevh [SHGraph.S] | |
| size_edgevh [SHGraph] |
Number of edges (vertex,hyperedge) in the hypergraph
|
| size_hedge [SHGraph.S] | |
| size_hedge [SHGraph] |
Number of hyperedges in the hypergraph
|
| size_vertex [SHGraph.S] | |
| size_vertex [SHGraph] |
Number of vertices in the hypergraph
|
| split [Sette.Compare] |
Meant to be internal, but exporting needed for Mappe.maptoset.
|
| sprintf [Print] |
Better
sprintf function than Format.sprintf, as it takes the same
kind of formatters as other Format.Xprintf functions.
|
| stat_iteration_merge [FixpointType] | |
| stdcompare [SHGraph.S] | |
| stdcompare [SHGraph] | |
| stdcompare [Hashhe] | |
| string_of_print [Print] |
Transforms a printing function into a conversion-to-string function.
|
| subset [Sette.Compare] | |
| subset [Sette.S] | subset s1 s2 tests whether the set s1 is a subset of
the set s2.
|
| subset [Sette] | subset s1 s2 tests whether the set s1 is a subset of
the set s2.
|
| succ_vertex [SHGraph.Compare] | |
| succ_vertex [SHGraph.S] | |
| succ_vertex [SHGraph] |
Successor vertices of a vertex by any hyperedge
|
| succhedge [SHGraph.Compare] | |
| succhedge [SHGraph.S] | |
| succhedge [SHGraph] |
Successor hyperedges of a vertex
|
| succvertex [SHGraph.Compare] | |
| succvertex [SHGraph.S] | |
| succvertex [SHGraph] |
Successor vertices of an hyperedge
|
T | |
| tl [Ilist] |
Return the tail of the list.
|
| to_list [Ilist] |
Create a regular list from a recursive list.
|
| topological_sort [SHGraph.Compare] | |
| topological_sort [SHGraph.S] | |
| topological_sort [SHGraph] |
Topological sort of the vertices of the hypergraph starting from
a root vertex.
|
| topological_sort_multi [SHGraph.Compare] | |
| topological_sort_multi [SHGraph.S] | |
| topological_sort_multi [SHGraph] |
Topological sort from a set of root vertices.
|
| transpose [SHGraph.S] | |
| transpose [SHGraph] |
Similar to
copy, but hyperedges are reversed: successor vertices
and predecessor vertices are exchanged.
|
| treach_of_tvertex [FixpointStd] |
Return the array of abstract values associated to the
vertices
|
U | |
| union [Sette.Compare] | |
| union [Sette.S] |
Set union.
|
| union [Sette] | |
| update_workingsets [FixpointStd] |
Update working sets assuming that the abstract value
associated to the vertex has been modified.
|
V | |
| vertex_dummy [SHGraph.T] |
A dummy (never used) value for vertex identifiers (used for the
functions
XXX_multi)
|
| vertex_dummy [SHGraph.S] | |
W | |
| weak [Print] |
Print a weak pointer array
|
| wrap_duration [Time] | wrap_duration duration f executes the function f and stores into
!duration the time spent in f, in seconds.
|
| wrap_duration_add [Time] |
Similar to
wrap_duration, but here the time spent in f is added to
the value !duration.
|