Tabling round 2 [1/3]

Oliver Hutchison ohutch at students.cs.mu.OZ.AU
Fri Mar 13 16:52:32 AEDT 1998


Ok. This new diff has addressed all of the suggestions Fergus made except
some of the documentation issues which I intend to work on while this is
getting reviewed. Also it does not include the memo_loop_check case that
is currently being discussed, but, since memo does the loop check in my
implementation it will be trivial to add in the future. 

Estimated hours taken: 220

Add support for tabling.

This change allows for model_det, model_semidet and model_non memoing, 
minimal model and loop detection tabling.

compiler/base_type_layout.m:
	Update comments to reflect new runtime naming standard.

compiler/det_analysis.m:
	Allow tabling to change the result of det analysis. This is 
	necessary in the case of minimal model tabling which can
	turn a det procedure into a semidet one.

compiler/det_report.m:
compiler/hlds_data.m:
	Add code to report error messages for various non compatible
	tabling methods and determinism.

compiler/hlds_out.m:
compiler/modules.m:
compiler/stratify.m:
	Remove reference to the old memo marker.

compiler/hlds_pred.m:
	Create new type (eval_method) to define which of the available 
	evaluation methods should be used each procedure.
	Add new field to the proc_info structure.
	Add several new predicates relating to the new eval_method type.

compiler/inlining.m:
compiler/intermod.m:
	Make sure only procedures with normal evaluation are inlined.

compiler/make_hlds.m:
	Add code to process new tabling pragmas.

compiler/mercury_compile.m:
	Call the tabling transformation code.

compiler/modes.m:
	Make sure that all procedures with non normal evaluation have 
	no unique/partially instantiated modes. Produce error messages 
	if they do. Support for partially instantiated modes is currently 
	missing as it represents a large amount of work for a case that 
	is currently not used.

compiler/module_qual.m:
compile/prog_data.m:
compiler/prog_io_pragma.m:
	Add three new pragma types:
		`memo'
		`loop_check'
		`minimal_model'
	and code to support them.

compiler/simplify.m:
	Don't report infinite recursion warning if a procedure has
	minimal model evaluation.

compiler/switch_detection.m:
	Fix a small bug where goal were being placed in reverse order.
	Call list__reverse on the list of goals.

compiler/table_gen.m:
	New module to do the actual tabling transformation.

compiler/notes/compiler_design.html:
	Document addition of new tabling pass to the compiler.

doc/reference_manual.texi:
	Fix mistake in example.

library/mercury_builtin.m:
	Add many new predicates for support of tabling.

library/std_util.m:
library/store.m:
	Move the functions :
		ML_compare_type_info
		ML_collapse_equivalences
		ML_create_type_info
	to the runtime.

runtime/Mmakefile:
runtime/mercury_imp.h:
	Add references to new files added for tabling support.

runtime/mercury_string.h:
	Change hash macro so it does not cause a name clash with any
	variable called "hash".

runtime/mercury_type_info.c:
runtime/mercury_type_info.h:
	Add three new functions taken from the library :
		MR_compare_type_info
		MR_collapse_equivalences
		MR_create_type_info.

runtime/mercury_table_any.c:
runtime/mercury_table_any.h:
runtime/mercury_table_enum.c:
runtime/mercury_table_enum.h:
runtime/mercury_table_int_float_string.c:
runtime/mercury_table_int_float_string.h:
runtime/mercury_table_type_info.c:
runtime/mercury_table_type_info.h:
runtime/mercury_tabling.h:
	New modules for the support of tabling.

Index: compiler/base_type_layout.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/base_type_layout.m,v
retrieving revision 1.28
diff -u -r1.28 base_type_layout.m
--- base_type_layout.m	1998/03/03 17:33:33	1.28
+++ base_type_layout.m	1998/03/05 02:04:14
@@ -34,8 +34,9 @@
 % 		io.m			- io__stream type
 % 		mercury_builtin.m	- builtin types
 %
-% runtime:	type_info.h		- defines layout macros
-% 		deep_copy.{c,h}		- deep_copy
+% runtime:	mercury_type_info.h	- defines layout macros
+% 		mercury_deep_copy.{c,h}	- deep_copy
+%		mercury_table_any.c	- tabling
 % 		
 % Any module that uses base_type_layouts should register itself here.
 % Changes can by minimized by using the macros in type_info.h.
Index: compiler/det_analysis.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/det_analysis.m,v
retrieving revision 1.130
diff -u -r1.130 det_analysis.m
--- det_analysis.m	1998/03/03 17:34:02	1.130
+++ det_analysis.m	1998/03/05 02:04:20
@@ -258,8 +258,12 @@
 	determinism_components(Detism1, CanFail1, MaxSoln1),
 	det_switch_canfail(CanFail0, CanFail1, CanFail),
 	det_switch_maxsoln(MaxSoln0, MaxSoln1, MaxSoln),
-	determinism_components(Detism, CanFail, MaxSoln),
+	determinism_components(Detism2, CanFail, MaxSoln),
 
+		% Now see if the evaluation model can change the detism
+	proc_info_eval_method(Proc0, EvalMethod),
+	eval_method_change_determinism(EvalMethod, Detism2, Detism),		
+			
 		% Save the newly inferred information
 	proc_info_set_goal(Proc0, Goal, Proc1),
 	proc_info_set_inferred_determinism(Proc1, Detism, Proc),
Index: compiler/det_report.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/det_report.m,v
retrieving revision 1.49
diff -u -r1.49 det_report.m
--- det_report.m	1998/03/03 17:34:04	1.49
+++ det_report.m	1998/03/10 01:50:10
@@ -108,7 +108,7 @@
 :- import_module globals, options, prog_out, hlds_out, mercury_to_mercury.
 :- import_module passes_aux.
 
-:- import_module bool, int, map, set, std_util, require.
+:- import_module bool, int, map, set, std_util, require, string.
 
 %-----------------------------------------------------------------------------%
 
@@ -128,19 +128,19 @@
 		module_info, module_info, io__state, io__state).
 :- mode check_determinism(in, in, in, in, in, out, di, uo) is det.
 
-check_determinism(PredId, ProcId, _PredInfo, ProcInfo,
+check_determinism(PredId, ProcId, PredInfo0, ProcInfo0,
 		ModuleInfo0, ModuleInfo) -->
-	{ proc_info_declared_determinism(ProcInfo, MaybeDetism) },
-	{ proc_info_inferred_determinism(ProcInfo, InferredDetism) },
+	{ proc_info_declared_determinism(ProcInfo0, MaybeDetism) },
+	{ proc_info_inferred_determinism(ProcInfo0, InferredDetism) },
 	(
 		{ MaybeDetism = no },
-		{ ModuleInfo = ModuleInfo0 }
+		{ ModuleInfo1 = ModuleInfo0 }
 	;
 		{ MaybeDetism = yes(DeclaredDetism) },
 		{ compare_determinisms(DeclaredDetism, InferredDetism, Cmp) },
 		(
 			{ Cmp = sameas },
-			{ ModuleInfo = ModuleInfo0 }
+			{ ModuleInfo1 = ModuleInfo0 }
 		;
 			{ Cmp = looser },
 			globals__io_lookup_bool_option(
@@ -154,25 +154,80 @@
 			;
 				[]
 			),
-			{ ModuleInfo = ModuleInfo0 }
+			{ ModuleInfo1 = ModuleInfo0 }
 		;
 			{ Cmp = tighter },
-			{ module_info_incr_errors(ModuleInfo0, ModuleInfo) },
+			{ module_info_incr_errors(ModuleInfo0, ModuleInfo1) },
 			{ Message = "  error: determinism declaration not satisfied.\n" },
 			report_determinism_problem(PredId,
-				ProcId, ModuleInfo, Message,
+				ProcId, ModuleInfo1, Message,
 				DeclaredDetism, InferredDetism),
-			{ proc_info_goal(ProcInfo, Goal) },
+			{ proc_info_goal(ProcInfo0, Goal) },
 			globals__io_get_globals(Globals),
-			{ det_info_init(ModuleInfo, PredId, ProcId, Globals,
+			{ det_info_init(ModuleInfo1, PredId, ProcId, Globals,
 				DetInfo) },
 			det_diagnose_goal(Goal, DeclaredDetism, [], DetInfo, _)
 			% XXX with the right verbosity options, we want to
 			% call report_determinism_problem only if diagnose
 			% returns false, i.e. it didn't print a message.
 		)
+	),
+	
+	% make sure the code model is valid given the eval method
+	{ proc_info_eval_method(ProcInfo0, EvalMethod0) },
+	{ determinism_to_code_model(InferredDetism, CodeMod) },
+	( 
+		{ valid_code_model_for_eval_method(EvalMethod0, CodeMod) }
+	->
+		{
+		    get_actual_eval_method(EvalMethod0, EvalMethod),
+		    proc_info_set_eval_method(ProcInfo0, EvalMethod, ProcInfo),
+		    pred_info_procedures(PredInfo0, ProcTable0),
+		    map__det_update(ProcTable0, ProcId, ProcInfo, ProcTable),
+		    pred_info_set_procedures(PredInfo0, ProcTable, PredInfo),
+		    module_info_set_pred_info(ModuleInfo1, PredId, PredInfo, 
+		    	ModuleInfo)
+		}
+	;
+		{ proc_info_context(ProcInfo0, Context) },
+		prog_out__write_context(Context),
+		{ eval_method_to_string(EvalMethod0, EvalMethodS) },
+		io__write_string("Error: `pragma "),
+		io__write_string(EvalMethodS),
+		io__write_string("' declaration not allowed for procedure\n"),
+		prog_out__write_context(Context),
+		io__write_string("with determinism `"),
+		mercury_output_det(InferredDetism),
+		io__write_string("'.\n"), 
+		globals__io_lookup_bool_option(verbose_errors, VerboseErrors),
+		( { VerboseErrors = yes } ->
+			io__write_string(
+"\tThe pragma requested is only valid for the folowing determinism(s): \n"),
+			{ solutions(get_valid_dets(EvalMethod0), Sols) },
+			print_dets(Sols)
+		;
+			[]
+		),
+		{ module_info_incr_errors(ModuleInfo1, ModuleInfo) }
 	).
 
