[m-dev.] for review: Added a new format "newpretty" to the browser.

[Sarvamanan THURAIRATNAM]

Estimated hours taken : 180 

For Mark Brown to Review. 

Added a new pretty printing format to the term browser. This new format
helps put a limit on the size of the term printed during debugging.
This limit is specified by setting the number of lines you want the term to be
printed on and the width of these lines. Refer to sized_pretty.m for 
Examples.

browser/sized_pretty.m: 
	New file that does what's described above. 

browser/browse.m: 
browser/browser_info.m: 
browser/parse.m: 
trace/mercury_trace_browse.c: 
trace/mercury_trace_browse.h: 
trace/mercury_trace_internal.c: 
	Modified to accommodate the new format. 

This is a relative diff between the newest version of the code and the 
previous version I posted:

--- /home/stude/s/sthur/OldFiles/browser_info.m	Tue Feb  6 12:07:22 2001
+++ /home/stude/s/sthur/Review/mercury/browser/browser_info.m	Tue Feb  6 12:14:44 2001
@@ -1,5 +1,5 @@
 %---------------------------------------------------------------------------%
-% Copyright (C) 2001 The University of Melbourne.
+% Copyright (C) 2000-2001 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.
 %---------------------------------------------------------------------------%
@@ -55,10 +55,11 @@
 :- type portray_format
 	--->	flat
 	;	raw_pretty	% calls pprint module directly, without first 
-				% attempting to manipulate the term in any way
+				% attempting to manipulate the term in any way.
 	;	verbose
-	;	pretty.		% allows user to specify the no of lines in
-				% which the term has to be printed
+	;	pretty.		% It allows the user to specify the maximum 
+				% number of lines which the term has to be 
+				% printed within.
 
 :- type format_params
 	--->	format_params(
--- /home/stude/s/sthur/OldFiles/sized_pretty.m	Tue Feb  6 11:50:25 2001
+++ /home/stude/s/sthur/Review/mercury/browser/sized_pretty.m	Tue Feb  6 13:21:13 2001
@@ -1,5 +1,5 @@
 %---------------------------------------------------------------------------%
-% Copyright (C) 1998-2001 The University of Melbourne.
+% Copyright (C) 2001 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.
 %---------------------------------------------------------------------------%
@@ -182,9 +182,9 @@
 :- type maybe_deconstructed(T)
 	--->	not_deconstructed
 	;	deconstructed(
-			string,		% Functor 
-			int,		% Arity
-			list(maybe(pair(T, size_annotated_term(T)))) % arguments
+			string,			% Functor 
+			int,			% Arity
+			size_annotated_args(T) 	% arguments
 		).
 
 	% The exact type indicates the term has been fully deconstructed.
@@ -205,6 +205,9 @@
 			maybe_deconstructed(T)
 		).
 
