A | |
| add [Hashhe.S] | |
| add [Hashhe] | Hashtbl.add tbl x y adds a binding of x to y in table tbl.
|
| 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_hedge [SHGraph.S] | |
| add_hedge [SHGraph] |
Add an hyperedge.
|
| add_vertex [SHGraph.S] | |
| add_vertex [SHGraph] |
Add a vertex
|
| analysis [MkFixpoint.S] |
Performs initialization, fixpoint analysis and descending, and measures
the global analysis time.
|
| analysis_guided [MkFixpoint.S] |
Same as
analysis, but with the technique of Gopan and Reps published
in Static Anlaysis Symposium, SAS'2007.
|
| append [Ilist] |
Append two lists
|
| array [Print] |
Print an array
|
| atome [Ilist] |
Create a list element from a single element.
|
| attrhedge [SHGraph.S] | |
| attrhedge [SHGraph] | attrhedge graph hedge returns the information associated to the
hyperedge hedge
|
| 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.S] | |
| cfc [SHGraph] |
Decomposition of the graph into Strongly Connected Components,
|
| cfc_filter_multi [SHGraph.S] | |
| cfc_filter_multi [SHGraph] |
idem, but with a filtering of dependencies
|
| cfc_multi [SHGraph.S] | |
| cfc_multi [SHGraph] |
idem, but from several initial vertices.
|
| cfc_priority_multi [SHGraph.S] | |
| cfc_priority_multi [SHGraph] |
idem, but with a priority of dependencies.
|
| 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.S] |
Total ordering between sets.
|
| compare [Sette] |
Total ordering between sets.
|
| concat [Ilist] |
Flatten the recursive list and converts it to a list
|
| 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] | Hashtbl.create n creates a new, empty hash table, with
initial size n.
|
D | |
| depth [Ilist] |
Return the (maximal) depth of the list.
|
| descend [MkFixpoint.S] | descend manager graph sinit strategy performs several descending
steps, depending on the option manager.widening_descend.
|
| diff [Sette.S] |
Set difference.
|
| diff [Sette] |
Union, intersection and set difference.
|
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.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.
|
| escaped [SHGraph] |
Escape a string, replacing line breaks by
linebreak (default
'\n').
|
| 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.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.S] | |
| find [Hashhe] | Hashtbl.find tbl x returns the current binding of x in tbl,
or raises Not_found if no such binding exists.
|
| find_all [Hashhe.S] | |
| find_all [Hashhe] | Hashtbl.find_all tbl x returns the list of all data
associated with x in tbl.
|
| fixpoint [MkFixpoint.S] | fixpoint manager graph strategy computes a fixpoint (or a
postfixpoint in case of widening) of the system of equation represented
by graph.
|
| flatten [Ilist] |
Flatten the recursive list, but only starting from the given
depth.
|
| fold [Hashhe.S] | |
| fold [Hashhe] | 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 [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, from left to right.
|
| 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.
|
H | |
| hash [Hashhe.HashedType] |
A hashing function on keys.
|
| hash [Hashhe] | Hashtbl.hash x associates a positive integer to any value of
any type.
|
| hash [Print] |
Print an hashtable
|
| hash_param [Hashhe] | Hashtbl.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)
|
I | |
| info [SHGraph.S] | |
| info [SHGraph] | info g returns the user-information attached to the graph g
|
| init [MkFixpoint.S] | init manager inputgraph sinit creates an internal graph and
initializes it.
|
| 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.S] | |
| is_hedge [SHGraph] | |
| is_vertex [SHGraph.S] | |
| is_vertex [SHGraph] | |
| iter [Ilist] |
Ordinary iteration function.
|
| iter [Hashhe.S] | |
| iter [Hashhe] | Hashtbl.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_rec [Ilist] |
Recursive iteration function, rather complex.
|
| 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] | Hashtbl.length tbl returns the number of bindings in tbl.
|
| list [Ilist] |
Create a list element from a list.
|
| list [Print] |
Print a list
|
M | |
| map [SHGraph.S] | |
| map [SHGraph] | |
| map [Ilist] |
Ordinary map function.
|
| map [Hashhe.S] | |
| map [Hashhe] | Hashtbl.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.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.S] | |
| mem [Hashhe] | Hashtbl.mem tbl x checks if x is bound in tbl.
|
| 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.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] | |
| obj [Sette] | |
| of_list [Ilist] |
Create a recursive list from a list
|
| output_of_graph [MkFixpoint.S] |
Getting the result of the analysis.
|
P | |
| pair [Print] |
Print a pair
|
| 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.S] | |
| pred_vertex [SHGraph] |
Predecessor vertices of a vertex by any hyperedge
|
| predhedge [SHGraph.S] | |
| predhedge [SHGraph] |
Predecessor hyperedges of a vertex
|
| predvertex [SHGraph.S] | |
| predvertex [SHGraph] |
Predecessor vertices of an hyperedge
|
| 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_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 [MkFixpoint.S] |
Prints internal graph.
|
| print_of_string [Print] |
Transforms a conversion-to-string function to a printing function.
|
| print_output [MkFixpoint.S] |
Prints the result of an analysis.
|
| print_stat [MkFixpoint.S] |
Prints statistics
|
| print_strategy [MkFixpoint.S] | print_strategy_vertex man fmt sv prints an object of type
strategy, using the manager man for printing vertices and
hyperedges.
|
| print_strategy_vertex [MkFixpoint.S] | print_strategy_vertex man fmt sv prints an object of type
strategy_vertex, using the manager man for printing vertices and
hyperedges.
|
R | |
| reachable [SHGraph.S] | |
| reachable [SHGraph] |
Returns the set of vertices and hyperedges that are *NOT* reachable from
the given root vertex.
|
| reachable_filter_multi [SHGraph.S] | |
| reachable_filter_multi [SHGraph] | |
| reachable_multi [SHGraph.S] | |
| reachable_multi [SHGraph] | |
| remove [Hashhe.S] | |
| remove [Hashhe] | Hashtbl.remove tbl x removes the current binding of x in tbl,
restoring the previous binding if it exists.
|
| 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.S] | |
| remove_hedge [SHGraph] |
Remove the hyperedge from the graph.
|
| remove_vertex [SHGraph.S] | |
| remove_vertex [SHGraph] |
Remove the vertex from the graph, as well as all related hyperedges.
|
| replace [Hashhe.S] | |
| replace [Hashhe] | Hashtbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y.
|
| repr [Sette.S] | |
| repr [Sette] | |
| rev [Ilist] |
Recursively reverse the recursive list
rev [a;[b;[c];d];e;[f]] = [[f];e;[d;[c];b];a]
|
S | |
| scfc [SHGraph.S] | |
| scfc [SHGraph] |
Decomposition of the graph into Strongly Connected Sub-Components,
|
| scfc_filter_multi [SHGraph.S] | |
| scfc_filter_multi [SHGraph] |
idem, but with a filtering of dependencies
|
| scfc_multi [SHGraph.S] | |
| scfc_multi [SHGraph] |
idem, but from several initial vertices.
|
| scfc_priority_multi [SHGraph.S] | |
| scfc_priority_multi [SHGraph] |
idem, but with a priority of dependencies.
|
| 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
|
| splitzz [Sette.S] | |
| splitzz [Sette] |
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.
|
| strategy_default [MkFixpoint.S] |
Build a "default" strategy, with the following options:
|
| string_of_print [Print] |
Transforms a printing function into a conversion-to-string function.
|
| 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.S] | |
| succ_vertex [SHGraph] |
Successor vertices of a vertex by any hyperedge
|
| succhedge [SHGraph.S] | |
| succhedge [SHGraph] |
Successor hyperedges of a vertex
|
| succvertex [SHGraph.S] | |
| succvertex [SHGraph] |
Successor vertices of an hyperedge
|
T | |
| tl [Ilist] |
Return the tail of the list.
|
| topological_sort [SHGraph.S] | |
| topological_sort [SHGraph] |
Topological sort of the vertices of the hypergraph starting from
a root vertex.
|
| topological_sort_filter_multi [SHGraph.S] | |
| topological_sort_filter_multi [SHGraph] |
Variant of the previous function, where the Boolean function
f hedge
succ tells whether the given dependency should be taken into account or
not in the sort.
|
| 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 predecssor vertices are exchanged.
|
U | |
| union [Sette.S] |
Set union.
|
| union [Sette] | |
V | |
| vertex_dummy [SHGraph.T] |
A dummy (never used) value for vertex identifiers (used for the
functions
XXX_multi)
|
W | |
| 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.
|