+:- pred get_valid_dets(eval_method, determinism).
+:- mode get_valid_dets(in, out) is multidet.
+
+get_valid_dets(EvalMethod, Det) :-
+	valid_code_model_for_eval_method(EvalMethod, CodeModel),
+	determinism_to_code_model(Det, CodeModel).
+
+:- pred print_dets(list(determinism), io__state, io__state).
+:- mode print_dets(in, di, uo) is det.
+
+print_dets([]) --> [].
+print_dets([D|Rest]) -->
+	io__write_string("\t\t"),
+	mercury_output_det(D),
+	io__nl,
+	print_dets(Rest).
+	
 :- pred check_if_main_can_fail(pred_id, proc_id, pred_info, proc_info,
 		module_info, module_info, io__state, io__state).
 :- mode check_if_main_can_fail(in, in, in, in, in, out, di, uo) is det.
@@ -193,8 +248,8 @@
 		  determinism_components(DeclaredDeterminism, can_fail, _)
 		}
 	->
-		{ proc_info_context(ProcInfo, Context) },
-		prog_out__write_context(Context),
+		{ proc_info_context(ProcInfo, Context1) },
+		prog_out__write_context(Context1),
 			% The error message is actually a lie -
 			% main/2 can also be `erroneous'.  But mentioning
 			% that would probably just confuse people.
@@ -236,6 +291,7 @@
 	->
 		% ... then it is an error.
 		{ pred_info_name(PredInfo, PredName) },
+
 		{ proc_info_context(ProcInfo, FuncContext) },
 		prog_out__write_context(FuncContext),
 		io__write_string("Error: invalid determinism for function\n"),
@@ -290,7 +346,7 @@
 		DeclaredDetism, InferredDetism) -->
 	globals__io_lookup_bool_option(halt_at_warn, HaltAtWarn),
 	( { HaltAtWarn = yes } ->
-		 io__set_exit_status(1)
+		io__set_exit_status(1)
 	;
 		[]
 	),
Index: compiler/hlds_data.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/hlds_data.m,v
retrieving revision 1.22
diff -u -r1.22 hlds_data.m
--- hlds_data.m	1998/03/03 17:34:27	1.22
+++ hlds_data.m	1998/03/05 02:04:23
@@ -674,6 +674,7 @@
 
 :- pred determinism_to_code_model(determinism, code_model).
 :- mode determinism_to_code_model(in, out) is det.
+:- mode determinism_to_code_model(out, in) is multidet.
 
 :- implementation.
 
Index: compiler/hlds_out.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/hlds_out.m,v
retrieving revision 1.191
diff -u -r1.191 hlds_out.m
--- hlds_out.m	1998/03/12 01:12:09	1.191
+++ hlds_out.m	1998/03/12 01:39:37
@@ -550,7 +550,6 @@
 hlds_out__marker_name(dnf, "dnf").
 hlds_out__marker_name(magic, "magic").
 hlds_out__marker_name(obsolete, "obsolete").
-hlds_out__marker_name(memo, "memo").
 hlds_out__marker_name(class_method, "class_method").
 hlds_out__marker_name((impure), "impure").
 hlds_out__marker_name((semipure), "semipure").
Index: compiler/hlds_pred.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/hlds_pred.m,v
retrieving revision 1.46
diff -u -r1.46 hlds_pred.m
--- hlds_pred.m	1998/03/03 17:34:35	1.46
+++ hlds_pred.m	1998/03/13 05:37:34
@@ -111,6 +111,19 @@
 			;	clauses		
 			;	none.
 
+	% The evaluation method that should be used for a pred
+
+:- type eval_method	--->	eval_normal		% normal mercury 
+							% evaluation
+			;	eval_memo		% memoing evaluation
+			;	eval_loop_check		% memoing + loop check
+			;	eval_minimal		% minimal model 
+							% evaluation 
+			;	if_valid(eval_method).	% ignore the eval model
+							% if the detism of the 
+							% proc is not valid for 
+							% the eval model
+							
 	% Note: `liveness' and `liveness_info' record liveness in the sense
 	% used by code generation.  This is *not* the same thing as the notion
 	% of liveness used by mode analysis!  See compiler/notes/glossary.html.
