for review: making error_util more flexible

Zoltan Somogyi zs at cs.mu.OZ.AU
Wed Feb 25 10:51:37 AEDT 1998
Previous message: for review: new library predicate
Next message: for review: making error_util more flexible
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
error_util:
	Instead of requiring the writer of error messages to provide a list
	of words, allow them to provide strings that the code in this module
	will break down into words at white space. (They can still provide
	words not to be proken down.)

term_errors:
	Use the new flexibility in error_util to make the code preparing
	error messages to read a lot better.

Zoltan.

cvs diff: Diffing .
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing bytecode
cvs diff: Diffing bytecode/test
cvs diff: Diffing compiler
Index: compiler/error_util.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/error_util.m,v
retrieving revision 1.3
diff -u -u -r1.3 error_util.m
--- error_util.m	1998/01/23 12:56:28	1.3
+++ error_util.m	1998/02/23 05:47:53
@@ -1,5 +1,5 @@
 %-----------------------------------------------------------------------------%
-% Copyright (C) 1997 The University of Melbourne.
+% Copyright (C) 1997-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.
 %-----------------------------------------------------------------------------%
@@ -16,7 +16,7 @@
 
 :- interface.
 
-:- import_module io, list, term, string, int.
+:- import_module io, list, term.
 
 	% Given a context, a starting indentation level and a list of words,
 	% print an error message that looks like this:
@@ -31,15 +31,33 @@
 	% on the first line and Indent+3 spaces on later lines, and that every
 	% line contains at most 79 characters (unless a long single word
 	% forces the line over this limit).
+	%
+	% The caller supplies the list of words to be printed in the form
+	% a list of error message components. Each component may specify
+	% a string to printed exactly as it is, or it may specify a string
+	% containing a list of words, a list which may be broken at
+	% white space.
+
+:- type format_component
+	--->	fixed(string)	% This string should appear in the output
+				% in one piece, as it is.
+
+	;	words(string).	% This string contains words separated by
+				% white space. The words should appear in
+				% the output in the given order, but the
+				% white space may be rearranged and line
+				% breaks may be inserted.
 
-:- pred write_error_pieces(term__context::in, int::in, list(string)::in,
-	io__state::di, io__state::uo) is det.
+:- pred write_error_pieces(term__context::in, int::in,
+	list(format_component)::in, io__state::di, io__state::uo) is det.
 
 :- implementation.
 
 :- import_module prog_out.
+:- import_module char.
+:- import_module io, list, term, char, string, int.
 
-write_error_pieces(Context, Indent, Words) -->
+write_error_pieces(Context, Indent, Components) -->
 	{
 			% The fixed characters at the start of the line are:
 			% filename
@@ -59,6 +77,7 @@
 		),
 		Remain is 79 - (FileNameLength + 1 +
 			LineNumberStrLength + 2 + Indent),
+		convert_components_to_word_list(Components, Words),
 		group_words(Words, Remain, Lines)
 	},
 	write_lines(Lines, Context, Indent).
@@ -101,6 +120,67 @@
 	io__write_char(' '),
 	io__write_string(Word),
 	write_line_rest(Words).