+:- type size_annotated_args(T) == 
+	list(maybe(pair(T, size_annotated_term(T)))). 
+
 :- typeclass measure(T) where [
 	func max_measure(T, T) = T is det,
 	func zero_measure = T is det,
@@ -218,12 +221,15 @@
 		% given a term, it's arity, and a limit, this method decides
 		% the partial limit that each of the argument should be
 		% given. It's arguments in order are term, measure parameter(s),
-		% limit, arity, a flag, size of the Functor, partial limit,
-		% adjusted limit, adjusted measure parameter(s).
+		% limit, arity, a flag (once the limit for the subterms 
+		% is determined the subterms are flagged with this limit), size 
+		% of the Functor, partial limit, adjusted limit, adjusted 
+		% measure parameter(s).
 		% Also a term is not deconstructed unless it has enough space
-		% to print functor and the functors of it's arguments. But in
-		% some cases this check is not needed that's why the booleen is
-		% included.
+		% to print functor and the functors of it's arguments.
+		% If the bool is `yes', we check that there is enough space to 
+		% print the functor and the functors of its arguments before 
+		% deconstructing the term. 
 	pred measured_split(univ::in, MeasureParams::in, T::in, int::in,
 	     bool::in, T::out, maybe(T)::out, T::out, MeasureParams::out) is det
 		
@@ -299,9 +305,9 @@
 %------------------------------------------------------------------------------%
 	% annotating the arguments.
 :- pred annotate_args_with_size(assoc_list(maybe(T), univ)::in,
-	MeasureParams::in, T::in, T::in, T::out, bool::in, bool::out,
-	list(maybe(pair(T, size_annotated_term(T))))::out)
-	is det <= measure_with_params(T, MeasureParams).
+	MeasureParams::in, T::in, T::in, T::out, bool::in, bool::out, 
+	size_annotated_args(T)::out) is det <= measure_with_params(T, 
+	MeasureParams).
 
 annotate_args_with_size([], _, _, SoFar, SoFar, Exact, Exact, []).
 annotate_args_with_size([Flag - Arg | FlaggedArgs], Params, Limit,
@@ -341,7 +347,7 @@
 %------------------------------------------------------------------------------%
 	% Annotates the arguments with zero limit.
 :- pred annotate_args_with_zero_size(assoc_list(maybe(T), univ)::in, T::in,
-	list(maybe(pair(T, size_annotated_term(T))))::out) is det <= measure(T).
+	size_annotated_args(T)::out) is det <= measure(T).
 
 annotate_args_with_zero_size([], _, []).
 annotate_args_with_zero_size([Flag - Univ | FlaggedArgs], ZeroMeasure,
@@ -463,9 +469,8 @@
 	% represented would be annoted again with a new limit
 	% (SplitLimit). The rest of the terms are left alone.
 :- pred process_args(MeasureParams::in, 
-	list(maybe(pair(T, size_annotated_term(T))))::in, T::in, T::in, 
-	list(maybe(pair(T, size_annotated_term(T))))::out, T::out)
-	is det <= measure_with_params(T, MeasureParams).
+	size_annotated_args(T)::in, T::in, T::in, size_annotated_args(T)::out, 
+	T::out) is det <= measure_with_params(T, MeasureParams).
 
 process_args(_, [], _, _, [], zero_measure).
 process_args(Params, [HeadArg | Rest], ArgLimit, SplitLimit, 
@@ -530,8 +535,7 @@
 %------------------------------------------------------------------------------%
 	% Assumes that every argument must be on a different line
 	% or all of them should be on the same line.
-:- func to_doc_sized_2(string, int, 
-	list(maybe(pair(T, size_annotated_term(T))))) = doc.
+:- func to_doc_sized_2(string, int, size_annotated_args(T)) = doc.
 
 to_doc_sized_2(Functor, _Arity, []) = text(Functor).
 
@@ -729,9 +733,9 @@
 	% that each argument is a different line or they are all on 
 	% the same line. But this requires you to determine which case
 	% likely to happen before hand. For example if a term is to be
-	% on one line, you should do subtract_size_count(size_count(0, 
-	% LineLength), size_count(0, arglength)) rather than
-	% subtract_size_count(size_count(1, 0), size_count(0, arglength)).
+	% on one line, you should do subtract_size_count(character_count(
+	% LineLength), charater_count(arglength)) rather than
+	% subtract_size_count(line_count(1), character_count(arglength)).
 	% The reason that this situation cannot be detected in this code is:
 	% A term can be printed on a single line only if, all of it's 
 	% arguments can be printed on the same line. And you cannot determine
@@ -806,9 +810,10 @@
 
 size_count_split(Univ, Params, Limit, Arity, Check, FunctorSize, 
 		Flag, NewLimit, NewParams) :-
+	% LineWidth is length of the line in which the functor is printed.
 	Params = measure_params(LineWidth),
     	deconstruct(univ_value(Univ), Functor, ActualArity, Args),
-    	FSize = string__length(Functor) + 2*(ActualArity),
+    	FSize = string__length(Functor) + 2 * (ActualArity),
     	( Check = yes ->
     		get_arg_length(Args, TotalLength, MaxArgLength),
 		int__max(MaxArgLength, (string__length(Functor) + 1), MaxLength)
@@ -826,8 +831,12 @@
     	;
 		(
 			Limit = line_count(LineLimit),
-			(LineLimit >= (Arity + 1), 
-			(LineWidth - 2) >= MaxLength) 
+			% we need one line for the functor and atleast 
+			% one line for each argument
+			LineLimit >= (Arity + 1),
+			% linewidth is decreased by two characters to account 
+			% for indentation
+			(LineWidth - 2) >= MaxLength
 		->
 			Line = (LineLimit - 1) // Arity,
 			Flag = yes(line_count(Line)),
@@ -836,10 +845,14 @@
 	    		NewParams = measure_params(LineWidth - 2)
 		;
 			Limit = line_count(LineLimit),
-			LineLimit > 0, 
+			LineLimit > 0,
+			% Since every term is part of a bigger term (in this 
+			% context anyway) it will have a comma, space and a 
+			% newline at the end of it (Hence the "- 3").
 			LineWidth - 3 >= (FSize + TotalLength) 
 		->
-	    		Char = (LineWidth - 3 - FSize + Arity - 1) // Arity ,
+	    		% "Arity - 1" is for rounding up.
+			Char = (LineWidth - 3 - FSize + Arity - 1) // Arity ,
 	    		Flag = yes(character_count(Char)),
 	    		FunctorSize = character_count(FSize),
 	    		NewLimit = character_count(LineWidth - 3),
@@ -848,13 +861,15 @@
 			Limit = character_count(CharLimit),
 			CharLimit >= (FSize + TotalLength)
 		->
-	   		Char = (CharLimit - FSize + Arity - 1)// Arity,
+	   		Char = (CharLimit - FSize + Arity - 1) // Arity,
 	   		Flag = yes(character_count(Char)),
 	   		FunctorSize = character_count(FSize),
 	   		NewLimit = Limit,
 	   		NewParams = Params
 		;
-	   		Flag = no, 
+	   		Flag = no,
+			% If a term is not deconstructed, it is printed as
+			% "functor/Arity". The "+ 2" accounts for that.
 	   		FunctorSize = 
 				character_count(string__length(Functor) + 2),
 	   		NewLimit = Limit, 

--------------------------------------------------------------------------
mercury-developers mailing list
Post messages to:       mercury-developers at cs.mu.oz.au
Administrative Queries: owner-mercury-developers at cs.mu.oz.au
Subscriptions:          mercury-developers-request at cs.mu.oz.au
--------------------------------------------------------------------------