@@ -194,12 +207,9 @@
 				% Conflicts with `inline' marker.
 	;	dnf		% Requests that this predicate be transformed
 				% into disjunctive normal form.
-				% Used for pragma(memo).
 	;	magic		% Requests that this predicate be transformed
 				% using the magic set transformation
 				% Used for pragma(memo).
-	;	memo		% Requests that this predicate be evaluated
-				% using memoing.
 				% Used for pragma(memo).
 	;	class_method	% Requests that this predicate be transformed
 				% into the appropriate call to a class method
@@ -938,6 +948,12 @@
 	proc_info).
 :- mode proc_info_set_typeinfo_varmap(in, in, out) is det.
 
+:- pred proc_info_eval_method(proc_info, eval_method).
+:- mode proc_info_eval_method(in, out) is det.
+
+:- pred proc_info_set_eval_method(proc_info, eval_method, proc_info).
+:- mode proc_info_set_eval_method(in, in, out) is det.
+
 :- pred proc_info_typeclass_info_varmap(proc_info, map(class_constraint, var)).
 :- mode proc_info_typeclass_info_varmap(in, out) is det.
 
@@ -1019,6 +1035,7 @@
 			map(class_constraint, var),
 					% typeclass_info vars for class
 					% constraints
+			eval_method,	% how should the proc be evaluated	
 			maybe(arg_size_info),
 					% Information about the relative sizes
 					% of the input and output args of the
@@ -1066,8 +1083,8 @@
 	NewProc = procedure(
 		MaybeDet, BodyVarSet, BodyTypes, HeadVars, Modes, MaybeArgLives,
 		ClauseBody, MContext, StackSlots, InferredDet, CanProcess,
-		ArgInfo, InitialLiveness, TVarsMap, TCVarsMap, no, no,
-		DeclaredModes, ArgsMethod
+		ArgInfo, InitialLiveness, TVarsMap, TCVarsMap, eval_normal,
+		no, no, DeclaredModes, ArgsMethod
 	).
 
 proc_info_set(DeclaredDetism, BodyVarSet, BodyTypes, HeadVars, HeadModes,
@@ -1077,7 +1094,7 @@
 	ProcInfo = procedure(
 		DeclaredDetism, BodyVarSet, BodyTypes, HeadVars, HeadModes,
 		HeadLives, Goal, Context, StackSlots, InferredDetism,
-		CanProcess, ArgInfo, Liveness, TVarMap, TCVarsMap,
+		CanProcess, ArgInfo, Liveness, TVarMap, TCVarsMap, eval_normal, 
 		ArgSizes, Termination, no, ArgsMethod).
 
 proc_info_create(VarSet, VarTypes, HeadVars, HeadModes, Detism, Goal,
@@ -1087,13 +1104,14 @@
 	MaybeHeadLives = no,
 	ProcInfo = procedure(yes(Detism), VarSet, VarTypes, HeadVars, HeadModes,
 		MaybeHeadLives, Goal, Context, StackSlots, Detism, yes, [],
-		Liveness, TVarMap, TCVarsMap, no, no, no, ArgsMethod).
+		Liveness, TVarMap, TCVarsMap, eval_normal, no, no, no, 
+			ArgsMethod).
 
 proc_info_set_body(ProcInfo0, VarSet, VarTypes, HeadVars, Goal, ProcInfo) :-
 	ProcInfo0 = procedure(A, _, _, _, E, F, _,
-		H, I, J, K, L, M, N, O, P, Q, R, S),
+		H, I, J, K, L, M, N, O, P, Q, R, S, T),
 	ProcInfo = procedure(A, VarSet, VarTypes, HeadVars, E, F, Goal,
-		H, I, J, K, L, M, N, O, P, Q, R, S).
+		H, I, J, K, L, M, N, O, P, Q, R, S, T).
 
 proc_info_interface_determinism(ProcInfo, Determinism) :-
 	proc_info_declared_determinism(ProcInfo, MaybeDeterminism),
@@ -1150,80 +1168,84 @@
 	).
 
 proc_info_declared_determinism(ProcInfo, A) :-
-    ProcInfo = procedure(A, _, _, _, _, _, _, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(A, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+    		_, _, _, _).
 
 proc_info_varset(ProcInfo, B) :-
-    ProcInfo = procedure(_, B, _, _, _, _, _, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, B, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_vartypes(ProcInfo, C) :-
-    ProcInfo = procedure(_, _, C, _, _, _, _, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, C, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_headvars(ProcInfo, D) :-
-    ProcInfo = procedure(_, _, _, D, _, _, _, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, D, _, _, _, _, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_argmodes(ProcInfo, E) :-
-    ProcInfo = procedure(_, _, _, _, E, _, _, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, E, _, _, _, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_maybe_arglives(ProcInfo, F) :-
-    ProcInfo = procedure(_, _, _, _, _, F, _, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, F, _, _, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_goal(ProcInfo, G) :-
-    ProcInfo = procedure(_, _, _, _, _, _, G, _, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, G, _, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_context(ProcInfo, H) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, H, _,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, H, _, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_stack_slots(ProcInfo, I) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, I,
-    		_, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, I, _, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_inferred_determinism(ProcInfo, J) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		J, _, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, J, _, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_can_process(ProcInfo, K) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, K, _, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, K, _, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_arg_info(ProcInfo, L) :- 
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-   		 _, _, L, _, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, L, _, _, _, _, 
+		_, _, _, _).
 
 proc_info_liveness_info(ProcInfo, M) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, M, _, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, M, _, _, _,
+		_, _, _, _).
 
 proc_info_typeinfo_varmap(ProcInfo, N) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, _, N, _, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, N, _, _, 
+		_, _, _, _).
 
 proc_info_typeclass_info_varmap(ProcInfo, O) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, _, _, O, _, _, _, _).
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, O, _, 
+		_, _, _, _).
+
+proc_info_eval_method(ProcInfo, P) :-
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, P, 
+		_, _, _, _).
 
-proc_info_get_maybe_arg_size_info(ProcInfo, P) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, _, _, _, P, _, _, _).
-
-proc_info_get_maybe_termination_info(ProcInfo, Q) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, _, _, _, _, Q, _, _).
-
-proc_info_maybe_declared_argmodes(ProcInfo, R) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, _, _, _, _, _, R, _).
-
-proc_info_args_method(ProcInfo, S) :-
-    ProcInfo = procedure(_, _, _, _, _, _, _, _, _,
-    		_, _, _, _, _, _, _, _, _, S).
+proc_info_get_maybe_arg_size_info(ProcInfo, Q) :-
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+		Q, _, _, _).
+
+proc_info_get_maybe_termination_info(ProcInfo, R) :-
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+		_, R, _, _)..
+
+proc_info_maybe_declared_argmodes(ProcInfo, S) :-
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+		_, _, S, _).
+
+proc_info_args_method(ProcInfo, T) :-
+	ProcInfo = procedure(_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, 
+		_, _, _, T).
 
 % :- type proc_info
 % 	--->	procedure(
@@ -1262,18 +1284,21 @@
 % O			map(class_constraint, var),
 % 					% typeclass_info vars for class
 % 					% constraints
-% P			maybe(arg_size_info),
+% P			eval_method,
+%					% info on how the proc sould be 
+%					% evaluated
+% Q			maybe(arg_size_info),
 % 					% Information about the relative sizes
 % 					% of the input and output args of the
 % 					% procedure. Set by termination
 % 					% analysis.
-% Q			maybe(termination_info),
+% R			maybe(termination_info),
 % 					% The termination properties of the
 % 					% procedure. Set by termination
 % 					% analysis.
-% R			maybe(list(mode))
+% S			maybe(list(mode))
 % 					% declared modes of arguments.
-% S			args_method
+% T			args_method
 % 					% The args_method to be used for
 %					% the procedure. Usually this will
 %					% be set to the value of the --args
@@ -1285,100 +1310,106 @@
 %		).
 
 proc_info_set_varset(ProcInfo0, B, ProcInfo) :-
-    ProcInfo0 = procedure(A, _, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, _, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_vartypes(ProcInfo0, C, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, _, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, _, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_headvars(ProcInfo0, D, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, _, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, _, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_argmodes(ProcInfo0, E, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, _, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, _, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_maybe_arglives(ProcInfo0, F, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, _, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, _, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_goal(ProcInfo0, G, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, _, H, I,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, _, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_stack_slots(ProcInfo0, I, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, _,
-    		J, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, _, J, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_inferred_determinism(ProcInfo0, J, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		_, K, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, _, K, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_can_process(ProcInfo0, K, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, _, L, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, _, L, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_arg_info(ProcInfo0, L, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, _, M, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, _, M, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_liveness_info(ProcInfo0, M, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, _, N, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, _, N, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_typeinfo_varmap(ProcInfo0, N, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, _, O, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, _, O, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_set_typeclass_info_varmap(ProcInfo0, O, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, _, P, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
-
-proc_info_set_maybe_arg_size_info(ProcInfo0, P, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, _, Q, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
-
-proc_info_set_maybe_termination_info(ProcInfo0, Q, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, _, R, S),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
-
-proc_info_set_args_method(ProcInfo0, S, ProcInfo) :-
-    ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, _),
-    ProcInfo  = procedure(A, B, C, D, E, F, G, H, I,
-    		J, K, L, M, N, O, P, Q, R, S).
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, _, 
+		P, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
+
+proc_info_set_eval_method(ProcInfo0, P, ProcInfo) :-
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O,
+		_, Q, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O,
+		P, Q, R, S, T).
+
+proc_info_set_maybe_arg_size_info(ProcInfo0, Q, ProcInfo) :-
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, _, R, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
+
+proc_info_set_maybe_termination_info(ProcInfo0, R, ProcInfo) :-
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, _, S, T),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
+
+proc_info_set_args_method(ProcInfo0, T, ProcInfo) :-
+	ProcInfo0 = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, _),
+	ProcInfo  = procedure(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 
+		P, Q, R, S, T).
 
 proc_info_get_typeinfo_vars_setwise(ProcInfo, Vars, TypeInfoVars) :-
 	set__to_sorted_list(Vars, VarList),
@@ -1505,3 +1536,79 @@
 	).
 
 %-----------------------------------------------------------------------------%
+
+:- interface.
+
+	% Check if the given evaluation method is allowed with
+	% the given code model.
+:- pred valid_code_model_for_eval_method(eval_method, code_model).
+:- mode valid_code_model_for_eval_method(in, in) is semidet.
+:- mode valid_code_model_for_eval_method(in, out) is multidet.
+
+	% Remove any if_valid evaluation methods and return the 
+	% final "actual" method. 
+:- pred get_actual_eval_method(eval_method, eval_method).
+:- mode get_actual_eval_method(in, out) is det.
+
+	% Convert an evaluation method to a string.
+:- pred eval_method_to_string(eval_method, string).
+:- mode eval_method_to_string(in, out) is det.
+
+	% Return true if the given evaluation method requires a
+	% stratification check.
+:- pred eval_method_need_stratification(eval_method).
+:- mode eval_method_need_stratification(in) is semidet.
+
+	% Return the change a given evaluation method can do to a given 
+	% determinism.
+:- pred eval_method_change_determinism(eval_method, determinism, 
+		determinism).
+:- mode eval_method_change_determinism(in, in, out) is det.
+
+:- implementation.
+
+:- import_module det_analysis.
+
+valid_code_model_for_eval_method(eval_normal, model_det).
+valid_code_model_for_eval_method(eval_normal, model_semi).
+valid_code_model_for_eval_method(eval_normal, model_non).
+valid_code_model_for_eval_method(eval_memo, model_det).
+valid_code_model_for_eval_method(eval_memo, model_semi).
+valid_code_model_for_eval_method(eval_memo, model_non).
+valid_code_model_for_eval_method(eval_loop_check, model_det).
+valid_code_model_for_eval_method(eval_loop_check, model_semi).
+valid_code_model_for_eval_method(eval_loop_check, model_non).
+valid_code_model_for_eval_method(eval_minimal, model_semi).
+valid_code_model_for_eval_method(eval_minimal, model_non).
+valid_code_model_for_eval_method(if_valid(Method0), CodeMod) :-
+	valid_code_model_for_eval_method(Method0, CodeMod).
+
+get_actual_eval_method(EvalMethod0, EvalMethod) :-
+	(
+		EvalMethod0 = if_valid(Method0)
+	->
+		get_actual_eval_method(Method0, EvalMethod)
+	;
+		EvalMethod = EvalMethod0
+	).
+
+eval_method_to_string(eval_normal,		"normal").
+eval_method_to_string(eval_memo,		"memo").
+eval_method_to_string(eval_loop_check,		"loop_check").
+eval_method_to_string(eval_minimal, 		"minimal_model").
+eval_method_to_string(if_valid(Method), String) :-
+	eval_method_to_string(Method, String).
+
+	% XXX : We can't really use the stratification check, because it is 
+	% too conservative.
+eval_method_need_stratification(_) :-
+	semidet_fail.	
+
+eval_method_change_determinism(eval_normal, Detism, Detism).
+eval_method_change_determinism(eval_memo, Detism, Detism).
+eval_method_change_determinism(eval_loop_check, Detism, Detism).
+eval_method_change_determinism(eval_minimal, Det0, Det) :-
+	det_conjunction_detism(semidet, Det0, Det).
+eval_method_change_determinism(if_valid(Method), Detism0, Detism) :-
+	eval_method_change_determinism(Method, Detism0, Detism).
+
Index: compiler/inlining.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/inlining.m,v
retrieving revision 1.74
diff -u -r1.74 inlining.m
--- inlining.m	1998/03/03 17:34:37	1.74
+++ inlining.m	1998/03/10 01:57:11
@@ -587,7 +587,8 @@
 	% don't try to inline imported predicates, since we don't
 	% have the code for them.
 
-	module_info_pred_info(ModuleInfo, PredId, PredInfo),
+	module_info_pred_proc_info(ModuleInfo, PredId, ProcId, PredInfo, 
+		ProcInfo),
 	\+ pred_info_is_imported(PredInfo),
 		% this next line catches the case of locally defined
 		% unification predicates for imported types.
@@ -596,6 +597,14 @@
 		hlds_pred__in_in_unification_proc_id(ProcId)
 	),
 
+	% Only try to inline procedures which are evaluated using
+	% normal evaluation. Currently we can't inline procs evaluated
+	% using any of the other methods because the code generator for
+	% the methods can only handle whole procedures not code 
+	% fragments.
+
+	proc_info_eval_method(ProcInfo, eval_normal),
+	
 	% don't inlining anything we have been specifically requested
 	% not to inline.
 
Index: compiler/intermod.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/intermod.m,v
retrieving revision 1.46
diff -u -r1.46 intermod.m
--- intermod.m	1998/03/03 17:34:44	1.46
+++ intermod.m	1998/03/05 02:04:27
@@ -180,7 +180,9 @@
 				{ inlining__is_simple_goal(Goal,
 						InlineThreshold) },
 				{ pred_info_get_markers(PredInfo0, Markers) },
-				{ \+ check_marker(Markers, no_inline) }
+				{ \+ check_marker(Markers, no_inline) },
+				{ proc_info_eval_method(ProcInfo, 
+					eval_normal) }
 			;
 				{ pred_info_requested_inlining(PredInfo0) }
 			;
Index: compiler/make_hlds.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/make_hlds.m,v
retrieving revision 1.263
diff -u -r1.263 make_hlds.m
--- make_hlds.m	1998/03/04 19:47:34	1.263
+++ make_hlds.m	1998/03/12 03:01:39
@@ -323,12 +323,11 @@
 		% clauses).
 		{ Pragma = c_code(_, _, _, _, _, _) },
 		{ Module = Module0 }
-	;
-		{ Pragma = memo(Name, Arity) },
-		add_pred_marker(Module0, "memo", Name, Arity, Context,
-			memo, [], Module1),
-		add_stratified_pred(Module1, "memo", Name, Arity, Context, 
-			Module)
+	;	
+		% Handle pragma tabled decls later on (when we process
+		% clauses).
+		{ Pragma = tabled(_, _, _, _, _) },
+		{ Module = Module0 }
 	;
 		{ Pragma = inline(Name, Arity) },
 		add_pred_marker(Module0, "inline", Name, Arity, Context,
@@ -526,7 +525,29 @@
 		module_add_pragma_fact_table(Pred, Arity, File, 
 			Status, Context, Module0, Module, Info0, Info)
 	;
-		% don't worry about any pragma decs but c_code
+		{ Pragma = tabled(Type, Name, Arity, PredOrFunc, Mode) }
+	->
+		globals__io_lookup_bool_option(type_layout, TypeLayout),
+		(
+			{ TypeLayout = yes }
+		->
+			module_add_pragma_tabled(Type, Name, Arity, PredOrFunc,
+				Mode, Context, Module0, Module)
+		;
+			{ module_info_incr_errors(Module0, Module) },
+			prog_out__write_context(Context),
+			io__write_string("Error: `:- pragma "),
+			{ eval_method_to_string(Type, EvalMethodS) },
+			io__write_string(EvalMethodS),
+			io__write_string(
+"' declaration requires the base_type_layout\n"),
+			prog_out__write_context(Context),
+			io__write_string(
+"structures. Use the --type-layout flag to enable them.\n")
+		),
+		{ Info = Info0 }
+	;
+		% don't worry about any pragma decs but c_code, tabling
 		% and fact_table here
 		{ Module = Module0 },
 		{ Info = Info0 }	
