mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-24 05:43:53 +00:00
eae3174a2c
Estimated hours taken: 30 (including debugging) Add MR_TYPECTOR_REP_* to the type_ctor_info to describe the representation of this type. We want to do this because it allows us to check quickly to see what kind of data representation is being used. Previously this information was spread throughout the type_ctor_layout and type_ctor_functors data structures. It was complex to interpret and contained a lot of unnecessary duplication. We can now omit data structures such as the type_ctor_layout in many cases (it is only necessary for discriminated unions). Because we rule out some of the possible alternatives, the encodings used in the type_ctor_layout can be simplified. Also, the functors indicator in type_ctor_functors can be removed, as it subsumed by this data structure. Use this representation in code that uses RTTI. compiler/base_type_info.m: Add a missing alternative to the type_ctor_rep (this was a bug). library/array.m: library/builtin.m: library/private_builtin.m: runtime/mercury_bootstrap.c: Use MR_TYPECTOR_REP_* in the type_ctor_infos for builtin types. library/std_util.m: runtime/mercury_deep_copy_body.h: runtime/mercury_tabling.c: Use MR_TYPECTOR_REP_* and MR_DISCUNION_TAG_* to dispatch on data representations. Also, fix a bug in deep_copy when copying floating point values. I'm not sure when this stopped working, or if this is exactly the right fix, but it is more correct than the previous code. runtime/mercury_type_info.c: runtime/mercury_type_info.h: Update code to use MR_TYPECTOR_REP_*. Use a struct for type_ctor_info. tests/hard_coded/Mmakefile: tests/hard_coded/deep_copy.m: tests/hard_coded/deep_copy.exp: Add a test case for deep_copy.
152 lines
3.4 KiB
Mathematica
152 lines
3.4 KiB
Mathematica
% Test case for deep_copy
|
|
%
|
|
% Author: trd
|
|
|
|
:- module deep_copy.
|
|
:- interface.
|
|
:- import_module io.
|
|
|
|
:- pred main(io__state::di, io__state::uo) is det.
|
|
|
|
:- implementation.
|
|
|
|
:- import_module list, int, std_util, term, map, string, require.
|
|
|
|
:- pred test_builtins(io__state::di, io__state::uo) is det.
|
|
:- pred test_discriminated(io__state::di, io__state::uo) is det.
|
|
:- pred test_polymorphism(io__state::di, io__state::uo) is det.
|
|
:- pred test_other(io__state::di, io__state::uo) is det.
|
|
|
|
:- pred newline(io__state::di, io__state::uo) is det.
|
|
|
|
:- pred test_all(T::in, io__state::di, io__state::uo) is det.
|
|
|
|
:- type enum ---> one ; two ; three.
|
|
|
|
:- type fruit ---> apple(list(int))
|
|
; banana(list(enum)).
|
|
|
|
:- type thingie ---> foo ; bar(int) ; bar(int, int) ; qux(int) ;
|
|
quux(int) ; quuux(int, int) ; wombat ;
|
|
zoom(int) ; zap(int, float) ; zip(int, int) ;
|
|
zop(float, float).
|
|
|
|
:- type poly(A, B) ---> poly_one(A) ; poly_two(B) ;
|
|
poly_three(B, A, poly(B, A));
|
|
poly_four(A, B).
|
|
|
|
:- type no_tag ---> qwerty(int).
|
|
|
|
%----------------------------------------------------------------------------%
|
|
|
|
main -->
|
|
test_discriminated,
|
|
test_polymorphism,
|
|
test_builtins,
|
|
test_other.
|
|
|
|
%----------------------------------------------------------------------------%
|
|
|
|
test_all(T) -->
|
|
io__write(T),
|
|
io__write_string("\n"),
|
|
{ copy(T, T1) },
|
|
io__write(T),
|
|
io__write_string("\n"),
|
|
io__write(T1).
|
|
|
|
%----------------------------------------------------------------------------%
|
|
|
|
test_discriminated -->
|
|
io__write_string("TESTING DISCRIMINATED UNIONS\n"),
|
|
|
|
% test enumerations
|
|
test_all(two), newline,
|
|
test_all(one), newline,
|
|
test_all(three), newline,
|
|
|
|
% test simple tags
|
|
test_all(apple([9,5,1])), newline,
|
|
test_all(banana([three, one, two])), newline,
|
|
|
|
|
|
% test complicated tags
|
|
test_all(zop(3.3, 2.03)), newline,
|
|
test_all(zip(3, 2)), newline,
|
|
test_all(zap(3, -2.111)), newline,
|
|
|
|
% test complicated constant
|
|
|
|
test_all(wombat), newline,
|
|
test_all(foo), newline,
|
|
|
|
newline.
|
|
|
|
test_polymorphism -->
|
|
io__write_string("TESTING POLYMORPHISM\n"),
|
|
test_all(poly_three(3.33, 4, poly_one(9.11))), newline,
|
|
test_all(poly_two(3)), newline,
|
|
test_all(poly_one([2399.3])), newline,
|
|
|
|
newline.
|
|
|
|
|
|
test_builtins -->
|
|
io__write_string("TESTING BUILTINS\n"),
|
|
|
|
% test strings
|
|
test_all(""), newline,
|
|
test_all("Hello, world\n"), newline,
|
|
test_all("Foo%sFoo"), newline,
|
|
test_all(""""), newline,
|
|
|
|
% test characters
|
|
test_all('a'), newline,
|
|
test_all('&'), newline,
|
|
|
|
% test floats
|
|
test_all(3.14159), newline,
|
|
test_all(11.28324983E-22), newline,
|
|
test_all(22.3954899E22), newline,
|
|
|
|
% test integers
|
|
test_all(-65), newline,
|
|
test_all(4), newline,
|
|
|
|
% test univ.
|
|
{ type_to_univ(["hi! I'm a univ!"], Univ) },
|
|
test_all(Univ), newline,
|
|
|
|
% test predicates
|
|
% XXX we don't deep copy predicates correctly yet
|
|
%test_all(newline), newline,
|
|
|
|
newline.
|
|
|
|
% Note: testing abstract types is always going to have results
|
|
% that are dependent on the implementation. If someone changes
|
|
% the implementation, the results of this test can change.
|
|
|
|
test_other -->
|
|
io__write_string("TESTING OTHER TYPES\n"),
|
|
{ term__init_var_supply(VarSupply) },
|
|
{ term__create_var(VarSupply, Var, NewVarSupply) },
|
|
test_all(Var), newline,
|
|
test_all(VarSupply), newline,
|
|
test_all(NewVarSupply), newline,
|
|
|
|
% presently, at least, map is an equivalence and
|
|
% an abstract type.
|
|
{ map__init(Map) },
|
|
test_all(Map), newline,
|
|
|
|
% a no tag type
|
|
test_all(qwerty(4)), newline,
|
|
|
|
newline.
|
|
|
|
newline -->
|
|
io__write_char('\n').
|
|
|
|
|