+
+%----------------------------------------------------------------------------%
+
+:- pred convert_components_to_word_list(list(format_component)::in,
+	list(string)::out) is det.
+
+convert_components_to_word_list([], []).
+convert_components_to_word_list([Component | Components], Words) :-
+	convert_components_to_word_list(Components, TailWords),
+	(
+		Component = fixed(Word),
+		Words = [Word | TailWords]
+	;
+		Component = words(WordsStr),
+		break_into_words(WordsStr, HeadWords),
+		list__append(HeadWords, TailWords, Words)
+	).
+
+:- pred break_into_words(string::in, list(string)::out) is det.
+
+break_into_words(String, Words) :-
+	break_into_words_from(String, 0, Words).
+
+:- pred break_into_words_from(string::in, int::in, list(string)::out) is det.
+
+break_into_words_from(String, Cur, Words) :-
+	( find_word_start(String, Cur, Start) ->
+		find_word_end(String, Start, End),
+		Length is End - Start + 1,
+		string__substring(String, Start, Length, Word),
+		Next is End + 1,
+		break_into_words_from(String, Next, MoreWords),
+		Words = [Word | MoreWords]
+	;
+		Words = []
+	).
+
+:- pred find_word_start(string::in, int::in, int::out) is semidet.
+
+find_word_start(String, Cur, WordStart) :-
+	string__index(String, Cur, Char),
+	( char__is_whitespace(Char) ->
+		Next is Cur + 1,
+		find_word_start(String, Next, WordStart)
+	;
+		WordStart = Cur
+	).
+
+:- pred find_word_end(string::in, int::in, int::out) is det.
+
+find_word_end(String, Cur, WordEnd) :-
+	Next is Cur + 1,
+	( string__index(String, Next, Char) ->
+		( char__is_whitespace(Char) ->
+			WordEnd = Cur
+		;
+			find_word_end(String, Next, WordEnd)
+		)
+	;
+		WordEnd = Cur
+	).
 
 %----------------------------------------------------------------------------%
 
Index: compiler/term_errors.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/term_errors.m,v
retrieving revision 1.9
diff -u -u -r1.9 term_errors.m
--- term_errors.m	1998/01/24 17:02:57	1.9
+++ term_errors.m	1998/02/23 05:47:54
@@ -143,16 +143,18 @@
 term_errors__report_term_errors(SCC, Errors, Module) -->
 	{ get_context_from_scc(SCC, Module, Context) },
 	( { SCC = [PPId] } ->
-		{ Pieces0 = ["Termination", "of"] },
+		{ Pieces0 = [words("Termination of")] },
 		{ term_errors__describe_one_proc_name(PPId, Module, PredName) },
-		{ list__append(Pieces0, [PredName], Pieces1) },
+		{ list__append(Pieces0, [fixed(PredName)], Pieces1) },
 		{ Single = yes(PPId) }
 	;
-		{ Pieces0 = ["Termination", "of", "the",
-			"mutually", "recursive", "procedures"] },
+		{ Pieces0 = [words("Termination of the mutually recursive procedures")] },
 		{ term_errors__describe_several_proc_names(SCC, Module, Context,
-			PredNames) },
-		{ list__append(Pieces0, PredNames, Pieces1) },
+			ProcNames) },
+		{ list__map(lambda([PN::in, FPN::out] is det,
+			(FPN = fixed(PN))),
+			ProcNames, ProcNamePieces) },
+		{ list__append(Pieces0, ProcNamePieces, Pieces1) },
 		{ Single = no }
 	),
 	(
@@ -160,21 +162,18 @@
 		% XXX this should never happen
 		% XXX but for some reason, it often does
 		% { error("empty list of errors") }
-		{ Pieces2 = ["not", "proven,", "for", "unknown",
-			"reason(s)."] },
+		{ Pieces2 = [words("not proven, for unknown reason(s).")] },
 		{ list__append(Pieces1, Pieces2, Pieces) },
 		write_error_pieces(Context, 0, Pieces)
 	;
 		{ Errors = [Error] },
-		{ Pieces2 = ["not", "proven", "for", "the",
-			"following", "reason:"] },
+		{ Pieces2 = [words("not proven for the following reason:")] },
 		{ list__append(Pieces1, Pieces2, Pieces) },
 		write_error_pieces(Context, 0, Pieces),
 		term_errors__output_error(Error, Single, no, 0, Module)
 	;
 		{ Errors = [_, _ | _] },
-		{ Pieces2 = ["not", "proven", "for", "the",
-			"following", "reasons:"] },
+		{ Pieces2 = [words("not proven for the following reasons:")] },
 		{ list__append(Pieces1, Pieces2, Pieces) },
 		write_error_pieces(Context, 0, Pieces),
 		term_errors__output_errors(Errors, Single, 1, 0, Module)
@@ -187,33 +186,35 @@
 term_errors__report_arg_size_errors(SCC, Errors, Module) -->
 	{ get_context_from_scc(SCC, Module, Context) },
 	( { SCC = [PPId] } ->
-		{ Pieces0 = ["Termination", "constant", "of"] },
-		{ term_errors__describe_one_proc_name(PPId, Module, PredName) },
-		{ list__append(Pieces0, [PredName], Pieces1) },
+		{ Pieces0 = [words("Termination constant of")] },
+		{ term_errors__describe_one_proc_name(PPId, Module, ProcName) },
+		{ list__append(Pieces0, [fixed(ProcName)], Pieces1) },
 		{ Single = yes(PPId) }
 	;
-		{ Pieces0 = ["Termination", "constants", "of", "the",
-			"mutually", "recursive", "procedures"] },
-		{ term_errors__describe_several_proc_names(SCC, Module, Context,
-			PredNames) },
-		{ list__append(Pieces0, PredNames, Pieces1) },
+		{ Pieces0 = [words("Termination constants"),
+			words("of the mutually recursive procedures")] },
+		{ term_errors__describe_several_proc_names(SCC, Module,
+			Context, ProcNames) },
+		{ list__map(lambda([PN::in, FPN::out] is det,
+			(FPN = fixed(PN))),
+			ProcNames, ProcNamePieces) },
+		{ list__append(Pieces0, ProcNamePieces, Pieces1) },
 		{ Single = no }
 	),
+	{ Piece2 = words("set to infinity for the following") },
 	(
 		{ Errors = [] },
 		{ error("empty list of errors") }
 	;
 		{ Errors = [Error] },
-		{ Pieces2 = ["set", "to", "infinity", "for", "the",
-			"following", "reason:"] },
-		{ list__append(Pieces1, Pieces2, Pieces) },
+		{ Piece3 = words("reason:") },
+		{ list__append(Pieces1, [Piece2, Piece3], Pieces) },
 		write_error_pieces(Context, 0, Pieces),
 		term_errors__output_error(Error, Single, no, 0, Module)
 	;
 		{ Errors = [_, _ | _] },
-		{ Pieces2 = ["set", "to", "infinity", "for", "the",
-			"following", "reasons:"] },
-		{ list__append(Pieces1, Pieces2, Pieces) },
+		{ Piece3 = words("reasons:") },
+		{ list__append(Pieces1, [Piece2, Piece3], Pieces) },
 		write_error_pieces(Context, 0, Pieces),
 		term_errors__output_errors(Errors, Single, 1, 0, Module)
 	).
@@ -238,7 +239,7 @@
 	{ ErrorNum = yes(N) ->
 		string__int_to_string(N, Nstr),
 		string__append_list(["Reason ", Nstr, ":"], Preamble),
-		Pieces = [Preamble | Pieces0]
+		Pieces = [fixed(Preamble) | Pieces0]
 	;
 		Pieces = Pieces0
 	},
@@ -258,188 +259,178 @@
 	).
 
 :- pred term_errors__description(termination_error::in,
-	maybe(pred_proc_id)::in, module_info::in, list(string)::out,
+	maybe(pred_proc_id)::in, module_info::in, list(format_component)::out,
 	maybe(pred_proc_id)::out) is det.
 
 term_errors__description(horder_call, _, _, Pieces, no) :-