@@ -698,38 +719,12 @@
 
 %-----------------------------------------------------------------------------%
 
-:- pred add_stratified_pred(module_info, string, sym_name, arity,
-	term__context, module_info, io__state, io__state).
-:- mode add_stratified_pred(in, in, in, in, in, out, di, uo) is det.
-
-add_stratified_pred(Module0, PragmaName, Name, Arity, Context, Module) -->
-	{ module_info_get_predicate_table(Module0, PredTable0) },
-	(
-		{ predicate_table_search_sym_arity(PredTable0, Name, 
-			Arity, PredIds) }
-	->
-		{ module_info_stratified_preds(Module0, StratPredIds0) },
-		{ set__insert_list(StratPredIds0, PredIds, StratPredIds) },
-		{ module_info_set_stratified_preds(Module0, StratPredIds, 
-			Module) }
-	;
-		{ string__append_list(
-			["`:- pragma ", PragmaName, "' declaration"],
-			Description) },
-		undefined_pred_or_func_error(Name, Arity, Context,
-			Description),
-		{ module_info_incr_errors(Module0, Module) }
-	).
-
-%-----------------------------------------------------------------------------%
-
 	% add_pred_marker(ModuleInfo0, PragmaName, Name, Arity, Context, 
 	% 	Marker, ConflictMarkers, ModuleInfo, IO0, IO)
 	% Adds Marker to the marker list of the pred(s) with give Name and
 	% Arity, updating the ModuleInfo. If the named pred does not exist,
 	% or the pred already has a marker in ConflictMarkers, report
 	% an error.
