mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-13 04:44:39 +00:00
b5ae12b829
Estimated hours taken: 50
Add support for nested modules.
- module names may themselves be module-qualified
- modules may contain `:- include_module' declarations
which name sub-modules
- a sub-module has access to all the declarations in the
parent module (including its implementation section).
This support is not yet complete; see the BUGS and LIMITATIONS below.
LIMITATIONS
- source file names must match module names
(just as they did previously)
- mmc doesn't allow path names on the command line any more
(e.g. `mmc --make-int ../library/foo.m').
- import_module declarations must use the fully-qualified module name
- module qualifiers must use the fully-qualified module name
- no support for root-qualified module names
(e.g. `:parent:child' instead of `parent:child').
- modules may not be physically nested (only logical nesting, via
`include_module').
BUGS
- doesn't check that the parent module is imported/used before allowing
import/use of its sub-modules.
- doesn't check that there is an include_module declaration in the
parent for each module claiming to be a child of that parent
- privacy of private modules is not enforced
-------------------
NEWS:
Mention that we support nested modules.
library/ops.m:
library/nc_builtin.nl:
library/sp_builtin.nl:
compiler/mercury_to_mercury.m:
Add `include_module' as a new prefix operator.
Change the associativity of `:' from xfy to yfx
(since this made parsing module qualifiers slightly easier).
compiler/prog_data.m:
Add new `include_module' declaration.
Change the `module_name' and `module_specifier' types
from strings to sym_names, so that module names can
themselves be module qualified.
compiler/modules.m:
Add predicates module_name_to_file_name/2 and
file_name_to_module_name/2.
Lots of changes to handle parent module dependencies,
to create parent interface (`.int0') files, to read them in,
to output correct dependencies information for them to the
`.d' and `.dep' files, etc.
Rewrite a lot of the code to improve the readability
(add comments, use subroutines, better variable names).
Also fix a couple of bugs:
- generate_dependencies was using the transitive implementation
dependencies rather than the transitive interface dependencies
to compute the `.int3' dependencies when writing `.d' files
(this bug was introduced during crs's changes to support
`.trans_opt' files)
- when creating the `.int' file, it was reading in the
interfaces for modules imported in the implementation section,
not just those in the interface section.
This meant that the compiler missed a lot of errors.
library/graph.m:
library/lexer.m:
library/term.m:
library/term_io.m:
library/varset.m:
compiler/*.m:
Add `:- import_module' declarations to the interface needed
by declarations in the interface. (The previous version
of the compiler did not detect these missing interface imports,
due to the above-mentioned bug in modules.m.)
compiler/mercury_compile.m:
compiler/intermod.m:
Change mercury_compile__maybe_grab_optfiles and
intermod__grab_optfiles so that they grab the opt files for
parent modules as well as the ones for imported modules.
compiler/mercury_compile.m:
Minor changes to handle parent module dependencies.
(Also improve the wording of the warning about trans-opt
dependencies.)
compiler/make_hlds.m:
compiler/module_qual.m:
Ignore `:- include_module' declarations.
compiler/module_qual.m:
A couple of small changes to handle nested module names.
compiler/prog_out.m:
compiler/prog_util.m:
Add new predicates string_to_sym_name/3 (prog_util.m) and
sym_name_to_string/{2,3} (prog_out.m).
compiler/*.m:
Replace many occurrences of `string' with `module_name'.
Change code that prints out module names or converts
them to strings or filenames to handle the fact that
module names are now sym_names intead of strings.
Also change a few places (e.g. in intermod.m, hlds_module.m)
where the code assumed that any qualified symbol was
fully-qualified.
compiler/prog_io.m:
compiler/prog_io_goal.m:
Move sym_name_and_args/3, parse_qualified_term/4 and
parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m,
since they are very similar to the parse_symbol_name/2 predicate
already in prog_io.m. Rewrite these predicates, both
to improve maintainability, and to handle the newly
allowed syntax (module-qualified module names).
Rename parse_qualified_term/5 as `parse_implicit_qualified_term'.
compiler/prog_io.m:
Rewrite the handling of `:- module' and `:- end_module'
declarations, so that it can handle nested modules.
Add code to parse `include_module' declarations.
compiler/prog_util.m:
compiler/*.m:
Add new predicates mercury_public_builtin_module/1 and
mercury_private_builtin_module/1 in prog_util.m.
Change most of the hard-coded occurrences of "mercury_builtin"
to call mercury_private_builtin_module/1 or
mercury_public_builtin_module/1 or both.
compiler/llds_out.m:
Add llds_out__sym_name_mangle/2, for mangling module names.
compiler/special_pred.m:
compiler/mode_util.m:
compiler/clause_to_proc.m:
compiler/prog_io_goal.m:
compiler/lambda.m:
compiler/polymorphism.m:
Move the predicates in_mode/1, out_mode/1, and uo_mode/1
from special_pred.m to mode_util.m, and change various
hard-coded definitions to instead call these predicates.
compiler/polymorphism.m:
Ensure that the type names `type_info' and `typeclass_info' are
module-qualified in the generated code. This avoids a problem
where the code generated by polymorphism.m was not considered
type-correct, due to the type `type_info' not matching
`mercury_builtin:type_info'.
compiler/check_typeclass.m:
Simplify the code for check_instance_pred and
get_matching_instance_pred_ids.
compiler/mercury_compile.m:
compiler/modules.m:
Disallow directory names in command-line arguments.
compiler/options.m:
compiler/handle_options.m:
compiler/mercury_compile.m:
compiler/modules.m:
Add a `--make-private-interface' option.
The private interface file `<module>.int0' contains
all the declarations in the module; it is used for
compiling sub-modules.
scripts/Mmake.rules:
scripts/Mmake.vars.in:
Add support for creating `.int0' and `.date0' files
by invoking mmc with `--make-private-interface'.
doc/user_guide.texi:
Document `--make-private-interface' and the `.int0'
and `.date0' file extensions.
doc/reference_manual.texi:
Document nested modules.
util/mdemangle.c:
profiler/demangle.m:
Demangle names with multiple module qualifiers.
tests/general/Mmakefile:
tests/general/string_format_test.m:
tests/general/string_format_test.exp:
tests/general/string__format_test.m:
tests/general/string__format_test.exp:
tests/general/.cvsignore:
Change the `:- module string__format_test' declaration in
`string__format_test.m' to `:- module string_format_test',
because with the original declaration the `__' was taken
as a module qualifier, which lead to an error message.
Hence rename the file accordingly, to avoid the warning
about file name not matching module name.
tests/invalid/Mmakefile:
tests/invalid/missing_interface_import.m:
tests/invalid/missing_interface_import.err_exp:
Regression test to check that the compiler reports
errors for missing `import_module' in the interface section.
tests/invalid/*.err_exp:
tests/warnings/unused_args_test.exp:
tests/warnings/unused_import.exp:
Update the expected diagnostics output for the test cases to
reflect a few minor changes to the warning messages.
tests/hard_coded/Mmakefile:
tests/hard_coded/parent.m:
tests/hard_coded/parent.child.m:
tests/hard_coded/parent.exp:
tests/hard_coded/parent2.m:
tests/hard_coded/parent2.child.m:
tests/hard_coded/parent2.exp:
Two simple tests case for the use of nested modules with
separate compilation.
421 lines
14 KiB
Mathematica
421 lines
14 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 1994-1998 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU Library General
|
|
% Public License - see the file COPYING.LIB in the Mercury distribution.
|
|
%------------------------------------------------------------------------------%
|
|
%
|
|
% File: graph.m.
|
|
% Main author: conway.
|
|
% Stability: low.
|
|
%
|
|
% This module defines a directed graph data type. The type graph(N, A)
|
|
% stores information of type N in the nodes, and information of type A
|
|
% in the arcs.
|
|
%
|
|
%------------------------------------------------------------------------------%
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- module graph.
|
|
|
|
:- interface.
|
|
:- import_module list, set, std_util.
|
|
|
|
% graph(Node, Arc) represents a directed graph with information of
|
|
% type Node associated with each node, and information of type Arc
|
|
% associated with each arc.
|
|
:- type graph(N, A).
|
|
|
|
:- type node(N).
|
|
|
|
:- type arc(A).
|
|
|
|
% Lots of graphs don't need to store anything in the arcs so here's
|
|
% a type equivalence that only has `real' information in the nodes.
|
|
:- type graph(N) == graph(N, unit).
|
|
|
|
:- type arc == arc(unit).
|
|
|
|
% graph__init(Graph) binds Graph to an empty graph
|
|
% containing no nodes and no arcs. (The graph contains
|
|
% a counter of the number of nodes allocated in it, so
|
|
% it is possible for a graph to contain no nodes or arcs
|
|
% and still fail to unify with the binding of Graph from
|
|
% graph__init.)
|
|
:- pred graph__init(graph(N, A)).
|
|
:- mode graph__init(out) is det.
|
|
|
|
% graph__set_node(OldGraph, NodeInfo, Node, NewGraph) takes
|
|
% OldGraph and NodeInfo which is the information to be stored
|
|
% in a new node, and returns a key "Node" which refers to that
|
|
% node, and the new graph NewGraph containing all of the nodes
|
|
% and arcs in OldGraph as well as the new node.
|
|
% It is possible to have two nodes in the graph with the
|
|
% same information stored in them.
|
|
%
|
|
% This operation is O(lgN) for a graph containing N nodes.
|
|
:- pred graph__set_node(graph(N, A), N, node(N), graph(N, A)).
|
|
:- mode graph__set_node(in, in, out, out) is det.
|
|
|
|
% graph__insert_node/4 is the same as graph__set_node/4 except
|
|
% that if the information to be stored in the node is stored
|
|
% in another node, then the graph__insert_node/4 fails.
|
|
%
|
|
% This operation is O(N) for a graph containing N nodes since
|
|
% this predicate has to check that the node data isn't in an
|
|
% existing node.
|
|
:- pred graph__insert_node(graph(N, A), N, node(N), graph(N, A)).
|
|
:- mode graph__insert_node(in, in, out, out) is semidet.
|
|
|
|
% graph__det_insert_node/4 is like graph__insert_node, except
|
|
% that if the insertion would fail, it calls error/1.
|
|
:- pred graph__det_insert_node(graph(N, A), N, node(N), graph(N, A)).
|
|
:- mode graph__det_insert_node(in, in, out, out) is det.
|
|
|
|
% graph__search_node(Graph, NodeInfo, Node) nondeterministically
|
|
% produces bindings of Node such that Node is a node in Graph
|
|
% that has the information NodeInfo attatched to it.
|
|
%
|
|
% This operation is O(lgN) for the first solution for a graph
|
|
% containing N nodes.
|
|
:- pred graph__search_node(graph(N, A), N, node(N)).
|
|
:- mode graph__search_node(in, in, out) is nondet.
|
|
|
|
% graph__find_matching_nodes(Graph, NodeInfo, Nodes) takes a graph
|
|
% Graph and the information NodeInfo and returns the set of nodes
|
|
% Nodes which have the information NodeInfo stored in them. (The set
|
|
% Nodes will of course be empty if there are no matching nodes.)
|
|
%
|
|
% This operation is O(NlgN) for a graph containing N nodes.
|
|
:- pred graph__find_matching_nodes(graph(N, A), N, set(node(N))).
|
|
:- mode graph__find_matching_nodes(in, in, out) is det.
|
|
|
|
% graph__node_contents(Graph, Node, NodeInfo) takes Graph and
|
|
% Node and returns the information NodeInfo stored in Node.
|
|
%
|
|
% This operation is O(lgN) for a graph containing N nodes.
|
|
:- pred graph__node_contents(graph(N, A), node(N), N).
|
|
:- mode graph__node_contents(in, in, out) is det.
|
|
|
|
% graph__successors(Graph, Node, Nodes) takes a graph Graph and
|
|
% a node Node and returns the set of nodes Nodes that are reachable
|
|
% (directly - not transitively) from Node.
|
|
%
|
|
% This operation is O(NlgN) for a graph containing N nodes.
|
|
:- pred graph__successors(graph(N, A), node(N), set(node(N))).
|
|
:- mode graph__successors(in, in, out) is det.
|
|
|
|
% graph__nodes(Graph, Nodes) binds Nodes to the set of nodes in Graph.
|
|
:- pred graph__nodes(graph(N, A), set(node(N))).
|
|
:- mode graph__nodes(in, out) is det.
|
|
|
|
% graph__set_edge(OldGraph, Start, End, ArcInfo, Arc, NewGraph)
|
|
% takes a graph OldGraph and adds an arc from Start to End with
|
|
% the information ArcInfo stored in it, and returns a key for
|
|
% that arc Arc, and the new graph NewGraph.
|
|
% If an identical arc already exists then this operation has
|
|
% no effect.
|
|
%
|
|
% This operation is O(lgN+lgM) for a graph with N nodes and M arcs.
|
|
:- pred graph__set_edge(graph(N, A), node(N), node(N), A,
|
|
arc(A), graph(N, A)).
|
|
:- mode graph__set_edge(in, in, in, in, out, out) is det.
|
|
|
|
% graph__insert_edge/6 is the same as graph__set_edge/6 except that
|
|
% if an identical arc already exists in the graph the operation fails.
|
|
% This is O(N) for a graph with N edges between the two nodes.
|
|
:- pred graph__insert_edge(graph(N, A), node(N), node(N), A,
|
|
arc(A), graph(N, A)).
|
|
:- mode graph__insert_edge(in, in, in, in, out, out) is semidet.
|
|
|
|
% graph__det_insert_edge/6 is like graph__insert_edge except
|
|
% than instead of failing, it calls error/1.
|
|
:- pred graph__det_insert_edge(graph(N, A), node(N), node(N), A,
|
|
arc(A), graph(N, A)).
|
|
:- mode graph__det_insert_edge(in, in, in, in, out, out) is det.
|
|
|
|
% graph__arc_contents(Graph, Arc, Start, End, ArcInfo) takes a
|
|
% graph Graph and an arc Arc and returns the start and end nodes
|
|
% and the information stored in that arc.
|
|
:- pred graph__arc_contents(graph(N, A), arc(A), node(N), node(N), A).
|
|
:- mode graph__arc_contents(in, in, out, out, out) is det.
|
|
|
|
% graph__path(Graph, Start, End, Path) is true iff there is a path
|
|
% from the node Start to the node End in Graph that goes through
|
|
% the sequence of arcs Arcs.
|
|
% The algorithm will return paths containing at most one cycle.
|
|
:- pred graph__path(graph(N, A), node(N), node(N), list(arc(A))).
|
|
:- mode graph__path(in, in, in, out) is nondet.
|
|
:- mode graph__path(in, in, out, out) is nondet.
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module map, int, std_util, list.
|
|
:- import_module require.
|
|
|
|
:- type graph(N, A) --->
|
|
graph(
|
|
graph__node_supply,
|
|
graph__arc_supply,
|
|
map(node(N), N),
|
|
map(arc(A), arc_info(N, A)),
|
|
map(node(N), map(arc(A), node(N)))
|
|
).
|
|
|
|
:- type graph__node_supply == int.
|
|
|
|
:- type graph__arc_supply == int.
|
|
|
|
:- type node(N) ---> node(int).
|
|
|
|
:- type arc(A) ---> arc(int).
|
|
|
|
:- type arc_info(N, A) ---> arc_info(node(N), node(N), A).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__init(Graph) :-
|
|
Graph = graph(0, 0, Nodes, Arcs, Edges),
|
|
map__init(Nodes),
|
|
map__init(Arcs),
|
|
map__init(Edges).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__set_node(G0, NInfo, node(N), G) :-
|
|
graph__get_node_supply(G0, NS0),
|
|
NS is NS0 + 1,
|
|
N = NS,
|
|
graph__set_node_supply(G0, NS, G1),
|
|
|
|
graph__get_nodes(G1, Nodes0),
|
|
map__set(Nodes0, node(N), NInfo, Nodes),
|
|
graph__set_nodes(G1, Nodes, G2),
|
|
|
|
graph__get_edges(G2, Edges0),
|
|
map__init(EdgeMap),
|
|
map__set(Edges0, node(N), EdgeMap, Edges),
|
|
graph__set_edges(G2, Edges, G).
|
|
|
|
graph__det_insert_node(G0, NInfo, N, G) :-
|
|
(
|
|
graph__insert_node(G0, NInfo, N1, G1)
|
|
->
|
|
N = N1,
|
|
G = G1
|
|
;
|
|
error("graph__det_insert_node: node already exists.")
|
|
).
|
|
|
|
graph__insert_node(G0, NInfo, node(N), G) :-
|
|
% Make sure that the graph doesn't contain
|
|
% NInfo already.
|
|
graph__get_nodes(G0, Nodes0),
|
|
\+ map__member(Nodes0, _, NInfo),
|
|
|
|
graph__get_node_supply(G0, NS0),
|
|
NS is NS0 + 1,
|
|
N = NS,
|
|
graph__set_node_supply(G0, NS, G1),
|
|
|
|
graph__get_nodes(G1, Nodes1),
|
|
map__set(Nodes1, node(N), NInfo, Nodes),
|
|
graph__set_nodes(G1, Nodes, G2),
|
|
|
|
graph__get_edges(G2, Edges0),
|
|
map__init(EdgeSet),
|
|
map__set(Edges0, node(N), EdgeSet, Edges),
|
|
graph__set_edges(G2, Edges, G).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__search_node(Graph, NodeInfo, Node) :-
|
|
graph__get_nodes(Graph, NodeTable),
|
|
map__member(NodeTable, Node, NodeInfo).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__find_matching_nodes(Graph, NodeInfo, NodeSet) :-
|
|
graph__get_nodes(Graph, NodeTable),
|
|
% SolnGoal = lambda([Node::out] is nondet,
|
|
% map__member(NodeTable, Node, NodeInfo)),
|
|
% solutions(SolnGoal, NodeList),
|
|
solutions(graph__select_node(NodeTable, NodeInfo), NodeList),
|
|
set__sorted_list_to_set(NodeList, NodeSet).
|
|
|
|
:- pred graph__select_node(map(node(N), N), N, node(N)).
|
|
:- mode graph__select_node(in, in, out) is nondet.
|
|
|
|
graph__select_node(NodeTable, NodeInfo, Node) :-
|
|
map__member(NodeTable, Node, NodeInfo).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__node_contents(G, N, I) :-
|
|
graph__get_nodes(G, Ns),
|
|
map__lookup(Ns, N, I).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__successors(G, N, Ss) :-
|
|
graph__get_edges(G, Es),
|
|
map__lookup(Es, N, E),
|
|
map__values(E, SsList),
|
|
set__list_to_set(SsList, Ss).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__nodes(G, Ns) :-
|
|
graph__get_nodes(G, Ns0),
|
|
map__keys(Ns0, Ns1),
|
|
set__list_to_set(Ns1, Ns).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__set_edge(G0, Start, End, Info, Arc, G) :-
|
|
graph__get_arc_supply(G0, AS0),
|
|
AS is AS0 + 1,
|
|
Arc = arc(AS),
|
|
graph__set_arc_supply(G0, AS, G1),
|
|
|
|
graph__get_arcs(G1, Arcs0),
|
|
map__set(Arcs0, Arc, arc_info(Start, End, Info), Arcs),
|
|
graph__set_arcs(G1, Arcs, G2),
|
|
|
|
graph__get_edges(G2, Es0),
|
|
map__lookup(Es0, Start, EdgeMap0),
|
|
map__set(EdgeMap0, Arc, End, EdgeMap),
|
|
map__set(Es0, Start, EdgeMap, Es),
|
|
graph__set_edges(G2, Es, G).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__det_insert_edge(G0, Start, End, Info, Arc, G) :-
|
|
(
|
|
graph__insert_edge(G0, Start, End, Info, Arc1, G1)
|
|
->
|
|
Arc = Arc1,
|
|
G = G1
|
|
;
|
|
error("graph__det_insert_edge: this edge is already in the graph.")
|
|
).
|
|
|
|
graph__insert_edge(G0, Start, End, Info, Arc, G) :-
|
|
graph__get_arc_supply(G0, AS0),
|
|
AS is AS0 + 1,
|
|
Arc = arc(AS),
|
|
graph__set_arc_supply(G0, AS, G1),
|
|
|
|
graph__get_arcs(G1, Arcs0),
|
|
map__insert(Arcs0, Arc, arc_info(Start, End, Info), Arcs),
|
|
graph__set_arcs(G1, Arcs, G2),
|
|
|
|
graph__get_edges(G2, Es0),
|
|
map__lookup(Es0, Start, EdgeMap0),
|
|
map__set(EdgeMap0, Arc, End, EdgeMap),
|
|
map__set(Es0, Start, EdgeMap, Es),
|
|
graph__set_edges(G2, Es, G).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__arc_contents(G, N, S, E, A) :-
|
|
graph__get_arcs(G, Ns),
|
|
map__lookup(Ns, N, I),
|
|
I = arc_info(S, E, A).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
graph__path(G, S, E, Path) :-
|
|
graph__path_2(G, S, E, [], Path).
|
|
|
|
:- pred graph__path_2(graph(N, A), node(N), node(N),
|
|
list(node(N)), list(arc(A))).
|
|
:- mode graph__path_2(in, in, in, in, out) is nondet.
|
|
:- mode graph__path_2(in, in, out, in, out) is nondet.
|
|
|
|
graph__path_2(G, S, E, Nodes0, Path) :-
|
|
graph__get_edges(G, Es),
|
|
map__lookup(Es, S, Arcs),
|
|
(
|
|
map__member(Arcs, A, E),
|
|
\+ list__member(E, Nodes0),
|
|
Path = [A]
|
|
;
|
|
map__member(Arcs, A, N),
|
|
\+ list__member(N, Nodes0),
|
|
graph__path_2(G, N, E, [N|Nodes0], Path0),
|
|
Path = [A|Path0]
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred graph__get_node_supply(graph(N, A), graph__node_supply).
|
|
:- mode graph__get_node_supply(in, out) is det.
|
|
|
|
graph__get_node_supply(G, NS) :-
|
|
G = graph(NS, _AS, _N, _A, _E).
|
|
|
|
:- pred graph__get_arc_supply(graph(N, A), graph__arc_supply).
|
|
:- mode graph__get_arc_supply(in, out) is det.
|
|
|
|
graph__get_arc_supply(G, AS) :-
|
|
G = graph(_NS, AS, _N, _A, _E).
|
|
|
|
:- pred graph__get_nodes(graph(N, A), map(node(N), N)).
|
|
:- mode graph__get_nodes(in, out) is det.
|
|
|
|
graph__get_nodes(G, N) :-
|
|
G = graph(_NS, _AS, N, _A, _E).
|
|
|
|
:- pred graph__get_arcs(graph(N, A), map(arc(A), arc_info(N, A))).
|
|
:- mode graph__get_arcs(in, out) is det.
|
|
|
|
graph__get_arcs(G, A) :-
|
|
G = graph(_NS, _AS, _N, A, _E).
|
|
|
|
:- pred graph__get_edges(graph(N, A), map(node(N), map(arc(A), node(N)))).
|
|
:- mode graph__get_edges(in, out) is det.
|
|
|
|
graph__get_edges(G, E) :-
|
|
G = graph(_NS, _AS, _N, _A, E).
|
|
|
|
:- pred graph__set_node_supply(graph(N, A), graph__node_supply, graph(N, A)).
|
|
:- mode graph__set_node_supply(in, in, out) is det.
|
|
|
|
graph__set_node_supply(G0, NS, G) :-
|
|
G0 = graph(_, AS, N, A, E),
|
|
G = graph(NS, AS, N, A, E).
|
|
|
|
:- pred graph__set_arc_supply(graph(N, A), graph__arc_supply, graph(N, A)).
|
|
:- mode graph__set_arc_supply(in, in, out) is det.
|
|
|
|
graph__set_arc_supply(G0, AS, G) :-
|
|
G0 = graph(NS, _, N, A, E),
|
|
G = graph(NS, AS, N, A, E).
|
|
|
|
:- pred graph__set_nodes(graph(N, A), map(node(N), N), graph(N, A)).
|
|
:- mode graph__set_nodes(in, in, out) is det.
|
|
|
|
graph__set_nodes(G0, N, G) :-
|
|
G0 = graph(NS, AS, _, A, E),
|
|
G = graph(NS, AS, N, A, E).
|
|
|
|
:- pred graph__set_arcs(graph(N, A), map(arc(A), arc_info(N, A)), graph(N, A)).
|
|
:- mode graph__set_arcs(in, in, out) is det.
|
|
|
|
graph__set_arcs(G0, A, G) :-
|
|
G0 = graph(NS, AS, N, _, E),
|
|
G = graph(NS, AS, N, A, E).
|
|
|
|
:- pred graph__set_edges(graph(N, A), map(node(N), map(arc(A), node(N))), graph(N, A)).
|
|
:- mode graph__set_edges(in, in, out) is det.
|
|
|
|
graph__set_edges(G0, E, G) :-
|
|
G0 = graph(NS, AS, N, A, _),
|
|
G = graph(NS, AS, N, A, E).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
%------------------------------------------------------------------------------%
|