-	Pieces = ["It", "contains", "a", "higher", "order", "call."].
+	Pieces = [words("It contains a higher order call.")].
 
 term_errors__description(pragma_c_code, _, _, Pieces, no) :-
-	Pieces = ["It", "depends", "on", "the", "properties", "of",
-		"foreign", "language", "code", "included", "via", "a",
-		"`pragma c_code'", "declaration."].
+	Pieces = [words("It depends on the properties of"),
+		words("foreign language code included via a"),
+		fixed("`pragma c_code'"),
+		words("declaration.")].
 
 term_errors__description(inf_call(CallerPPId, CalleePPId),
 		Single, Module, Pieces, no) :-
 	(
 		Single = yes(PPId),
 		require(unify(PPId, CallerPPId), "caller outside this SCC"),
-		Piece1 = "It"
+		Piece1 = words("It")
 	;
 		Single = no,
-		term_errors__describe_one_proc_name(CallerPPId, Module, Piece1)
+		term_errors__describe_one_proc_name(CallerPPId, Module,
+			ProcName),
+		Piece1 = fixed(ProcName)
 	),
-	Piece2 = "calls",
+	Piece2 = words("calls"),
 	term_errors__describe_one_proc_name(CalleePPId, Module, CalleePiece),
-	Pieces3 = ["with", "an", "unbounded", "increase", "in", "the",
-		"size", "of", "the", "input", "arguments."],
-	Pieces = [Piece1, Piece2, CalleePiece | Pieces3].
+	Pieces3 = [words("with an unbounded increase"),
+		words("in the size of the input arguments.")],
+	Pieces = [Piece1, Piece2, fixed(CalleePiece) | Pieces3].
 
 term_errors__description(can_loop_proc_called(CallerPPId, CalleePPId),
 		Single, Module, Pieces, no) :-
 	(
 		Single = yes(PPId),
 		require(unify(PPId, CallerPPId), "caller outside this SCC"),
-		Piece1 = "It"
+		Piece1 = words("It")
 	;
 		Single = no,
-		term_errors__describe_one_proc_name(CallerPPId, Module, Piece1)
+		term_errors__describe_one_proc_name(CallerPPId, Module,
+			ProcName),
+		Piece1 = fixed(ProcName)
 	),