-
 :- pred add_pred_marker(module_info, string, sym_name, arity,
 	term__context, marker, list(marker), module_info,
 	io__state, io__state).
@@ -2499,6 +2494,200 @@
 
 %-----------------------------------------------------------------------------%
 
+:- pred module_add_pragma_tabled(eval_method, sym_name, int, 
+		maybe(pred_or_func), maybe(list(mode)), 
+		term__context, module_info, module_info, 
+		io__state, io__state).
+:- mode module_add_pragma_tabled(in, in, in, in, in, in, in, out, 
+	di, uo) is det. 
+	
+module_add_pragma_tabled(EvalMethod, PredName, Arity, MaybePredOrFunc, 
+		MaybeModes,  Context, ModuleInfo0, ModuleInfo) --> 
+	{ module_info_get_predicate_table(ModuleInfo0, PredicateTable0) }, 
+ 	{ eval_method_to_string(EvalMethod, EvalMethodS) },
+		
+	% Find out if we are tabling a predicate or a function 
+	(
+		{ MaybePredOrFunc = yes(PredOrFunc0) }
+	->
+		{ PredOrFunc = PredOrFunc0 },
+
+			% Lookup the pred declaration in the predicate table.
+			% (If it's not there, print an error message and insert
+			% a dummy declaration for the predicate.) 
+		(
+			{ predicate_table_search_pf_sym_arity(PredicateTable0,
+				PredOrFunc, PredName, Arity, [PredId1]) }
+		->
+			{ PredId = PredId1 },
+			{ ModuleInfo1 = ModuleInfo0 }	
+		;
+			{ module_info_name(ModuleInfo0, ModuleName) },
+			{ string__format("pragma (%s)", [s(EvalMethodS)], 
+				Message1) },
+			maybe_undefined_pred_error(PredName, Arity, 
+				PredOrFunc, Context, Message1),
+			{ preds_add_implicit(PredicateTable0,
+				ModuleName, PredName, Arity, Context,
+				PredOrFunc, PredId, PredicateTable1) },
+			{ module_info_set_predicate_table(ModuleInfo0,
+				PredicateTable1, ModuleInfo1) }
+		),
+		module_add_pragma_tabled_2(EvalMethod, PredName, Arity,
+			MaybePredOrFunc, MaybeModes, Context, PredId,
+			ModuleInfo1, ModuleInfo)
+	;
+		(	
+			{ predicate_table_search_sym_arity(PredicateTable0,
+					PredName, Arity, PredIds0) }
+		->
+			{ ModuleInfo1 = ModuleInfo0 },
+			{ PredIds = PredIds0 }
+		;
+			{ module_info_name(ModuleInfo0, ModuleName) },
+			{ string__format("pragma (%s)", [s(EvalMethodS)], 
+				Message1) },
+			maybe_undefined_pred_error(PredName, Arity, 
+				predicate, Context, Message1),
+			{ preds_add_implicit(PredicateTable0,
+				ModuleName, PredName, Arity, Context,
+				predicate, PredId, PredicateTable1) },
+			{ module_info_set_predicate_table(ModuleInfo0,
+				PredicateTable1, ModuleInfo1) },
+			{ PredIds = [PredId] }
+		),
+		
+		list__foldl2(module_add_pragma_tabled_2(EvalMethod, PredName, 
+				Arity, MaybePredOrFunc, MaybeModes, Context), 
+			PredIds, ModuleInfo1, ModuleInfo)
+	).
+
+
+:- pred module_add_pragma_tabled_2(eval_method, sym_name, int, 
+		maybe(pred_or_func), maybe(list(mode)), term__context,
+		pred_id, module_info, module_info, io__state, io__state).
+:- mode module_add_pragma_tabled_2(in, in, in, in, in, in, in, in, out,
+		di, uo) is det.
+
+module_add_pragma_tabled_2(EvalMethod, PredName, Arity0, MaybePredOrFunc, 
+		MaybeModes, Context, PredId, ModuleInfo0, ModuleInfo) -->
+	{ module_info_get_predicate_table(ModuleInfo0, PredicateTable) }, 
+ 	
+	% Find out if we are tabling a predicate or a function 
+	(
+		{ MaybePredOrFunc = yes(PredOrFunc0) }
+	->
+		{ PredOrFunc = PredOrFunc0 }
+	;
+		{ predicate_table_get_preds(PredicateTable, Preds0) },
+		{ map__lookup(Preds0, PredId, PredInfo0) },
+		{ pred_info_get_is_pred_or_func(PredInfo0, PredOrFunc) }
+	),
+	(
+		{ PredOrFunc = predicate },
+		{ Arity = Arity0 }
+	;
+		{ PredOrFunc = function },
+		{ Arity is Arity0 + 1 }
+	),
+		
+		% print out a progress message
+	{ eval_method_to_string(EvalMethod, EvalMethodS) },
+	globals__io_lookup_bool_option(very_verbose, VeryVerbose),
+	( 
+		{ VeryVerbose = yes }
+	->
+		io__write_string("% Processing `:- pragma "),
+		io__write_string(EvalMethodS),
+		io__write_string("' for "),
+		hlds_out__write_call_id(PredOrFunc, PredName/Arity),
+		io__write_string("...\n")
+	;
+		[]
+	),
+		
+		% Lookup the pred_info for this pred,
+	{ predicate_table_get_preds(PredicateTable, Preds1) },
+	{ map__lookup(Preds1, PredId, PredInfo1) },
+	
+	( 
+		{ pred_info_is_imported(PredInfo1) }
+	->
+		{ module_info_incr_errors(ModuleInfo0, ModuleInfo) },
+		prog_out__write_context(Context),
+		io__write_string("Error: `:- pragma "),
+		io__write_string(EvalMethodS),
+		io__write_string("' declaration for imported "),
+		hlds_out__write_call_id(PredOrFunc, PredName/Arity),
+		io__write_string(".\n")
+	;
+		% do we have to make sure the tabled preds are stratified?
+		(
+			{ eval_method_need_stratification(EvalMethod) }
+		->
+			{ module_info_stratified_preds(ModuleInfo0, 
+				StratPredIds0) },
+			{ set__insert(StratPredIds0, PredId, StratPredIds) },
+			{ module_info_set_stratified_preds(ModuleInfo0, 
+				StratPredIds, ModuleInfo1) }
+		;
+			{ ModuleInfo1 = ModuleInfo0 }
+		),
+		
+		% add the eval model to the proc_info for this procedure
+		{ pred_info_procedures(PredInfo1, Procs0) },
+		{ map__to_assoc_list(Procs0, ExistingProcs) },
+		(
+			{ MaybeModes = yes(Modes) }
+		->
+			(
+				{ get_procedure_matching_argmodes(
+					ExistingProcs, Modes, ModuleInfo1, 
+					ProcId) }
+			->
+				{ map__lookup(Procs0, ProcId, ProcInfo0) },
+				{ proc_info_set_eval_method(ProcInfo0, 
+					EvalMethod, ProcInfo) },
+				{ map__det_update(Procs0, ProcId, ProcInfo, 
+					Procs) },
+				{ pred_info_set_procedures(PredInfo1, Procs, 
+					PredInfo) },
+				{ module_info_set_pred_info(ModuleInfo1, 
+					PredId, PredInfo, ModuleInfo) }
+			;
+				{ module_info_incr_errors(ModuleInfo1, 
+					ModuleInfo) }, 
+				prog_out__write_context(Context),
+				io__write_string("Error: `:- pragma "),
+				io__write_string(EvalMethodS),
+				io__write_string(
+				     "' declaration for undeclared mode of "), 
+				hlds_out__write_call_id(PredOrFunc, 
+					PredName/Arity),
+				io__write_string(".\n")
+			)
+		;
+			{ set_eval_method_list(ExistingProcs, 
+				if_valid(EvalMethod), Procs0, Procs) },
+			{ pred_info_set_procedures(PredInfo1, Procs, 
+				PredInfo) },
+			{ module_info_set_pred_info(ModuleInfo1, PredId, 
+				PredInfo, ModuleInfo) }
+		)
+	).
+
+:- pred set_eval_method_list(assoc_list(proc_id, proc_info), eval_method, 
+	proc_table, proc_table).
+:- mode set_eval_method_list(in, in, in, out) is det.
+
+set_eval_method_list([], _, Procs, Procs).
+set_eval_method_list([ProcId - ProcInfo0|Rest], EvalMethod, Procs0, Procs) :-
+	proc_info_set_eval_method(ProcInfo0, EvalMethod, ProcInfo),
+	map__det_update(Procs0, ProcId, ProcInfo, Procs1),
+	set_eval_method_list(Rest, EvalMethod, Procs1, Procs).
+	
+%-----------------------------------------------------------------------------%
+
 	% from the list of pragma_vars extract the modes.
 :- pred pragma_get_modes(list(pragma_var), list(mode)).
 :- mode pragma_get_modes(in, out) is det.
