mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-17 23:05:21 +00:00
459847a064
Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.
130 lines
4.6 KiB
Mathematica
130 lines
4.6 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 2005-2006 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.
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% This module computes diffs between terms.
|
|
|
|
:- module mdb.diff.
|
|
:- interface.
|
|
|
|
:- import_module int.
|
|
:- import_module io.
|
|
:- import_module univ.
|
|
|
|
:- pred report_diffs(int::in, int::in, univ::in, univ::in, io::di, io::uo)
|
|
is cc_multi.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module mdbcomp.program_representation.
|
|
|
|
:- import_module deconstruct.
|
|
:- import_module list.
|
|
:- import_module require.
|
|
:- import_module string.
|
|
:- import_module type_desc.
|
|
|
|
:- pragma export(report_diffs(in, in, in, in, di, uo), "ML_report_diffs").
|
|
|
|
report_diffs(Drop, Max, Univ1, Univ2, !IO) :-
|
|
(
|
|
Type1 = univ_type(Univ1),
|
|
Type2 = univ_type(Univ2),
|
|
Type1 = Type2
|
|
->
|
|
compute_diffs(Univ1, Univ2, [], [], RevDiffs),
|
|
list.reverse(RevDiffs, AllDiffs),
|
|
list.length(AllDiffs, NumAllDiffs),
|
|
(
|
|
list.drop(Drop, AllDiffs, Diffs),
|
|
Diffs = [_ | _]
|
|
->
|
|
FirstShown = Drop + 1,
|
|
LastShown = min(Drop + Max, NumAllDiffs),
|
|
( FirstShown = LastShown ->
|
|
io.format("There are %d diffs, showing diff %d:\n",
|
|
[i(NumAllDiffs), i(FirstShown)], !IO)
|
|
;
|
|
io.format("There are %d diffs, showing diffs %d-%d:\n",
|
|
[i(NumAllDiffs), i(FirstShown), i(LastShown)], !IO)
|
|
),
|
|
list.take_upto(Max, Diffs, ShowDiffs),
|
|
list.foldl2(show_diff, ShowDiffs, Drop, _, !IO)
|
|
;
|
|
( NumAllDiffs = 0 ->
|
|
io.write_string("There are no diffs.\n", !IO)
|
|
; NumAllDiffs = 1 ->
|
|
io.write_string("There is only one diff.\n", !IO)
|
|
;
|
|
io.format("There are only %d diffs.\n", [i(NumAllDiffs)], !IO)
|
|
)
|
|
)
|
|
;
|
|
io.write_string("The two values are of different types.\n", !IO)
|
|
).
|
|
|
|
:- type term_path_diff
|
|
---> term_path_diff(term_path, univ, univ).
|
|
|
|
:- pred compute_diffs(univ::in, univ::in, term_path::in,
|
|
list(term_path_diff)::in, list(term_path_diff)::out) is cc_multi.
|
|
|
|
compute_diffs(Univ1, Univ2, !.RevPath, !RevDiffs) :-
|
|
deconstruct(univ_value(Univ1), include_details_cc, Functor1, _, Args1),
|
|
deconstruct(univ_value(Univ2), include_details_cc, Functor2, _, Args2),
|
|
( Functor1 = Functor2 ->
|
|
compute_arg_diffs(Args1, Args2, !.RevPath, 1, !RevDiffs)
|
|
;
|
|
list.reverse(!.RevPath, Path),
|
|
!:RevDiffs = [term_path_diff(Path, Univ1, Univ2) | !.RevDiffs]
|
|
).
|
|
|
|
:- pred compute_arg_diffs(list(univ)::in, list(univ)::in, term_path::in,
|
|
int::in, list(term_path_diff)::in, list(term_path_diff)::out) is cc_multi.
|
|
|
|
compute_arg_diffs([], [], _, _, !RevDiffs).
|
|
compute_arg_diffs([], [_ | _], _, _, !RevDiffs) :-
|
|
error("compute_arg_diffs: argument list mismatch").
|
|
compute_arg_diffs([_ | _], [], _, _, !RevDiffs) :-
|
|
error("compute_arg_diffs: argument list mismatch").
|
|
compute_arg_diffs([Arg1 | Args1], [Arg2 | Args2], !.RevPath, ArgNum,
|
|
!RevDiffs) :-
|
|
compute_diffs(Arg1, Arg2, [ArgNum | !.RevPath], !RevDiffs),
|
|
compute_arg_diffs(Args1, Args2, !.RevPath, ArgNum + 1, !RevDiffs).
|
|
|
|
:- pred show_diff(term_path_diff::in, int::in, int::out, io::di, io::uo)
|
|
is cc_multi.
|
|
|
|
show_diff(Diff, !DiffNum, !IO) :-
|
|
!:DiffNum = !.DiffNum + 1,
|
|
io.format("%d: ", [i(!.DiffNum)], !IO),
|
|
Diff = term_path_diff(Path, Univ1, Univ2),
|
|
(
|
|
Path = [],
|
|
io.write_string("mismatch at root", !IO)
|
|
;
|
|
Path = [Posn | Posns],
|
|
io.write_int(Posn, !IO),
|
|
show_path_rest(Posns, !IO)
|
|
),
|
|
io.write_string(": ", !IO),
|
|
functor(univ_value(Univ1), include_details_cc, Functor1, Arity1),
|
|
functor(univ_value(Univ2), include_details_cc, Functor2, Arity2),
|
|
io.format("%s/%d vs %s/%d\n",
|
|
[s(Functor1), i(Arity1), s(Functor2), i(Arity2)], !IO).
|
|
|
|
:- pred show_path_rest(list(int)::in, io::di, io::uo) is det.
|
|
|
|
show_path_rest([], !IO).
|
|
show_path_rest([Posn | Posns], !IO) :-
|
|
io.write_string("/", !IO),
|
|
io.write_int(Posn, !IO),
|
|
show_path_rest(Posns, !IO).
|