-	Piece2 = "calls",
+	Piece2 = words("calls"),
 	term_errors__describe_one_proc_name(CalleePPId, Module, CalleePiece),
-	Pieces3 = ["which", "could", "not", "be", "proven", "to", "terminate."],
-	Pieces = [Piece1, Piece2, CalleePiece | Pieces3].
+	Pieces3 = [words("which could not be proven to terminate.")],
+	Pieces = [Piece1, Piece2, fixed(CalleePiece) | Pieces3].
 
 term_errors__description(imported_pred, _, _, Pieces, no) :-
-	Pieces = ["It", "contains", "one", "or", "more",
-		"predicates", "and/or", "functions",
-		"imported", "from", "another", "module."].
+	Pieces = [words("It contains one or more"),
+		words("predicates and/or functions"),
+		words("imported from another module.")].
 
 term_errors__description(horder_args(CallerPPId, CalleePPId), Single, Module,
 		Pieces, no) :-
 	(
 		Single = yes(PPId),
 		require(unify(PPId, CallerPPId), "caller outside this SCC"),
-		Piece1 = "It"
+		Piece1 = words("It")
 	;
 		Single = no,
-		term_errors__describe_one_proc_name(CallerPPId, Module, Piece1)
+		term_errors__describe_one_proc_name(CallerPPId, Module,
+			ProcName),
+		Piece1 = fixed(ProcName)
 	),
-	Piece2 = "calls",
+	Piece2 = words("calls"),
 	term_errors__describe_one_proc_name(CalleePPId, Module, CalleePiece),
-	Pieces3 = ["with", "one", "or", "more",
-		"higher", "order", "arguments."],
-	Pieces = [Piece1, Piece2, CalleePiece | Pieces3].
+	Pieces3 = [words("with one or more higher order arguments.")],
+	Pieces = [Piece1, Piece2, fixed(CalleePiece) | Pieces3].
 
 term_errors__description(inf_termination_const(CallerPPId, CalleePPId),
 		Single, Module, Pieces, yes(CalleePPId)) :-
 	(
 		Single = yes(PPId),
 		require(unify(PPId, CallerPPId), "caller outside this SCC"),
-		Piece1 = "It"
+		Piece1 = words("It")
 	;
 		Single = no,
-		term_errors__describe_one_proc_name(CallerPPId, Module, Piece1)
+		term_errors__describe_one_proc_name(CallerPPId, Module,
+			ProcName),
+		Piece1 = fixed(ProcName)
 	),
-	Piece2 = "calls",
+	Piece2 = words("calls"),
 	term_errors__describe_one_proc_name(CalleePPId, Module, CalleePiece),
-	Pieces3 = ["which", "has", "a", "termination", "constant", "of",
-		"infinity."],
-	Pieces = [Piece1, Piece2, CalleePiece | Pieces3].
+	Pieces3 = [words("which has a termination constant of infinity.")],
+	Pieces = [Piece1, Piece2, fixed(CalleePiece) | Pieces3].
 
 term_errors__description(not_subset(ProcPPId, OutputSuppliers, HeadVars),
 		Single, Module, Pieces, no) :-
 	(
 		Single = yes(PPId),
 		( PPId = ProcPPId ->
-			Pieces1 = ["The", "set", "of", "its", "output",
-				"supplier", "variables"]
+			Pieces1 = [words("The set of"),
+				words("its output supplier variables")]
 		;
 			% XXX this should never happen (but it does)
 			% error("not_subset outside this SCC"),
 			term_errors__describe_one_proc_name(ProcPPId, Module,
 				PPIdPiece),
-			Pieces1 = ["The", "set", "of", "output", "supplier",
-				"variables", "of", PPIdPiece]
+			Pieces1 = [words("The set of"),
+				words("output supplier variables of"),
+				fixed(PPIdPiece)]
 		)
 	;
 		Single = no,
 		term_errors__describe_one_proc_name(ProcPPId, Module,
 			PPIdPiece),
-		Pieces1 = ["The", "set", "of", "output", "supplier",
-			"variables", "of", PPIdPiece]
+		Pieces1 = [words("The set of output supplier variables of"),
+			fixed(PPIdPiece)]
 	),
 	ProcPPId = proc(PredId, ProcId),
 	module_info_pred_proc_info(Module, PredId, ProcId, _, ProcInfo),
 	proc_info_varset(ProcInfo, Varset),
 	term_errors_var_bag_description(OutputSuppliers, Varset,
-		OutputSuppliersPieces),
-	Pieces3 = ["was", "not", "a", "subset", "of", "the", "head",
-		"variables"],
-	term_errors_var_bag_description(HeadVars, Varset, HeadVarsPieces),
+		OutputSuppliersNames),
+	list__map(lambda([OS::in, FOS::out] is det, (FOS = fixed(OS))),
+		OutputSuppliersNames, OutputSuppliersPieces),
+	Pieces3 = [words("was not a subset of the head variables")],
+	term_errors_var_bag_description(HeadVars, Varset, HeadVarsNames),
+	list__map(lambda([HV::in, FHV::out] is det, (FHV = fixed(HV))),
+		HeadVarsNames, HeadVarsPieces),
 	list__condense([Pieces1, OutputSuppliersPieces, Pieces3,
 		HeadVarsPieces], Pieces).
 
 term_errors__description(cycle(_StartPPId, CallSites), _, Module, Pieces, no) :-
 	( CallSites = [DirectCall] ->
 		term_errors__describe_one_call_site(DirectCall, Module, Site),
-		Pieces = ["At", "the", "recursive", "call", "to", Site,
-			"the", "arguments", "are", "not", "guaranteed",
-			"to", "decrease", "in", "size."]
+		Pieces = [words("At the recursive call to"),
+			fixed(Site),
+			words("the arguments are"),
+			words("not guaranteed to decrease in size.")]
 	;
-		Pieces1 = ["In", "the", "recursive", "cycle",
-			"through", "the", "calls", "to"],
+		Pieces1 = [words("In the recursive cycle"),
+			words("through the calls to")],
 		term_errors__describe_several_call_sites(CallSites, Module,
 			Sites),
-		Pieces2 = ["the", "arguments", "are", "not", "guaranteed",
-			"to", "decrease", "in", "size."],
-		list__condense([Pieces1, Sites, Pieces2], Pieces)
+		list__map(lambda([S::in, FS::out] is det, (FS = fixed(S))),
+			Sites, SitePieces),
+		Pieces2 = [words("the arguments are"),
+			words("not guaranteed to decrease in size.")],
+		list__condense([Pieces1, SitePieces, Pieces2], Pieces)
 	).
-	% Pieces = ["there", "was", "a", "cycle", "in", "the", "call", "graph",
-	% "of", "this", "SCC", "where", "the", "variables", "did", "not",
-	% "decrease", "in", "size."].
-
-% term_errors__description(positive_value(CallerPPId, CalleePPId),
-% 		Single, Module, Pieces, no) :-
-% 	(
-% 		Single = yes(PPId),
-% 		PPId = CallerPPId,
-% 		Piece1 = "it"
-% 	;
-% 		Single = no,
-% 		term_errors__describe_one_proc_name(CallerPPId, Module, Piece1)
-% 	),
-% 	( CallerPPId = CalleePPId ->
-% 		Pieces2 = ["contains", "a", "directly", "recursive", "call"]
-% 	;
-% 		term_errors__describe_one_proc_name(CalleePPId, Module,
-% 			CalleePiece),
-% 		Pieces2 = ["recursive", "call", "to", CalleePiece]
-% 	),
-% 	Pieces3 = ["with", "the", "size", "of", "the", "inputs", "increased."],
-% 	list__append([Piece1 | Pieces2], Pieces3, Pieces).
 
 term_errors__description(too_many_paths, _, _, Pieces, no) :-
-	Pieces = ["There", "were", "too", "many", "execution", "paths",
-		"for", "the", "analysis", "to", "process."].
+	Pieces = [words("There were too many execution paths"),
+		words("for the analysis to process.")].
 
 term_errors__description(no_eqns, _, _, Pieces, no) :-
-	Pieces = ["The", "analysis", "was", "unable", "to", "form", "any",
-		"constraints", "between", "the", "arguments", "of", "this",
-		"group", "of", "procedures."].
+	Pieces = [words("The analysis was unable to form any constraints"),
+		words("between the arguments of this group of procedures.")].
 
 term_errors__description(solver_failed, _, _, Pieces, no)  :-
-	Pieces = ["The", "solver", "found", "the", "constraints", "produced",
-		"by", "the", "analysis", "to", "be", "infeasible."].
+	Pieces = [words("The solver found the constraints produced"),
+		words("by the analysis to be infeasible.")].
 
 term_errors__description(is_builtin(_PredId), _Single, _, Pieces, no) :-
 	% XXX require(unify(Single, yes(_)), "builtin not alone in SCC"),
-	Pieces = ["It", "is", "a", "builtin", "predicate."].
+	Pieces = [words("It is a builtin predicate.")].
 
 term_errors__description(does_not_term_pragma(PredId), Single, Module,
 		Pieces, no) :-
-	Pieces1 = ["There", "was", "a", "`does_not_terminate'", "pragma",
-		"defined", "on"],
+	Pieces1 = [words("There was a `does_not_terminate' pragma defined on")],
 	(
 		Single = yes(PPId),
 		PPId = proc(SCCPredId, _),
 		require(unify(PredId, SCCPredId), "does not terminate pragma outside this SCC"),
-		Piece2 = "it."
+		Piece2 = words("It")
 	;
 		Single = no,
 		term_errors__describe_one_pred_name(PredId, Module,
 			Piece2Nodot),
-		string__append(Piece2Nodot, ".", Piece2)
+		string__append(Piece2Nodot, ".", Piece2Str),
+		Piece2 = fixed(Piece2Str)
 	),
 	list__append(Pieces1, [Piece2], Pieces).
 
cvs diff: Diffing compiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/cgi
cvs diff: Diffing extras/complex_numbers
cvs diff: Diffing extras/complex_numbers/samples
cvs diff: Diffing extras/complex_numbers/tests
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/Togl-1.2
cvs diff: Diffing extras/graphics/mercury_opengl
cvs diff: Diffing extras/graphics/mercury_tcltk
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/references
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing library
cvs diff: Diffing lp_solve
cvs diff: Diffing lp_solve/lp_examples
cvs diff: Diffing profiler
cvs diff: Diffing runtime
cvs diff: Diffing runtime/machdeps
cvs diff: Diffing samples
cvs diff: Diffing samples/c_interface
cvs diff: Diffing samples/c_interface/c_calls_mercury
cvs diff: Diffing samples/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/mercury_calls_c
cvs diff: Diffing samples/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/diff
cvs diff: Diffing scripts
cvs diff: Diffing tests
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/general
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trial
cvs diff: Diffing util
Previous message: for review: new library predicate
Next message: for review: making error_util more flexible
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the developers mailing list