@@ -3315,6 +3504,7 @@
 	transform_goal(Goal0, VarSet0, Subst, Goal, VarSet, Info0, Info),
 	{ goal_info_init(GoalInfo) }.
 
+
 transform_goal_2(if_then_else(Vars0, A0, B0, C0), _, VarSet0, Subst,
 	if_then_else(Vars, A, B, C, Empty) - GoalInfo, VarSet, Info0, Info)
 		-->
@@ -3807,7 +3997,7 @@
 				Modes, Det, HLDS_Goal),
 			Context, MainContext, SubContext, Goal) }
 	;
-	        % handle if-then-else expressions
+		% handle if-then-else expressions
 		{   F = term__atom("else"),
 		    Args = [term__functor(term__atom("if"), [
 				term__functor(term__atom("then"),
Index: compiler/mercury_compile.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/mercury_compile.m,v
retrieving revision 1.76
diff -u -r1.76 mercury_compile.m
--- mercury_compile.m	1998/03/03 17:35:03	1.76
+++ mercury_compile.m	1998/03/05 23:38:28
@@ -32,7 +32,7 @@
 :- import_module handle_options, prog_io, prog_out, modules, module_qual.
 :- import_module equiv_type, make_hlds, typecheck, purity, modes.
 :- import_module switch_detection, cse_detection, det_analysis, unique_modes.
-:- import_module check_typeclass, simplify, intermod, trans_opt.
+:- import_module check_typeclass, simplify, intermod, trans_opt, table_gen.
 :- import_module bytecode_gen, bytecode.
 :- import_module (lambda), polymorphism, termination, higher_order, inlining.
 :- import_module dnf, constraint, unused_args, dead_proc_elim, saved_vars.
@@ -743,10 +743,13 @@
 % :- mode mercury_compile__middle_pass(in, di, uo, di, uo) is det.
 :- mode mercury_compile__middle_pass(in, in, out, di, uo) is det.
 
-mercury_compile__middle_pass(ModuleName, HLDS25, HLDS50) -->
+mercury_compile__middle_pass(ModuleName, HLDS24, HLDS50) -->
 	globals__io_lookup_bool_option(verbose, Verbose),
 	globals__io_lookup_bool_option(statistics, Stats),
 
+	mercury_compile__tabling(HLDS24, Verbose, HLDS25),
+	mercury_compile__maybe_dump_hlds(HLDS25, "25", "tabling"), !,
+
 	mercury_compile__maybe_polymorphism(HLDS25, Verbose, Stats, HLDS26),
 	mercury_compile__maybe_dump_hlds(HLDS26, "26", "polymorphism"), !,
 
@@ -1271,6 +1274,19 @@
 	;
 		{ ModuleInfo = ModuleInfo0 }
 	).
+
+%-----------------------------------------------------------------------------%
+
+:- pred mercury_compile__tabling(module_info, bool,
+	module_info, io__state, io__state).
+:- mode mercury_compile__tabling(in, in, out, di, uo) is det.
+
+mercury_compile__tabling(HLDS0, Verbose, HLDS) -->
+	maybe_write_string(Verbose,
+		"% Transforming tabled predicates..."),
+	maybe_flush_output(Verbose),
+	{ table_gen__process_module(HLDS0, HLDS) },
+	maybe_write_string(Verbose, " done.\n").
 
 %-----------------------------------------------------------------------------%
 
Index: compiler/mercury_to_mercury.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/mercury_to_mercury.m,v
retrieving revision 1.133
diff -u -r1.133 mercury_to_mercury.m
--- mercury_to_mercury.m	1998/03/03 17:35:08	1.133
+++ mercury_to_mercury.m	1998/03/05 02:04:33
@@ -303,8 +303,9 @@
 		{ Pragma = obsolete(Pred, Arity) },
 		mercury_output_pragma_decl(Pred, Arity, predicate, "obsolete")
 	;
-		{ Pragma = memo(Pred, Arity) },
-		mercury_output_pragma_decl(Pred, Arity, predicate, "memo")
+		{ Pragma = tabled(Type, Pred, Arity, _PredOrFunc, _Mode) },
+		{ eval_method_to_string(Type, TypeS) },
+		mercury_output_pragma_decl(Pred, Arity, predicate, TypeS)
 	;
 		{ Pragma = inline(Pred, Arity) },
 		mercury_output_pragma_decl(Pred, Arity, predicate, "inline")
Index: compiler/modes.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/modes.m,v
retrieving revision 1.221
diff -u -r1.221 modes.m
--- modes.m	1998/03/03 17:35:23	1.221
+++ modes.m	1998/03/13 00:33:04
@@ -335,16 +335,19 @@
 	globals__io_lookup_int_option(mode_inference_iteration_limit,
 		MaxIterations),
 	modecheck_to_fixpoint(PredIds, MaxIterations, WhatToCheck, ModuleInfo0,
-					ModuleInfo, UnsafeToContinue),
+					ModuleInfo1, UnsafeToContinue),
 	( { WhatToCheck = check_unique_modes },
-		write_mode_inference_messages(PredIds, yes, ModuleInfo)
+		write_mode_inference_messages(PredIds, yes, ModuleInfo1),
+		{ ModuleInfo2 = ModuleInfo1 }
 	; { WhatToCheck = check_modes },
 		( { UnsafeToContinue = yes } ->
-			write_mode_inference_messages(PredIds, no, ModuleInfo)
+			write_mode_inference_messages(PredIds, no, ModuleInfo1)
 		;
 			[]
-		)
-	).
+		),
+		check_eval_methods(ModuleInfo1, ModuleInfo2)
+	),
+	{ ModuleInfo = ModuleInfo2 }.
 
 	% Iterate over the list of pred_ids in a module.
 
@@ -1805,6 +1808,91 @@
 		% XXX could do better; it's not really explicit
 mode_context_to_unify_context(uninitialized, _, _) :-
 	error("mode_context_to_unify_context: uninitialized context").
+
+%-----------------------------------------------------------------------------%
+%-----------------------------------------------------------------------------%
+
+:- pred check_eval_methods(module_info, module_info, io__state, io__state).
+:- mode check_eval_methods(in, out, di, uo) is det.
+
+check_eval_methods(ModuleInfo0, ModuleInfo) -->
+	{ module_info_predids(ModuleInfo0, PredIds) },
+	pred_check_eval_methods(PredIds, ModuleInfo0, ModuleInfo).
+
+:- pred pred_check_eval_methods(list(pred_id), module_info, module_info,
+		io__state, io__state).
+:- mode pred_check_eval_methods(in, in, out, di, uo) is det.
+
+pred_check_eval_methods([], M, M) --> [].
+pred_check_eval_methods([PredId|Rest], ModuleInfo0, ModuleInfo) --> 
+	{ module_info_preds(ModuleInfo0, Preds) },
+	{ map__lookup(Preds, PredId, PredInfo) },
+	{ pred_info_procids(PredInfo, ProcIds) },
+	proc_check_eval_methods(ProcIds, PredId, ModuleInfo0, ModuleInfo1),
+	pred_check_eval_methods(Rest, ModuleInfo1, ModuleInfo).	
+
+:- pred proc_check_eval_methods(list(proc_id), pred_id, module_info, 
+		module_info, io__state, io__state).
+:- mode proc_check_eval_methods(in, in, in, out, di, uo) is det.
+
+proc_check_eval_methods([], _, M, M) --> [].
+proc_check_eval_methods([ProcId|Rest], PredId, ModuleInfo0, ModuleInfo) --> 
+	{ module_info_pred_proc_info(ModuleInfo0, PredId, ProcId, 
+		_, ProcInfo) },
+	{ proc_info_eval_method(ProcInfo, EvalMethod) },
+	( { EvalMethod \= eval_normal } ->
+		{ proc_info_argmodes(ProcInfo, Modes) },
+		( 
+			\+ { only_fully_in_out_nonunique_modes(Modes, 
+				ModuleInfo0) } 
+		->
+			{ proc_info_context(ProcInfo, Context) },
+			prog_out__write_context(Context),
+			{ eval_method_to_string(EvalMethod, EvalMethodS) },
+			io__write_string("Error : `pragma "),
+			io__write_string(EvalMethodS),
+			io__write_string(
+"' declaration not allowed for procedure with\n"),
+			prog_out__write_context(Context),
+			io__write_string(
+"unique/partially instantiated modes.\n"), 
+			globals__io_lookup_bool_option(verbose_errors, 
+				VerboseErrors),
+			( { VerboseErrors = yes } ->
+				io__write_string(
+"	Tabling of predicates/functions with unique modes is not allowed
+	as this would lead to a copying of the unique arguments which 
+	would result in them no longer being unique.
+	Tabling of predicates/functions with partially instantiated modes
+	is not currently implemented.\n")
+			;
+				[]
+			),
+			{ module_info_incr_errors(ModuleInfo0, ModuleInfo1) }
+		;
+			{ ModuleInfo1 = ModuleInfo0 }	
+		)
+	;
+		{ ModuleInfo1 = ModuleInfo0 }	
+		
+	),
+	proc_check_eval_methods(Rest, PredId, ModuleInfo1, ModuleInfo).
+
+:- pred only_fully_in_out_nonunique_modes(list(mode), module_info).
+:- mode only_fully_in_out_nonunique_modes(in, in) is semidet.
+
+only_fully_in_out_nonunique_modes([], _).
+only_fully_in_out_nonunique_modes([Mode|Rest], ModuleInfo) :-
+	mode_get_insts(ModuleInfo, Mode, InitialInst, FinalInst),
+	inst_is_not_partly_unique(ModuleInfo, InitialInst),
+	inst_is_not_partly_unique(ModuleInfo, FinalInst),
+	(
+		inst_is_ground(ModuleInfo, InitialInst)	
+	;
+		inst_is_free(ModuleInfo, InitialInst),
+		inst_is_ground(ModuleInfo, FinalInst)
+	),
+	only_fully_in_out_nonunique_modes(Rest, ModuleInfo).
 
 %-----------------------------------------------------------------------------%
 %-----------------------------------------------------------------------------%
Index: compiler/module_qual.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/module_qual.m,v
retrieving revision 1.33
diff -u -r1.33 module_qual.m
--- module_qual.m	1998/03/11 19:55:28	1.33
+++ module_qual.m	1998/03/12 01:39:39
@@ -654,7 +654,17 @@
 		c_code(Rec, SymName, PredOrFunc, PragmaVars, Varset, CCode), 
 		Info0, Info) -->
 	qualify_pragma_vars(PragmaVars0, PragmaVars, Info0, Info).
-qualify_pragma(memo(A, B), memo(A, B), Info, Info) --> [].
+qualify_pragma(tabled(A, B, C, D, MModes0), tabled(A, B, C, D, MModes), 
+	Info0, Info) --> 
+	(
+		{ MModes0 = yes(Modes0) }
+	->
+		qualify_mode_list(Modes0, Modes, Info0, Info),
+		{ MModes = yes(Modes) }
+	;
+		{ Info = Info0 },
+		{ MModes = no }
+	).
 qualify_pragma(inline(A, B), inline(A, B), Info, Info) --> [].
 qualify_pragma(no_inline(A, B), no_inline(A, B), Info, Info) --> [].
 qualify_pragma(obsolete(A, B), obsolete(A, B), Info, Info) --> [].
Index: compiler/modules.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/modules.m,v
retrieving revision 1.61
diff -u -r1.61 modules.m
--- modules.m	1998/03/06 09:05:12	1.61
+++ modules.m	1998/03/09 01:20:35
@@ -541,7 +541,6 @@
 pragma_allowed_in_interface(c_header_code(_), no).
 pragma_allowed_in_interface(c_code(_), no).
 pragma_allowed_in_interface(c_code(_, _, _, _, _, _), no).
-pragma_allowed_in_interface(memo(_, _), no).
 pragma_allowed_in_interface(inline(_, _), no).
 pragma_allowed_in_interface(no_inline(_, _), no).
 pragma_allowed_in_interface(obsolete(_, _), yes).
@@ -550,6 +549,7 @@
 pragma_allowed_in_interface(source_file(_), yes).
 	% yes, but the parser will strip out `source_file' pragmas anyway...
 pragma_allowed_in_interface(fact_table(_, _, _), no).
+pragma_allowed_in_interface(tabled(_, _, _, _, _), no).
 pragma_allowed_in_interface(promise_pure(_, _), no).
 pragma_allowed_in_interface(unused_args(_, _, _, _, _), no).
 pragma_allowed_in_interface(termination_info(_, _, _, _, _), yes).
Index: compiler/prog_data.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/prog_data.m,v
retrieving revision 1.32
diff -u -r1.32 prog_data.m
--- prog_data.m	1998/03/03 17:35:40	1.32
+++ prog_data.m	1998/03/05 02:04:41
@@ -104,9 +104,6 @@
 			% PredName, Predicate or Function, Vars/Mode, 
 			% VarNames, C Code Implementation Info
 
-	;	memo(sym_name, arity)
-			% Predname, Arity
-
 	;	inline(sym_name, arity)
 			% Predname, Arity
 
@@ -140,6 +137,10 @@
 	;	fact_table(sym_name, arity, string)
 			% Predname, Arity, Fact file name.
 
+	;	tabled(eval_method, sym_name, int, maybe(pred_or_func), 
+				maybe(list(mode)))
+			% Tabling type, Predname, Arity, PredOrFunc?, Mode?
+	
 	;	promise_pure(sym_name, arity)
 			% Predname, Arity
 
@@ -155,6 +156,7 @@
 			% This includes c_code, and imported predicates.
 			% termination_info pragmas are used in opt and
 			% trans_opt files.
+
 
 	;	terminates(sym_name, arity)
 			% Predname, Arity
Index: compiler/prog_io_pragma.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/prog_io_pragma.m,v
retrieving revision 1.13
diff -u -r1.13 prog_io_pragma.m
--- prog_io_pragma.m	1998/03/03 17:35:47	1.13
+++ prog_io_pragma.m	1998/03/13 00:58:30
@@ -431,9 +431,15 @@
 
 parse_pragma_type(ModuleName, "memo", PragmaTerms,
 			ErrorTerm, _VarSet, Result) :-
-	parse_simple_pragma(ModuleName, "memo",
-		lambda([Name::in, Arity::in, Pragma::out] is det,
-			Pragma = memo(Name, Arity)),
+	parse_tabling_pragma(ModuleName, "memo", eval_memo, 
+		PragmaTerms, ErrorTerm, Result).
+parse_pragma_type(ModuleName, "loop_check", PragmaTerms,
+			ErrorTerm, _VarSet, Result) :-
+	parse_tabling_pragma(ModuleName, "loop_check", eval_loop_check, 
+		PragmaTerms, ErrorTerm, Result).
+parse_pragma_type(ModuleName, "minimal_model", PragmaTerms,
+			ErrorTerm, _VarSet, Result) :-
+	parse_tabling_pragma(ModuleName, "minimal_model", eval_minimal, 
 		PragmaTerms, ErrorTerm, Result).
 
 parse_pragma_type(ModuleName, "obsolete", PragmaTerms,
@@ -778,6 +784,99 @@
 		PragmaVars = [],	% return any old junk in PragmaVars
 		Error = yes("arguments not in form 'Var :: mode'")
 	).
+
+
+:- pred parse_tabling_pragma(module_name, string, eval_method, list(term), 
+		term, maybe1(item)).
+:- mode parse_tabling_pragma(in, in, in, in, in, out) is det.
+
+parse_tabling_pragma(ModuleName, PragmaName, TablingType, PragmaTerms, 
+		ErrorTerm, Result) :-
+    (
+        PragmaTerms = [PredAndModesTerm0]
+    ->
+        (
+                % Is this a simple pred/arity pragma
+            PredAndModesTerm0 = term__functor(term__atom("/"),
+                [PredNameTerm, ArityTerm], _)
+        ->
+            (
+                parse_implicitly_qualified_term(ModuleName, PredNameTerm, 
+                    PredAndModesTerm0, "", ok(PredName, [])),
+                ArityTerm = term__functor(term__integer(Arity), [], _)
+            ->
+                Result = ok(pragma(tabled(TablingType, PredName, Arity, 
+		    no, no)))    
+            ;
+                string__append_list(
+                    ["expected predname/arity for `pragma ",
+                    PragmaName, "(...)' declaration"], ErrorMsg),
+                Result = error(ErrorMsg, PredAndModesTerm0)
+            )
+        ;
+                % Is this a specific mode pragma
+            PredAndModesTerm0 = term__functor(Const, Terms0, _)
+        ->
+            (
+                % is this a function or a predicate?
+                Const = term__atom("="),
+                Terms0 = [FuncAndModesTerm, FuncResultTerm0]
+            ->
+                % function
+                PredOrFunc = function,
+                PredAndModesTerm = FuncAndModesTerm,
+                FuncResultTerms = [ FuncResultTerm0 ]
+            ;
+                % predicate
+                PredOrFunc = predicate,
+                PredAndModesTerm = PredAndModesTerm0,
+                FuncResultTerms = []
+            ),
+            string__append_list(["`pragma ", PragmaName, "(...)' declaration"],
+	    	ParseMsg), 
+	    parse_qualified_term(PredAndModesTerm, PredAndModesTerm0, 
+                ParseMsg, PredNameResult),
+            (
+                PredNameResult = ok(PredName, ModeList0),
+                (
+                    PredOrFunc = predicate,
+                    ModeList = ModeList0
+                ;
+                    PredOrFunc = function,
+                    list__append(ModeList0, FuncResultTerms, ModeList)
+                ),
+                (
+                    convert_mode_list(ModeList, Modes)
+                ->
+                    list__length(Modes, Arity0),
+                    (
+                        PredOrFunc = function
+                    ->
+                        Arity is Arity0 - 1
+                    ;
+                       Arity = Arity0
+                    ),
+                    Result = ok(pragma(tabled(TablingType, PredName, Arity, 
+                        yes(PredOrFunc), yes(Modes))))
+                ;
+                    string__append_list(["syntax error in pragma '", 
+		        PragmaName, "(...)' declaration"],ErrorMessage),
+                    Result = error(ErrorMessage, PredAndModesTerm)
+                )
+            ;
+                PredNameResult = error(Msg, Term),
+                Result = error(Msg, Term)
+            )
+        ;
+            string__append_list(["unexpected variable in `pragma ", PragmaName,
+                "'"], ErrorMessage),
+            Result = error(ErrorMessage, PredAndModesTerm0)
+        )
+    ;
+    	string__append_list(["wrong number of arguments in `pragma ", 
+            PragmaName, "(...)' declaration"], ErrorMessage),
+        Result = error(ErrorMessage, ErrorTerm)
+    ).
 
 :- pred convert_int_list(term::in, maybe1(list(int))::out) is det.
 
