mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-15 13:55:07 +00:00
Code Issues Projects Releases Wiki Activity
Files
b3af56e8faaa0957accac177afa6ab5de9c91f63
mercury/compiler/vn_debug.m
Fergus Henderson 11d8161692 Add support for nested modules. 
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.
1998-03-03 17:48:14 +00:00

582 lines
17 KiB
Mathematica
Raw Blame History

%-----------------------------------------------------------------------------%
% Copyright (C) 1995-1998 The University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%-----------------------------------------------------------------------------%
% vn_debug.m - debugging messages for vn_order and vn_flush.
% Author: zs.
%-----------------------------------------------------------------------------%
:- module vn_debug.
:- interface.
:- import_module atsort, vn_type, vn_table, llds, livemap.
:- import_module assoc_list, bool, list, std_util, io.
:- pred vn_debug__tuple_msg(maybe(bool), list(instruction), vn_ctrl_tuple,
io__state, io__state).
:- mode vn_debug__tuple_msg(in, in, in, di, uo) is det.
:- pred vn_debug__livemap_msg(livemap, io__state, io__state).
:- mode vn_debug__livemap_msg(in, di, uo) is det.
:- pred vn_debug__fragment_msg(instr, io__state, io__state).
:- mode vn_debug__fragment_msg(in, di, uo) is det.
:- pred vn_debug__failure_msg(instr, string, io__state, io__state).
:- mode vn_debug__failure_msg(in, in, di, uo) is det.
:- pred vn_debug__parallel_msgs(list(parallel), io__state, io__state).
:- mode vn_debug__parallel_msgs(in, di, uo) is det.
:- pred vn_debug__parallel_msg(parallel, io__state, io__state).
:- mode vn_debug__parallel_msg(in, di, uo) is det.
:- pred vn_debug__computed_goto_msg(list(label), list(parallel),
assoc_list(label, maybe(parallel)), io__state, io__state).
:- mode vn_debug__computed_goto_msg(in, in, in, di, uo) is det.
:- pred vn_debug__order_start_msg(ctrlmap, flushmap, vn_tables,
io__state, io__state).
:- mode vn_debug__order_start_msg(in, in, in, di, uo) is det.
:- pred vn_debug__order_sink_msg(vn_node, io__state, io__state).
:- mode vn_debug__order_sink_msg(in, di, uo) is det.
:- pred vn_debug__order_link_msg(vn_node, vn_node, bool, io__state, io__state).
:- mode vn_debug__order_link_msg(in, in, in, di, uo) is det.
:- pred vn_debug__order_antidep_msg(vn_node, vn_node, io__state, io__state).
:- mode vn_debug__order_antidep_msg(in, in, di, uo) is det.
:- pred vn_debug__order_map_msg(relmap(vn_node), relmap(vn_node),
relmap(vn_node), relmap(vn_node), io__state, io__state).
:- mode vn_debug__order_map_msg(in, in, in, in, di, uo) is det.
:- pred vn_debug__order_order_msg(list(vn_node), io__state, io__state).
:- mode vn_debug__order_order_msg(in, di, uo) is det.
:- pred vn_debug__order_equals_msg(string, list(vn_node), io__state, io__state).
:- mode vn_debug__order_equals_msg(in, in, di, uo) is det.
:- pred vn_debug__cost_header_msg(string, io__state, io__state).
:- mode vn_debug__cost_header_msg(in, di, uo) is det.
:- pred vn_debug__cost_msg(bool, int, int, io__state, io__state).
:- mode vn_debug__cost_msg(in, in, in, di, uo) is det.
:- pred vn_debug__cost_detail_msg(instr, int, int, io__state, io__state).
:- mode vn_debug__cost_detail_msg(in, in, in, di, uo) is det.
:- pred vn_debug__restart_msg(instruction, io__state, io__state).
:- mode vn_debug__restart_msg(in, di, uo) is det.
:- pred vn_debug__divide_msg(instruction, io__state, io__state).
:- mode vn_debug__divide_msg(in, di, uo) is det.
:- pred vn_debug__flush_start_msg(vn_node, io__state, io__state).
:- mode vn_debug__flush_start_msg(in, di, uo) is det.
:- pred vn_debug__flush_also_msg(vnlval, io__state, io__state).
:- mode vn_debug__flush_also_msg(in, di, uo) is det.
:- pred vn_debug__flush_end_msg(list(instruction), vn_tables,
io__state, io__state).
:- mode vn_debug__flush_end_msg(in, in, di, uo) is det.
:- pred vn_debug__dump_instrs(list(instruction), io__state, io__state).
:- mode vn_debug__dump_instrs(in, di, uo) is det.
%-----------------------------------------------------------------------------%
:- implementation.
:- import_module llds_out, globals, options, opt_debug.
:- import_module string, int, map.
vn_debug__tuple_msg(Intermediate, Instrs, Tuple) -->
vn_debug__tuple_msg_flag(Flag),
(
{ Flag = yes },
io__write_string("\nTuples from the "),
(
{ Intermediate = no },
io__write_string("final instruction sequence:\n\n")
;
{ Intermediate = yes(Stitched) },
(
{ Stitched = no },
io__write_string("intermediate instruction sequence:\n\n")
;
{ Stitched = yes },
io__write_string("stitched-together instruction sequence:\n\n")
)
),
vn_debug__dump_instrs(Instrs),
io__write_string("\nTuple data:\n\n"),
{ Tuple = tuple(N, CtrlMap, _, _, ParMap) },
vn_debug__tuple_entries(0, N, CtrlMap, ParMap),
io__write_string("\nTuple data ends\n\n")
;
{ Flag = no }
).
:- pred vn_debug__tuple_entries(int, int, ctrlmap, parmap,
io__state, io__state).
:- mode vn_debug__tuple_entries(in, in, in, in, di, uo) is det.
vn_debug__tuple_entries(N, Max, CtrlMap, ParMap) -->
( { N < Max } ->
{ map__lookup(CtrlMap, N, VnInstr) },
{ map__lookup(ParMap, N, Parallels) },
{ opt_debug__dump_vninstr(VnInstr, I_str) },
io__write_string("\n-----------\n"),
io__write_string(I_str),
io__write_string(":\n"),
vn_debug__parallel_msgs(Parallels),
{ N1 is N + 1 },
vn_debug__tuple_entries(N1, Max, CtrlMap, ParMap)
;
[]
).
vn_debug__livemap_msg(Livemap) -->
vn_debug__livemap_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_livemap(Livemap, L_str) },
io__write_string("\n\nLivemap:\n\n"),
io__write_string(L_str)
;
{ Flag = no }
).
vn_debug__fragment_msg(Instr) -->
vn_debug__start_msg_flag(Flag),
(
{ Flag = yes },
io__write_string("\nin value_number__optimize_fragment starting at\n"),
output_instruction(Instr),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__restart_msg(Instr) -->
vn_debug__start_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_fullinstr(Instr, I_str) },
io__write_string("starting again at "),
io__write_string(I_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__divide_msg(Instr) -->
vn_debug__start_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_fullinstr(Instr, I_str) },
io__write_string("dividing the block at "),
io__write_string(I_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__failure_msg(Instr, Cause) -->
vn_debug__failure_msg_flag(Flag),
(
{ Flag = yes },
io__write_string("FAILURE of VN consistency check "),
io__write_string("in fragment starting at\n"),
output_instruction(Instr),
io__write_string("\n"),
io__write_string("Cause: "),
io__write_string(Cause),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__parallel_msgs([]) --> [].
vn_debug__parallel_msgs([Parallel | Parallels]) -->
vn_debug__parallel_msg(Parallel),
vn_debug__parallel_msgs(Parallels).
vn_debug__parallel_msg(parallel(OldLabel, NewLabel, ParEntries)) -->
vn_debug__parallel_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_label(OldLabel, O_str) },
{ opt_debug__dump_label(NewLabel, N_str) },
io__write_string("\nparallel from "),
io__write_string(O_str),
io__write_string(" to "),
io__write_string(N_str),
io__write_string("\n"),
vn_debug__parentry_msg(ParEntries)
;
{ Flag = no }
).
:- pred vn_debug__parentry_msg(list(parentry), io__state, io__state).
:- mode vn_debug__parentry_msg(in, di, uo) is det.
vn_debug__parentry_msg([]) --> [].
vn_debug__parentry_msg([Lval - Rvals | ParEntries]) -->
{ opt_debug__dump_lval(Lval, L_str) },
{ opt_debug__dump_rvals(Rvals, R_str) },
io__write_string(L_str),
io__write_string(" -> "),
io__write_string(R_str),
io__write_string("\n"),
vn_debug__parentry_msg(ParEntries).
vn_debug__computed_goto_msg(Labels, Parallels, Pairs) -->
vn_debug__parallel_msg_flag(Flag),
(
{ Flag = yes },
io__write_string("computed goto labels:\n"),
vn_debug__dump_labels(Labels),
io__write_string("computed goto parallels:\n"),
vn_debug__dump_parallels(Parallels),
io__write_string("computed goto pairs:\n"),
vn_debug__dump_label_parallel_pairs(Pairs),
io__write_string("computed goto message end\n")
;
{ Flag = no }
).
:- pred vn_debug__dump_labels(list(label), io__state, io__state).
:- mode vn_debug__dump_labels(in, di, uo) is det.
vn_debug__dump_labels([]) --> [].
vn_debug__dump_labels([Label | Labels]) -->
{ opt_debug__dump_label(Label, Lstr) },
io__write_string(Lstr),
io__write_string("\n"),
vn_debug__dump_labels(Labels).
:- pred vn_debug__dump_parallels(list(parallel), io__state, io__state).
:- mode vn_debug__dump_parallels(in, di, uo) is det.
vn_debug__dump_parallels([]) --> [].
vn_debug__dump_parallels([Parallel | Parallels]) -->
vn_debug__parallel_msg(Parallel),
vn_debug__dump_parallels(Parallels).
:- pred vn_debug__dump_label_parallel_pairs(assoc_list(label, maybe(parallel)),
io__state, io__state).
:- mode vn_debug__dump_label_parallel_pairs(in, di, uo) is det.
vn_debug__dump_label_parallel_pairs([]) --> [].
vn_debug__dump_label_parallel_pairs([Label - MaybeParallel | Pairs]) -->
{ opt_debug__dump_label(Label, Lstr) },
io__write_string(Lstr),
io__write_string(": "),
(
{ MaybeParallel = yes(Parallel) },
vn_debug__parallel_msg(Parallel)
;
{ MaybeParallel = no },
io__write_string("no\n")
),
vn_debug__dump_label_parallel_pairs(Pairs).
vn_debug__order_start_msg(Ctrlmap, Flushmap, VnTables) -->
vn_debug__order_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_ctrlmap(Ctrlmap, Ctrl_str) },
{ opt_debug__dump_flushmap(Flushmap, Flush_str) },
{ opt_debug__dump_tables(VnTables, Tables_str) },
io__write_string("\n\n"),
io__write_string(Ctrl_str),
io__write_string(Flush_str),
io__write_string(Tables_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__order_sink_msg(Sink) -->
vn_debug__order_sink_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_node(Sink, S_str) },
io__write_string("sink_before_redef for node "),
io__write_string(S_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__order_link_msg(From, To, User) -->
vn_debug__order_sink_msg_flag(Flag),
(
{ Flag = yes },
(
{ User = yes },
io__write_string("adding user link from ")
;
{ User = no },
io__write_string("adding alias link from ")
),
{ opt_debug__dump_node(From, F_str) },
{ opt_debug__dump_node(To, T_str) },
io__write_string(F_str),
io__write_string(" to "),
io__write_string(T_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__order_antidep_msg(CtrlNode, Node) -->
vn_debug__order_sink_msg_flag(Flag),
(
{ Flag = yes },
io__write_string("anti dependency from "),
{ opt_debug__dump_node(CtrlNode, C_str) },
io__write_string(C_str),
io__write_string(" to "),
{ opt_debug__dump_node(Node, N_str) },
io__write_string(N_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__order_map_msg(MustSuccmap, MustPredmap, Succmap, Predmap) -->
vn_debug__order_map_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_node_relmap(MustSuccmap, MS_str) },
{ opt_debug__dump_node_relmap(MustPredmap, MP_str) },
{ opt_debug__dump_node_relmap(Succmap, S_str) },
{ opt_debug__dump_node_relmap(Predmap, P_str) },
io__write_string("\nMustSuccmap:\n"),
io__write_string(MS_str),
io__write_string("\nMustPredmap:\n"),
io__write_string(MP_str),
io__write_string("\nSuccmap:\n"),
io__write_string(S_str),
io__write_string("\nPredmap:\n"),
io__write_string(P_str)
;
{ Flag = no }
).
vn_debug__order_order_msg(Order) -->
vn_debug__order_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_longnodelist(Order, O_str) },
io__write_string("\nOrder:\n"),
io__write_string(O_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__order_equals_msg(Msg, Order) -->
vn_debug__order_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_nodelist(Order, O_str) },
io__write_string(Msg),
io__write_string(O_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__cost_header_msg(Header) -->
vn_debug__cost_msg_flag(Flag),
opt_debug__msg(Flag, Header).
vn_debug__cost_msg(Used, OrigCost, VnCost) -->
vn_debug__cost_msg_flag(Flag),
(
{ Flag = yes },
{ string__int_to_string(OrigCost, OC_str) },
{ string__int_to_string(VnCost, VC_str) },
io__write_string("\n"),
io__write_string("Old cost: "),
io__write_string(OC_str),
io__write_string("\n"),
io__write_string("New cost: "),
io__write_string(VC_str),
io__write_string("\n"),
( { VnCost < OrigCost } ->
io__write_string("Result: cost improvement\n")
;
io__write_string("Result: no cost improvement\n")
),
( { Used = yes } ->
io__write_string("Used: yes\n")
;
io__write_string("Used: no\n")
)
;
{ Flag = no }
).
vn_debug__cost_detail_msg(Uinstr, InstrCost, CostNow) -->
vn_debug__cost_msg_flag(Flag),
(
{ Flag = yes },
{ string__int_to_string(InstrCost, InstrCostStr) },
{ string__int_to_string(CostNow, CostNowStr) },
io__write_string(InstrCostStr),
io__write_string("\t"),
io__write_string(CostNowStr),
io__write_string("\t"),
output_instruction(Uinstr)
;
{ Flag = no }
).
vn_debug__flush_start_msg(Node) -->
vn_debug__flush_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_node(Node, N_str) },
io__write_string("\nat node "),
io__write_string(N_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__flush_also_msg(Vnlval) -->
vn_debug__flush_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_vnlval(Vnlval, Vn_str) },
io__write_string("took care of node_lval for "),
io__write_string(Vn_str),
io__write_string("\n")
;
{ Flag = no }
).
vn_debug__flush_end_msg(Instrs, VnTables) -->
vn_debug__flush_msg_flag(Flag),
(
{ Flag = yes },
{ opt_debug__dump_fullinstrs(Instrs, I_str) },
{ opt_debug__dump_useful_vns(VnTables, U_str) },
% { opt_debug__dump_useful_locs(VnTables, L_str) },
% { opt_debug__dump_vn_locs(VnTables, V_str) },
io__write_string("generated instrs:\n"),
io__write_string(I_str),
io__write_string("new use info\n"),
io__write_string(U_str)
% io__write_string("new location content info\n"),
% io__write_string(L_str),
% io__write_string("new vn location info\n"),
% io__write_string(V_str)
;
{ Flag = no }
).
vn_debug__dump_instrs(Instrs) -->
vn_debug__parallel_msg_flag(Flag1),
vn_debug__cost_msg_flag(Flag2),
{ bool__or(Flag1, Flag2, Flag) },
opt_debug__dump_instrs(Flag, Instrs).
%-----------------------------------------------------------------------------%
:- pred vn_debug__tuple_msg_flag(bool, io__state, io__state).
:- mode vn_debug__tuple_msg_flag(out, di, uo) is det.
:- pred vn_debug__livemap_msg_flag(bool, io__state, io__state).
:- mode vn_debug__livemap_msg_flag(out, di, uo) is det.
:- pred vn_debug__parallel_msg_flag(bool, io__state, io__state).
:- mode vn_debug__parallel_msg_flag(out, di, uo) is det.
:- pred vn_debug__order_sink_msg_flag(bool, io__state, io__state).
:- mode vn_debug__order_sink_msg_flag(out, di, uo) is det.
:- pred vn_debug__order_msg_flag(bool, io__state, io__state).
:- mode vn_debug__order_msg_flag(out, di, uo) is det.
:- pred vn_debug__order_map_msg_flag(bool, io__state, io__state).
:- mode vn_debug__order_map_msg_flag(out, di, uo) is det.
:- pred vn_debug__cost_msg_flag(bool, io__state, io__state).
:- mode vn_debug__cost_msg_flag(out, di, uo) is det.
:- pred vn_debug__flush_msg_flag(bool, io__state, io__state).
:- mode vn_debug__flush_msg_flag(out, di, uo) is det.
:- pred vn_debug__start_msg_flag(bool, io__state, io__state).
:- mode vn_debug__start_msg_flag(out, di, uo) is det.
:- pred vn_debug__failure_msg_flag(bool, io__state, io__state).
:- mode vn_debug__failure_msg_flag(out, di, uo) is det.
%-----------------------------------------------------------------------------%
vn_debug__tuple_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 512 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__livemap_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 256 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__parallel_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 128 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__order_sink_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 64 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__order_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 32 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__order_map_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 16 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__cost_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 8 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__flush_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 4 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__start_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 2 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
vn_debug__failure_msg_flag(Flag) -->
globals__io_lookup_int_option(debug_vn, DebugVn),
{ Bit is DebugVn /\ 1 },
{ Bit = 0 -> Flag = no ; Flag = yes }.
%-----------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink