mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-24 05:43:53 +00:00
935fbfe36e
Estimated hours taken: 6 Add Mmake support for nested sub-modules. compiler/mercury_compile.m: compiler/modules.m: compiler/intermod.m: Pass down the source file name to various places. Store the source file name in the module_imports data structure. In various places, use this source file name instead of assuming that the source file name can be obtained from the module name. compiler/modules.m: Change the generated .d and .dep files to use the source file names. Add hard-coded rules in the .d files if the source file name does not match the form expected by the pattern rules in scripts/Mmake.rules. XXX unfortunately the rules don't work right for parallel makes of nested modules scripts/Mmake.rules: Add a comment saying that any changes here might need to be duplicated in compiler/modules.m. tests/hard_coded/Mmakefile: tests/hard_coded/nested.m: tests/hard_coded/nested2.m: tests/hard_coded/nested.exp: tests/hard_coded/nested2.exp: Add a couple of test cases for nested modules (XXX not enabled, due to the above-mentioned problem with parallel makes). doc/reference_manual.texi: Update the "implementation bugs and limitations" section. NEWS: Update the news about nested modules.
96 lines
2.3 KiB
Mathematica
96 lines
2.3 KiB
Mathematica
% "Hello World" in Mercury, using nested modules.
|
|
|
|
:- module nested.
|
|
:- interface.
|
|
:- import_module io.
|
|
|
|
:- pred main(io__state::di, io__state::uo) is det.
|
|
|
|
:- implementation.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module nested:child.
|
|
:- interface.
|
|
:- import_module io.
|
|
|
|
:- type foo ---> bar ; baz(int).
|
|
|
|
:- pred hello(io__state::di, io__state::uo) is det.
|
|
|
|
:- implementation.
|
|
|
|
hello --> io__write_string("nested:child:hello\n").
|
|
|
|
:- end_module nested:child.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module nested:child2.
|
|
:- interface.
|
|
:- import_module io.
|
|
|
|
:- type foo ---> bar ; baz(int).
|
|
|
|
:- pred hello(io__state::di, io__state::uo) is det.
|
|
|
|
:- implementation.
|
|
|
|
hello --> io__write_string("nested:child2:hello\n").
|
|
|
|
:- end_module nested:child2.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% now we're back in the parent module.
|
|
|
|
:- import_module nested:child.
|
|
:- use_module nested:child2.
|
|
:- import_module std_util, require.
|
|
|
|
:- type t1 == nested:child:foo.
|
|
:- type t2 == child:foo.
|
|
:- type t3 == foo.
|
|
:- type t4 == nested:child2:foo.
|
|
% :- type t5 == child2:foo. % XXX mixing of use_module and import_module
|
|
% is not yet supported.
|
|
:- type t5 == nested:child2:foo.
|
|
|
|
main -->
|
|
nested:child:hello,
|
|
child:hello,
|
|
hello,
|
|
nested:child2:hello,
|
|
% child2:hello, % XXX mixing of use_module and import_module
|
|
% is not yet supported.
|
|
|
|
print("t1 = "), print(type_of(has_type_t1)), nl,
|
|
print("t2 = "), print(type_of(has_type_t2)), nl,
|
|
print("t3 = "), print(type_of(has_type_t3)), nl,
|
|
print("t4 = "), print(type_of(has_type_t4)), nl,
|
|
print("t5 = "), print(type_of(has_type_t5)), nl,
|
|
|
|
print("has_type_t1 = "), print(has_type_t1), nl,
|
|
print("has_type_t2 = "), print(has_type_t2), nl,
|
|
print("has_type_t3 = "), print(has_type_t3), nl,
|
|
print("has_type_t4 = "), print(has_type_t4), nl,
|
|
print("has_type_t5 = "), print(has_type_t5), nl,
|
|
|
|
{ true }.
|
|
|
|
:- func has_type_t1 = t1.
|
|
:- func has_type_t2 = t2.
|
|
:- func has_type_t3 = t3.
|
|
:- func has_type_t4 = t4.
|
|
:- func has_type_t5 = t5.
|
|
|
|
has_type_t1 = nested:child:bar.
|
|
has_type_t2 = child:bar.
|
|
has_type_t3 = bar.
|
|
has_type_t4 = nested:child2:bar.
|
|
% has_type_t5 = child2:bar. % XXX mixing of use_module and import_module
|
|
% is not yet supported.
|
|
has_type_t5 = nested:child2:bar.
|
|
|
|
:- end_module nested.
|