Index: compiler/simplify.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/simplify.m,v
retrieving revision 1.55
diff -u -r1.55 simplify.m
--- simplify.m	1998/03/03 17:35:58	1.55
+++ simplify.m	1998/03/12 06:38:00
@@ -433,14 +433,15 @@
 
 simplify__goal_2(Goal0, GoalInfo0, Goal, GoalInfo, Info0, Info) :-
 	Goal0 = call(PredId, ProcId, Args, IsBuiltin, _, _),
+	simplify_info_get_module_info(Info0, ModuleInfo),
+	module_info_pred_proc_info(ModuleInfo, PredId, ProcId, PredInfo,
+		ProcInfo),
 
 	%
 	% check for calls to predicates with `pragma obsolete' declarations
 	%
 	(
 		simplify_do_warn(Info0),
-		simplify_info_get_module_info(Info0, ModuleInfo),
-		module_info_pred_info(ModuleInfo, PredId, PredInfo),
 		pred_info_get_markers(PredInfo, Markers),
 		check_marker(Markers, obsolete),
 		%
@@ -502,8 +503,13 @@
 		proc_info_argmodes(ProcInfo1, ArgModes),
 		simplify_info_get_common_info(Info1, CommonInfo1),
 		simplify__input_args_are_equiv(Args, HeadVars, ArgModes,
-			CommonInfo1, ModuleInfo1)
-	->
+			CommonInfo1, ModuleInfo1),
+
+		% 
+		% Dont count procs using minimal evaluation
+		%
+		\+ proc_info_eval_method(ProcInfo, eval_minimal)	
+	->	
 		goal_info_get_context(GoalInfo0, Context2),
 		simplify_info_add_msg(Info1, warn_infinite_recursion(Context2),
 				Info2)
Index: compiler/stratify.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/stratify.m,v
retrieving revision 1.15
diff -u -r1.15 stratify.m
--- stratify.m	1998/02/12 01:17:48	1.15
+++ stratify.m	1998/03/05 23:49:16
@@ -299,14 +299,7 @@
 	{ PredProcId = proc(PredId, ProcId) },
 	{ module_info_pred_info(Module0, PredId, PredInfo) },
 	globals__io_lookup_bool_option(warn_non_stratification, Warn),
-	{ pred_info_get_markers(PredInfo, Markers) },
-	( 	
-		{ check_marker(Markers, memo) }
-	->
-		{ Error = yes }
-	;
-		{ Error = no }
-	),
+	{ Error = no },
 	(	( { Error = yes ; Warn = yes } ),
 		{ map__search(HOInfo, PredProcId, HigherOrderInfo) }
 	->
Index: compiler/switch_detection.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/switch_detection.m,v
retrieving revision 1.80
diff -u -r1.80 switch_detection.m
--- switch_detection.m	1998/02/12 01:17:49	1.80
+++ switch_detection.m	1998/02/19 00:51:48
@@ -538,8 +538,10 @@
 :- mode fix_case_list(in, in, out) is det.
 
 fix_case_list([], _, []).
-fix_case_list([Functor - DisjList | Cases0], GoalInfo,
+fix_case_list([Functor - DisjList0 | Cases0], GoalInfo,
 		[case(Functor, Goal) | Cases]) :-
+		% We need to put the list back the right way around.
+	list__reverse(DisjList0, DisjList),
 	disj_list_to_goal(DisjList, GoalInfo, Goal),
 	fix_case_list(Cases0, GoalInfo, Cases).
 
Index: compiler/notes/compiler_design.html
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/notes/compiler_design.html,v
retrieving revision 1.17
diff -u -r1.17 compiler_design.html
--- compiler_design.html	1998/01/10 09:14:51	1.17
+++ compiler_design.html	1998/03/12 06:34:25
@@ -353,7 +353,13 @@
 
 <p>
 
-The first two passes of this stage are code simplifications.
+The first pass of this stage does tabling transformations (table_gen.m). 
+This involves the insertion of several calls to tabling predicates 
+defined in mercury_builtin.m and the addition of some scaffolding structure.
+
+<p>
+
+The next two passes of this stage are code simplifications.
 
 <ul>
 <li> introduction of type_info arguments for polymorphic predicates, 
@@ -374,7 +380,7 @@
 
 <p>
   
-To improve efficiency, the above two passes are actually combined into
+To improve efficiency, the above two passes are actually combined into 
 one - polymorphism.m calls calls lambda__transform_lambda directly.
 
 <p>
Index: doc/reference_manual.texi
===================================================================
RCS file: /home/staff/zs/imp/mercury/doc/reference_manual.texi,v
retrieving revision 1.88
diff -u -r1.88 reference_manual.texi
--- reference_manual.texi	1998/03/09 09:11:52	1.88
+++ reference_manual.texi	1998/03/11 05:39:18
@@ -1185,7 +1185,7 @@
 are as follows:
 
 @example
-:- func length(list(T) = int.
+:- func length(list(T)) = int.
 :- mode length(in_listskel) = out.
 :- mode length(out_listskel) = in.





More information about the developers mailing list