[m-dev.] for review: bootstrap without backwards compatibility

Zoltan Somogyi zs at cs.mu.OZ.AU
Tue Sep 21 13:22:42 AEST 1999


This boring diff is for any masochist out there to review.

I would like to ask everyone to include -DMR_NO_BACKWARDS_COMPAT
in EXTRA_CFLAGS in their Mmake.stage.param file so that we can avoid the
introduction of new code that requires backward compatibility.

After this change is installed on all systems, we can delete the
MR_NO_BACKWARDS_COMPAT flag and the backwards compatibility code itself.

--------------------------------------------------

Make the entire Mercury system bootstrap without backwards compatbility.

compiler/llds_out.m:
compiler/pragma_c_gen.m:
	Add MR_ prefixes on generated code.

library/builtin.m:
library/exception.m:
library/private_builtin.m:
library/std_util.m:
library/store.m:
	Add MR_ prefixes.

runtime/mercury_deep_copy_body.h:
runtime/mercury_heap.h:
runtime/mercury_stacks.h:
runtime/mercury_string.h:
runtime/mercury_tags.h:
runtime/mercury_type_info.h:
	Add MR_ prefixes.

runtime/mercury_bootstrap.c;
runtime/mercury_engine.c;
runtime/mercury_ho_call.c;
runtime/mercury_tabling.c;
runtime/mercury_trace_base.c;
runtime/mercury_type_info.c;
runtime/mercury_wrapper.c;
	Add MR_ prefixes. In some cases, fix indentation; in functions using
	four-space indentation, convert all tabs to spaces.

trace/mercury_trace_browse.m:
trace/mercury_trace_declarative.m:
trace/mercury_trace_external.m:
trace/mercury_trace_help.m:
	Add MR_ prefixes.

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 browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/llds_out.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/llds_out.m,v
retrieving revision 1.123
diff -u -b -r1.123 llds_out.m
--- llds_out.m	1999/09/20 08:16:50	1.123
+++ llds_out.m	1999/09/21 00:18:32
@@ -3697,7 +3697,7 @@
 output_static_rval(binop(_, _, _)) -->
 	{ error("Cannot output a binop(_, _, _) in a static initializer") }.
 output_static_rval(mkword(Tag, Exprn)) -->
-	io__write_string("(Word *) mkword("),
+	io__write_string("(Word *) MR_mkword("),
 	output_tag(Tag),
 	io__write_string(", "),
 	output_static_rval(Exprn),
@@ -3707,7 +3707,7 @@
 output_static_rval(create(Tag, _Args, _ArgTypes, _StatDyn, CellNum, _Msg)) -->
 		% emit a reference to the static constant which we
 		% declared in output_rval_decls.
-	io__write_string("mkword(mktag("),
+	io__write_string("MR_mkword(MR_mktag("),
 	io__write_int(Tag),
 	io__write_string("), "),
 	io__write_string("&mercury_const_"),
Index: compiler/pragma_c_gen.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/pragma_c_gen.m,v
retrieving revision 1.28
diff -u -b -r1.28 pragma_c_gen.m
--- pragma_c_gen.m	1999/03/28 01:27:21	1.28
+++ pragma_c_gen.m	1999/09/20 09:34:00
@@ -600,19 +600,19 @@
 	},
 
 	{
-	Succeed	 = "\tsucceed();\n",
-	SucceedDiscard = "\tsucceed_discard();\n",
+	Succeed	 = "\tMR_succeed();\n",
+	SucceedDiscard = "\tMR_succeed_discard();\n",
 
 	CallDef1 = "#define\tSUCCEED     \tgoto MR_call_success\n",
 	CallDef2 = "#define\tSUCCEED_LAST\tgoto MR_call_success_last\n",
-	CallDef3 = "#define\tFAIL\tfail()\n",
+	CallDef3 = "#define\tFAIL\tMR_fail()\n",
 
 	CallSuccessLabel     = "MR_call_success:\n",
 	CallLastSuccessLabel = "MR_call_success_last:\n",
 
 	RetryDef1 = "#define\tSUCCEED     \tgoto MR_retry_success\n",
 	RetryDef2 = "#define\tSUCCEED_LAST\tgoto MR_retry_success_last\n",
-	RetryDef3 = "#define\tFAIL\tfail()\n",
+	RetryDef3 = "#define\tFAIL\tMR_fail()\n",
 
 	RetrySuccessLabel     = "MR_retry_success:\n",
 	RetryLastSuccessLabel = "MR_retry_success_last:\n",
@@ -728,7 +728,7 @@
 
 		SharedDef1 = "#define\tSUCCEED     \tgoto MR_shared_success\n",
 		SharedDef2 = "#define\tSUCCEED_LAST\tgoto MR_shared_success_last\n",
-		SharedDef3 = "#define\tFAIL\tfail()\n",
+		SharedDef3 = "#define\tFAIL\tMR_fail()\n",
 
 		SharedSuccessLabel     = "MR_shared_success:\n",
 		SharedLastSuccessLabel = "MR_shared_success_last:\n",
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/aditi
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/dynamic_linking
cvs diff: Diffing extras/graphics
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/graphics/samples/pent
cvs diff: Diffing extras/lazy_evaluation
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing library
Index: library/array.m
===================================================================
RCS file: /home/mercury1/repository/mercury/library/array.m,v
retrieving revision 1.58
diff -u -b -r1.58 array.m
--- array.m	1999/08/12 09:58:44	1.58
+++ array.m	1999/09/17 09:38:39
@@ -299,7 +299,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_array__type_ctor_layout_array_1 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_ARRAY_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_ARRAY_VALUE))
 };
 
 MR_MODULE_STATIC_OR_EXTERN
Index: library/builtin.m
===================================================================
RCS file: /home/mercury1/repository/mercury/library/builtin.m,v
retrieving revision 1.19
diff -u -b -r1.19 builtin.m
--- builtin.m	1999/08/12 09:58:45	1.19
+++ builtin.m	1999/09/17 09:42:34
@@ -251,7 +251,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_int_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_INT_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_INT_VALUE))
 };
 
 	/* type_ctor_layout for `character' */
@@ -261,7 +261,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_character_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_CHARACTER_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_CHARACTER_VALUE))
 };
 
 	/* type_ctor_layout for `string' */
@@ -271,7 +271,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_string_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_STRING_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_STRING_VALUE))
 };
 
 	/* type_ctor_layout for `float' */
@@ -281,7 +281,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_float_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_FLOAT_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_FLOAT_VALUE))
 };
 
 	/* type_ctor_layout for `void' */
@@ -291,7 +291,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_void_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_VOID_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_VOID_VALUE))
 };
 
 #ifdef	NATIVE_GC
@@ -303,7 +303,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_succip_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_SUCCIP_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_SUCCIP_VALUE))
 };
 
 	/* type_ctor_layout for `hp' (only used by accurate gc) */
@@ -313,7 +313,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_hp_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_HP_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_HP_VALUE))
 };
 
 	/* type_ctor_layout for `curfr' (only used by accurate gc) */
@@ -323,7 +323,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_curfr_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_CURFR_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_CURFR_VALUE))
 };
 
 	/* type_ctor_layout for `maxfr' (only used by accurate gc) */
@@ -333,7 +333,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_maxfr_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_MAXFR_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_MAXFR_VALUE))
 };
 
 	/* type_ctor_layout for `redofr' (only used by accurate gc) */
@@ -343,7 +343,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_redofr_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_REDOFR_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_REDOFR_VALUE))
 };
 
 	/* type_ctor_layout for `redoip' (only used by accurate gc) */
@@ -353,7 +353,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_redoip_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_REDOIP_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_REDOIP_VALUE))
 };
 
 #endif /* NATIVE_GC */
@@ -786,7 +786,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_builtin__type_ctor_layout_c_pointer_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_C_POINTER_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_C_POINTER_VALUE))
 };
 
 MR_MODULE_STATIC_OR_EXTERN
Index: library/exception.m
===================================================================
RCS file: /home/mercury1/repository/mercury/library/exception.m,v
retrieving revision 1.4
diff -u -b -r1.4 exception.m
--- exception.m	1999/09/20 15:02:38	1.4
+++ exception.m	1999/09/21 00:19:02
@@ -691,7 +691,7 @@
 #ifdef MR_USE_TRAIL
 	MR_discard_ticket();
 #endif
-	succeed_discard();
+	MR_succeed_discard();
 
 /*
 ** builtin_catch(Goal, Handler, Result)
@@ -742,7 +742,7 @@
 #ifdef MR_USE_TRAIL
 	MR_discard_ticket();
 #endif
-	succeed_discard();
+	MR_succeed_discard();
 
 /*
 ** builtin_catch(Goal, Handler, Result)
@@ -795,15 +795,15 @@
 	**
 	** Note that we need to keep the trail ticket still,
 	** in case it is needed again on backtracking.
-	** We can only discard it when we fail() out, or
+	** We can only discard it when we MR_fail() out, or
 	** (if an exception is thrown) in the throw.
 	*/
-	succeed();
+	MR_succeed();
 
 #ifdef MR_USE_TRAIL
 Define_label(mercury__exception__builtin_catch_3_5_i3);
 	MR_discard_ticket();
-	fail();
+	MR_fail();
 #endif
 
 /*
@@ -1045,7 +1045,7 @@
 		tailcall(ENTRY(do_call_det_closure), 
 			ENTRY(mercury__exception__builtin_throw_1_0));
 	}
-	incr_sp_push_msg(1, ""builtin_throw/1"");
+	MR_incr_sp_push_msg(1, ""builtin_throw/1"");
 	MR_stackvar(1) = (Word) MR_succip;
 	call(ENTRY(do_call_det_closure), 
 		LABEL(mercury__exception__builtin_throw_1_0_i1),
@@ -1057,7 +1057,7 @@
 	r2 = r1;
 	r1 = TRUE;
 	MR_succip = (Code *) MR_stackvar(1);
-	decr_sp_pop_msg(1);
+	MR_decr_sp_pop_msg(1);
 	proceed(); /* return to the caller of `builtin_catch' */
 
 END_MODULE
Index: library/private_builtin.m
===================================================================
RCS file: /home/mercury1/repository/mercury/library/private_builtin.m,v
retrieving revision 1.28
diff -u -b -r1.28 private_builtin.m
--- private_builtin.m	1999/08/12 09:58:45	1.28
+++ private_builtin.m	1999/09/17 09:42:52
@@ -341,7 +341,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_private_builtin__type_ctor_layout_type_info_1 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG,
-		mkbody(MR_TYPE_CTOR_LAYOUT_TYPEINFO_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_TYPEINFO_VALUE))
 };
 
 const struct mercury_data_private_builtin__type_ctor_functors_type_info_1_struct {
@@ -402,7 +402,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_private_builtin__type_ctor_layout_typeclass_info_1 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_TYPECLASSINFO_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_TYPECLASSINFO_VALUE))
 };
 
 const struct mercury_data_private_builtin__type_ctor_functors_typeclass_info_1_struct {
Index: library/std_util.m
===================================================================
RCS file: /home/mercury1/repository/mercury/library/std_util.m,v
retrieving revision 1.155
diff -u -b -r1.155 std_util.m
--- std_util.m	1999/09/17 06:40:32	1.155
+++ std_util.m	1999/09/21 02:53:40
@@ -678,7 +678,7 @@
 	** each solution, and for copying the collection back to the heap
 	** when we're done.
 	*/
-	mkframe(""builtin_aggregate"", num_framevars,
+	MR_mkframe(""builtin_aggregate"", num_framevars,
 		LABEL(mercury__std_util__builtin_aggregate_4_0_i3));
  
 	/* save heap states */
@@ -754,7 +754,7 @@
 	swap_heap_and_solutions_heap();
  
 	/* look for the next solution */
-	redo();
+	MR_redo();
 	
 Define_label(mercury__std_util__builtin_aggregate_4_0_i3);
 	update_prof_current_proc(
@@ -796,7 +796,7 @@
  	MR_sol_hp = (Word *) saved_solhp_fv;
  	
 	/* discard the frame we made */
-	succeed_discard();
+	MR_succeed_discard();
 }
 
 #undef num_framevars
@@ -832,7 +832,7 @@
 
 	/* create a nondet stack frame with two slots, to hold the collector
 	   pred and the collection, and set the failure continuation */
-	mkframe(""builtin_aggregate"", num_framevars,
+	MR_mkframe(""builtin_aggregate"", num_framevars,
 		LABEL(mercury__std_util__builtin_aggregate_4_0_i3));
 
 #ifdef MR_USE_TRAIL
@@ -886,7 +886,7 @@
 	sofar_fv = r1;
 
 	/* look for the next solution */
- 	redo();
+ 	MR_redo();
  
 Define_label(mercury__std_util__builtin_aggregate_4_0_i3);
 	update_prof_current_proc(
@@ -905,7 +905,7 @@
 
 	/* return the collection and discard the frame we made */
 	r1 = sofar_fv;
- 	succeed_discard();
+ 	MR_succeed_discard();
  
 #undef num_framevars
 #undef collector_pred_fv
@@ -1004,8 +1004,8 @@
 	).
 
 :- pragma c_code(univ_value(Univ::in) = (Value::out), will_not_call_mercury, "
-	TypeInfo_for_T = field(mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO);
-	Value = field(mktag(0), Univ, UNIV_OFFSET_FOR_DATA);
+	TypeInfo_for_T = MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO);
+	Value = MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_DATA);
 ").
 
 :- pragma c_header_code("
@@ -1033,13 +1033,15 @@
 	% in the second field.
 :- pragma c_code(type_to_univ(Type::di, Univ::uo), will_not_call_mercury, "
 	incr_hp(Univ, 2);
-	field(mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO) = (Word) TypeInfo_for_T;
-	field(mktag(0), Univ, UNIV_OFFSET_FOR_DATA) = (Word) Type;
+	MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO) =
+		(Word) TypeInfo_for_T;
+	MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_DATA) = (Word) Type;
 ").
 :- pragma c_code(type_to_univ(Type::in, Univ::out), will_not_call_mercury, "
 	incr_hp(Univ, 2);
-	field(mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO) = (Word) TypeInfo_for_T;
-	field(mktag(0), Univ, UNIV_OFFSET_FOR_DATA) = (Word) Type;
+	MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO) =
+		(Word) TypeInfo_for_T;
+	MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_DATA) = (Word) Type;
 ").
 
 	% Backward mode - convert from univ to type.
@@ -1050,12 +1052,12 @@
 	Word	univ_type_info;
 	int	comp;
 
-	univ_type_info = field(mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO);
+	univ_type_info = MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO);
 	save_transient_registers();
 	comp = MR_compare_type_info(univ_type_info, TypeInfo_for_T);
 	restore_transient_registers();
 	if (comp == COMPARE_EQUAL) {
-		Type = field(mktag(0), Univ, UNIV_OFFSET_FOR_DATA);
+		Type = MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_DATA);
 		SUCCESS_INDICATOR = TRUE;
 	} else {
 		SUCCESS_INDICATOR = FALSE;
@@ -1063,7 +1065,7 @@
 }").
 
 :- pragma c_code(univ_type(Univ::in) = (TypeInfo::out), will_not_call_mercury, "
-	TypeInfo = field(mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO);
+	TypeInfo = MR_field(MR_mktag(0), Univ, UNIV_OFFSET_FOR_TYPEINFO);
 ").
 
 :- pragma c_code("
@@ -1105,7 +1107,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_std_util__type_ctor_layout_univ_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_UNIV_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_UNIV_VALUE))
 };
 
 MR_MODULE_STATIC_OR_EXTERN
@@ -1121,7 +1123,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_std_util__type_ctor_layout_type_info_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_TYPEINFO_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_TYPEINFO_VALUE))
 };
 
 MR_MODULE_STATIC_OR_EXTERN
@@ -1172,8 +1174,8 @@
 	univ2 = r2;
 
 	/* First check the type_infos compare equal */
-	typeinfo1 = field(mktag(0), univ1, UNIV_OFFSET_FOR_TYPEINFO);
-	typeinfo2 = field(mktag(0), univ2, UNIV_OFFSET_FOR_TYPEINFO);
+	typeinfo1 = MR_field(MR_mktag(0), univ1, UNIV_OFFSET_FOR_TYPEINFO);
+	typeinfo2 = MR_field(MR_mktag(0), univ2, UNIV_OFFSET_FOR_TYPEINFO);
 	save_transient_registers();
 	comp = MR_compare_type_info(typeinfo1, typeinfo2);
 	restore_transient_registers();
@@ -1187,8 +1189,8 @@
 	** unwrapped args
 	*/
 	r1 = typeinfo1;
-	r2 = field(mktag(0), univ1, UNIV_OFFSET_FOR_DATA);
-	r3 = field(mktag(0), univ2, UNIV_OFFSET_FOR_DATA);
+	r2 = MR_field(MR_mktag(0), univ1, UNIV_OFFSET_FOR_DATA);
+	r3 = MR_field(MR_mktag(0), univ2, UNIV_OFFSET_FOR_DATA);
 	{
 		Declare_entry(mercury__unify_2_0);
 		tailcall(ENTRY(mercury__unify_2_0),
@@ -1217,8 +1219,8 @@
 	univ2 = r2;
 
 	/* First compare the type_infos */
-	typeinfo1 = field(mktag(0), univ1, UNIV_OFFSET_FOR_TYPEINFO);
-	typeinfo2 = field(mktag(0), univ2, UNIV_OFFSET_FOR_TYPEINFO);
+	typeinfo1 = MR_field(MR_mktag(0), univ1, UNIV_OFFSET_FOR_TYPEINFO);
+	typeinfo2 = MR_field(MR_mktag(0), univ2, UNIV_OFFSET_FOR_TYPEINFO);
 	save_transient_registers();
 	comp = MR_compare_type_info(typeinfo1, typeinfo2);
 	restore_transient_registers();
@@ -1233,8 +1235,8 @@
 	*/
 
 	r1 = typeinfo1;
-	r2 = field(mktag(0), univ1, UNIV_OFFSET_FOR_DATA);
-	r3 = field(mktag(0), univ2, UNIV_OFFSET_FOR_DATA);
+	r2 = MR_field(MR_mktag(0), univ1, UNIV_OFFSET_FOR_DATA);
+	r3 = MR_field(MR_mktag(0), univ2, UNIV_OFFSET_FOR_DATA);
 	{
 		Declare_entry(mercury__compare_3_0);
 		tailcall(ENTRY(mercury__compare_3_0),
@@ -1706,7 +1708,7 @@
 
 				term_vector = (Word) &new_data;
 
-			} else if (tag(layout_entry) == 
+			} else if (MR_tag(layout_entry) == 
 					TYPE_CTOR_LAYOUT_SHARED_REMOTE_TAG) {
 
 				/*
@@ -1715,10 +1717,10 @@
 				** be the rest of the words.
 				*/
 				incr_hp(new_data, info.arity + 1);
-				field(0, new_data, 0) = info.secondary_tag;
+				MR_field(0, new_data, 0) = info.secondary_tag;
 				term_vector = (Word) (new_data + sizeof(Word));
 
-			} else if (tag(layout_entry) == TYPE_CTOR_LAYOUT_CONST_TAG) {
+			} else if (MR_tag(layout_entry) == TYPE_CTOR_LAYOUT_CONST_TAG) {
 
 				/* 
 				** If it's a du, and this tag is
@@ -1726,7 +1728,7 @@
 				** tag. 
 				*/
 
-				new_data = mkbody(info.secondary_tag);
+				new_data = MR_mkbody(info.secondary_tag);
 				term_vector = (Word) NULL;
 
 			} else {
@@ -1750,7 +1752,7 @@
 				/* 
 				** Add tag to new_data.
 				*/
-			new_data = (Word) mkword(mktag(info.primary_tag), 
+			new_data = (Word) MR_mkword(MR_mktag(info.primary_tag), 
 				new_data);
 		}
 
@@ -1759,9 +1761,10 @@
 		*/
 
 		incr_hp(Term, 2);
-		field(mktag(0), Term, UNIV_OFFSET_FOR_TYPEINFO) = 
+		MR_field(MR_mktag(0), Term, UNIV_OFFSET_FOR_TYPEINFO) = 
 			(Word) TypeInfo;
-		field(mktag(0), Term, UNIV_OFFSET_FOR_DATA) = (Word) new_data;
+		MR_field(MR_mktag(0), Term, UNIV_OFFSET_FOR_DATA) =
+			(Word) new_data;
 	}
 
 	SUCCESS_INDICATOR = success;
@@ -1821,11 +1824,11 @@
 		info->argument_vector =
 			MR_TYPE_CTOR_LAYOUT_FUNCTOR_DESCRIPTOR_ARGS(
 				info->functor_descriptor);
-		info->primary_tag = tag(
+		info->primary_tag = MR_tag(
 			MR_TYPE_CTOR_LAYOUT_FUNCTOR_DESCRIPTOR_TAG(
 				info->functor_descriptor));
-		info->secondary_tag = unmkbody(
-			body(MR_TYPE_CTOR_LAYOUT_FUNCTOR_DESCRIPTOR_TAG(
+		info->secondary_tag = MR_unmkbody(
+			MR_body(MR_TYPE_CTOR_LAYOUT_FUNCTOR_DESCRIPTOR_TAG(
 				info->functor_descriptor), info->primary_tag));
 		info->functor_name =
 			MR_TYPE_CTOR_LAYOUT_FUNCTOR_DESCRIPTOR_FUNCTOR_NAME(
@@ -1893,8 +1896,8 @@
 		if (MR_list_is_empty(arg_list)) {
 			return FALSE;
 		}
-		list_arg_type_info = field(0, MR_list_head(arg_list), 
-			UNIV_OFFSET_FOR_TYPEINFO);
+		list_arg_type_info = MR_field(MR_mktag(0),
+			MR_list_head(arg_list), UNIV_OFFSET_FOR_TYPEINFO);
 
 		arg_type_info = (Word) MR_create_type_info(
 			(Word *) type_info, (Word *) arg_vector[i]);
@@ -1926,8 +1929,8 @@
 	int i;
 
 	for (i = 0; i < arity; i++) {
-		field(mktag(0), term_vector, i) = 
-			field(mktag(0), MR_list_head(arg_list), 
+		MR_field(MR_mktag(0), term_vector, i) = 
+			MR_field(MR_mktag(0), MR_list_head(arg_list), 
 				UNIV_OFFSET_FOR_DATA);
 		arg_list = MR_list_tail(arg_list);
 	}
@@ -1976,12 +1979,12 @@
 		incr_hp(LVALUE_CAST(Word, type_info), arity + extra_args);
 		save_transient_registers();
 		
-		field(mktag(0), type_info, 0) = type_ctor_info;
+		MR_field(MR_mktag(0), type_info, 0) = type_ctor_info;
 		if (MR_TYPECTOR_IS_HIGHER_ORDER(type_ctor)) {
-			field(mktag(0), type_info, 1) = (Word) arity;
+			MR_field(MR_mktag(0), type_info, 1) = (Word) arity;
 		}
 		for (i = 0; i < arity; i++) {
-			field(mktag(0), type_info, i + extra_args) = 
+			MR_field(MR_mktag(0), type_info, i + extra_args) = 
 				MR_list_head(arg_types_list);
 			arg_types_list = MR_list_tail(arg_types_list);
 		}
@@ -2222,8 +2225,10 @@
     MR_TypeCtorLayout type_ctor_layout;
     MR_TypeCtorFunctors type_ctor_functors;
     Code *compare_pred;
-    Word layout_for_tag, layout_vector_for_tag;
-    Word data_value, data_word;
+    Word		layout_for_tag;
+    Word		layout_vector_for_tag;
+    Word		data_value;
+    Word		data_word;
     int data_tag; 
     MR_DiscUnionTagRepresentation tag_rep;
 
@@ -2238,11 +2243,11 @@
         ENTRY(mercury__builtin_compare_non_canonical_type_3_0) );
 
     data_word = *data_word_ptr;
-    data_tag = tag(data_word);
-    data_value = body(data_word, data_tag);
+    data_tag = MR_tag(data_word);
+    data_value = MR_body(data_word, data_tag);
 
     layout_for_tag = type_ctor_layout[data_tag];
-    layout_vector_for_tag = strip_tag(layout_for_tag);
+    layout_vector_for_tag = MR_strip_tag(layout_for_tag);
 	
     switch(type_ctor_info->type_ctor_rep) {
 
@@ -2258,7 +2263,7 @@
             tag_rep = MR_get_tag_representation((Word) layout_for_tag);
             switch(tag_rep) {
             case MR_DISCUNIONTAG_SHARED_LOCAL:
-                data_value = unmkbody(data_value);
+                data_value = MR_unmkbody(data_value);
                 info->functor = MR_TYPE_CTOR_LAYOUT_ENUM_VECTOR_FUNCTOR_NAME(
                     layout_vector_for_tag, data_value);
                 info->arity = 0;
@@ -2280,7 +2285,7 @@
                 layout_for_tag = (Word)
                 MR_TYPE_CTOR_LAYOUT_SHARED_REMOTE_VECTOR_GET_FUNCTOR_DESCRIPTOR(
                     layout_vector_for_tag, secondary_tag);
-                layout_vector_for_tag = strip_tag(layout_for_tag);
+                layout_vector_for_tag = MR_strip_tag(layout_for_tag);
             }   /* fallthru */
 
             case MR_DISCUNIONTAG_UNSHARED: /* fallthru */
@@ -2646,9 +2651,10 @@
 	if (success) {
 		/* Allocate enough room for a univ */
 		incr_hp(ArgumentUniv, 2);
-		field(0, ArgumentUniv, UNIV_OFFSET_FOR_TYPEINFO) =
-			arg_type_info;
-		field(0, ArgumentUniv, UNIV_OFFSET_FOR_DATA) = *argument_ptr;
+		MR_field(MR_mktag(0), ArgumentUniv, UNIV_OFFSET_FOR_TYPEINFO)
+			= arg_type_info;
+		MR_field(MR_mktag(0), ArgumentUniv, UNIV_OFFSET_FOR_DATA)
+			= *argument_ptr;
 	}
 
 	SUCCESS_INDICATOR = success;
@@ -2731,16 +2737,18 @@
 		if (TYPEINFO_IS_VARIABLE(arg_pseudo_type_info)) {
 
 				/* It's a type variable, get its value */
-			field(0, Argument, UNIV_OFFSET_FOR_TYPEINFO) = 
+			MR_field(MR_mktag(0), Argument,
+				UNIV_OFFSET_FOR_TYPEINFO) = 
 				((Word *) TypeInfo_for_T)[arg_pseudo_type_info];
 		}
 		else {
 				/* It's already a type_info */
-			field(0, Argument, UNIV_OFFSET_FOR_TYPEINFO) = 
+			MR_field(MR_mktag(0), Argument,
+				UNIV_OFFSET_FOR_TYPEINFO) = 
 				arg_pseudo_type_info;
 		}
 			/* Fill in the data */
-		field(0, Argument, UNIV_OFFSET_FOR_DATA) = 
+		MR_field(MR_mktag(0), Argument, UNIV_OFFSET_FOR_DATA) = 
 			info.argument_vector[i];
 	}
 
Index: library/store.m
===================================================================
RCS file: /home/mercury1/repository/mercury/library/store.m,v
retrieving revision 1.13
diff -u -b -r1.13 store.m
--- store.m	1998/05/15 07:08:46	1.13
+++ store.m	1999/09/17 09:54:36
@@ -401,7 +401,7 @@
 		will_not_call_mercury,
 "{
 	/* unsafe - does not check type & arity, won't handle no_tag types */
-	Word *Ptr = (Word *) strip_tag(Ref);
+	Word *Ptr = (Word *) MR_strip_tag(Ref);
 	ArgRef = (Word) &Ptr[Arg];
 	S = S0;
 }").
@@ -410,7 +410,7 @@
 				S0::di, S::uo), will_not_call_mercury,
 "{
 	/* unsafe - does not check type & arity, won't handle no_tag types */
-	Word *Ptr = (Word *) strip_tag(Val);
+	Word *Ptr = (Word *) MR_strip_tag(Val);
 	ArgRef = (Word) &Ptr[Arg];
 	S = S0;
 }").
cvs diff: Diffing profiler
cvs diff: Diffing runtime
Index: runtime/mercury_bootstrap.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_bootstrap.c,v
retrieving revision 1.17
diff -u -b -r1.17 mercury_bootstrap.c
--- mercury_bootstrap.c	1999/09/16 09:24:39	1.17
+++ mercury_bootstrap.c	1999/09/17 01:46:35
@@ -27,7 +27,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data_std_util__type_ctor_layout_type_info_0_bootstrap = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_TYPEINFO_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_TYPEINFO_VALUE))
 };
 
 MR_MODULE_STATIC_OR_EXTERN
Index: runtime/mercury_deep_copy_body.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_deep_copy_body.h,v
retrieving revision 1.10
diff -u -b -r1.10 mercury_deep_copy_body.h
--- mercury_deep_copy_body.h	1999/07/06 06:32:14	1.10
+++ mercury_deep_copy_body.h	1999/09/07 02:52:35
@@ -39,12 +39,12 @@
 
     data = *data_ptr;
 
-    data_tag = tag(data);
-    data_value = (Word *) body(data, data_tag);
+    data_tag = MR_tag(data);
+    data_value = (Word *) MR_body(data, data_tag);
 
     type_ctor_info = MR_TYPEINFO_GET_TYPE_CTOR_INFO(type_info);
     layout_entry = type_ctor_info->type_ctor_layout[data_tag];
-    entry_value = (Word *) strip_tag(layout_entry);
+    entry_value = (Word *) MR_strip_tag(layout_entry);
 
     switch (type_ctor_info->type_ctor_rep) {
         case MR_TYPECTOR_REP_ENUM:
@@ -83,18 +83,18 @@
                     incr_saved_hp(new_data, arity + 1);
 
                     /* copy secondary tag */
-                    field(0, new_data, 0) = secondary_tag;
+                    MR_field(0, new_data, 0) = secondary_tag;
 
                     /* copy arguments */
                     for (i = 0; i < arity; i++) {
-                        field(0, new_data, i + 1) = copy_arg(
+                        MR_field(0, new_data, i + 1) = copy_arg(
                             &argument_vector[i], type_info,
                             (Word *) type_info_vector[i], lower_limit,
                             upper_limit);
                     }
 
                     /* tag this pointer */
-                    new_data = (Word) mkword(data_tag, new_data);
+                    new_data = (Word) MR_mkword(data_tag, new_data);
                     leave_forwarding_pointer(data_ptr, new_data);
                 } else {
                     new_data = data;
@@ -119,12 +119,13 @@
 
                     /* copy arguments */
                     for (i = 0; i < arity; i++) {
-                        field(0, new_data, i) = copy_arg(&argument_vector[i],
-                            type_info, (Word *) type_info_vector[i], lower_limit,
-                            upper_limit);
+                        MR_field(0, new_data, i) = copy_arg(
+                            &argument_vector[i],
+                            type_info, (Word *) type_info_vector[i],
+                            lower_limit, upper_limit);
                     }
                     /* tag this pointer */
-                    new_data = (Word) mkword(data_tag, new_data);
+                    new_data = (Word) MR_mkword(data_tag, new_data);
                     leave_forwarding_pointer(data_ptr, new_data);
                 } else {
                     new_data = data;
@@ -347,7 +348,6 @@
 	return new_data;
 }
 
-
 static Word *
 copy_type_info(maybeconst Word *type_info_ptr, const Word *lower_limit,
 		const Word *upper_limit)
Index: runtime/mercury_engine.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_engine.c,v
retrieving revision 1.17
diff -u -b -r1.17 mercury_engine.c
--- mercury_engine.c	1999/09/16 09:24:39	1.17
+++ mercury_engine.c	1999/09/17 02:12:00
@@ -618,7 +618,7 @@
 	** check for a redoip of `exception_handler_do_fail' and
 	** handle it specially.
 	*/
-	fail();
+	MR_fail();
 
 END_MODULE
 
Index: runtime/mercury_heap.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_heap.h,v
retrieving revision 1.10
diff -u -b -r1.10 mercury_heap.h
--- mercury_heap.h	1999/03/10 22:05:23	1.10
+++ mercury_heap.h	1999/09/07 02:42:24
@@ -18,10 +18,10 @@
   #include "gc.h"
 
   #define tag_incr_hp_n(dest, tag, count) \
-	((dest) = (Word) mkword((tag), \
+	((dest) = (Word) MR_mkword((tag), \
 			(Word) GC_MALLOC((count) * sizeof(Word))))
   #define tag_incr_hp_atomic(dest, tag, count) \
-	((dest) = (Word) mkword((tag), \
+	((dest) = (Word) MR_mkword((tag), \
 			(Word) GC_MALLOC_ATOMIC((count) * sizeof(Word))))
 
   #ifdef INLINE_ALLOC
@@ -61,7 +61,7 @@
 		/* if size > 1, round up to an even number of words */	\
 		Word num_words = ((count) == 1 ? 1 : 2 * (((count) + 1) / 2));\
 		GC_MALLOC_WORDS(temp, num_words);			\
-		(dest) = (Word)mkword((tag), temp);			\
+		(dest) = (Word) MR_mkword((tag), temp);			\
 	  })								\
 	: tag_incr_hp_n((dest), (tag), (count))				\
 	)
@@ -94,7 +94,7 @@
 
   #define tag_incr_hp(dest, tag, count) 			\
 	(							\
-		(dest) = (Word) mkword(tag, (Word) MR_hp),	\
+		(dest) = (Word) MR_mkword(tag, (Word) MR_hp),	\
 		debugincrhp(count, MR_hp),			\
 		MR_hp += (count),				\
 		heap_overflow_check(),				\
@@ -159,13 +159,14 @@
 ** which wouldn't work if it was parenthesized.
 */
 #define	incr_hp(dest, count) \
-		tag_incr_hp((dest), mktag(0), (count))
+		tag_incr_hp((dest), MR_mktag(0), (count))
 #define	incr_hp_msg(dest, count, proclabel, type) \
-		tag_incr_hp_msg((dest), mktag(0), (count), proclabel, (type))
+		tag_incr_hp_msg((dest), MR_mktag(0), (count), \
+			proclabel, (type))
 #define	incr_hp_atomic(dest, count) \
-		tag_incr_hp_atomic((dest), mktag(0), (count))
+		tag_incr_hp_atomic((dest), MR_mktag(0), (count))
 #define	incr_hp_atomic_msg(dest, count, proclabel, type) \
-		tag_incr_hp_atomic_msg((dest), mktag(0), (count), \
+		tag_incr_hp_atomic_msg((dest), MR_mktag(0), (count), \
 			proclabel, (type))
 
 /*
Index: runtime/mercury_ho_call.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_ho_call.c,v
retrieving revision 1.20
diff -u -b -r1.20 mercury_ho_call.c
--- mercury_ho_call.c	1999/06/01 09:46:04	1.20
+++ mercury_ho_call.c	1999/09/07 02:09:01
@@ -119,7 +119,7 @@
 	int	i, num_in_args, num_extra_args;
 
 	closure = r1; /* The closure */
-	num_in_args = field(0, closure, 0); /* number of input args */
+	num_in_args = MR_field(0, closure, 0); /* number of input args */
 	num_extra_args = r2; /* number of immediate input args */
 
 	save_registers();
@@ -137,12 +137,12 @@
 	} /* else do nothing because i == MR_HO_CALL_INPUTS */
 
 	for (i = 1; i <= num_in_args; i++) {
-		virtual_reg(i) = field(0, closure, i + 1); /* copy args */
+		virtual_reg(i) = MR_field(0, closure, i + 1); /* copy args */
 	}
 
 	restore_registers();
 
-	tailcall((Code *) field(0, closure, 1), LABEL(do_call_det_closure));
+	tailcall((Code *) MR_field(0, closure, 1), LABEL(do_call_det_closure));
 }
 
 Define_entry(mercury__do_call_closure);
@@ -270,16 +270,16 @@
 	x = r2;
 	y = r3;
 
-	type_ctor_info = field(0, type_info, 0);
+	type_ctor_info = MR_field(0, type_info, 0);
 	if (type_ctor_info == 0) {
 		type_arity = 0;
-		unify_pred = (Code *) field(0, type_info,
+		unify_pred = (Code *) MR_field(0, type_info,
 					OFFSET_FOR_UNIFY_PRED);
 		/* args_base will not be needed */
 		args_base = 0; /* just to supress a gcc warning */
 	} else {
-		type_arity = field(0, type_ctor_info, OFFSET_FOR_COUNT);
-		unify_pred = (Code *) field(0, type_ctor_info,
+		type_arity = MR_field(0, type_ctor_info, OFFSET_FOR_COUNT);
+		unify_pred = (Code *) MR_field(0, type_ctor_info,
 				OFFSET_FOR_UNIFY_PRED);
 		args_base = type_info;
 	}
@@ -288,7 +288,7 @@
 
 	/* we call `UnifyPred(...ArgTypeInfos..., X, Y)' */
 	for (i = 1; i <= type_arity; i++) {
-		virtual_reg(i) = field(0, args_base, i);
+		virtual_reg(i) = MR_field(0, args_base, i);
 	}
 	virtual_reg(type_arity + 1) = x;
 	virtual_reg(type_arity + 2) = y;
@@ -322,16 +322,16 @@
 
 	type_info = r1;
 	x = r2;
-	type_ctor_info = field(0, type_info, 0);
+	type_ctor_info = MR_field(0, type_info, 0);
 	if (type_ctor_info == 0) {
 		type_arity = 0;
-		index_pred = (Code *) field(0, type_info,
+		index_pred = (Code *) MR_field(0, type_info,
 					OFFSET_FOR_INDEX_PRED);
 		/* args_base will not be needed */
 		args_base = 0; /* just to supress a gcc warning */
 	} else {
-		type_arity = field(0, type_ctor_info, OFFSET_FOR_COUNT);
-		index_pred = (Code *) field(0, type_ctor_info,
+		type_arity = MR_field(0, type_ctor_info, OFFSET_FOR_COUNT);
+		index_pred = (Code *) MR_field(0, type_ctor_info,
 				OFFSET_FOR_INDEX_PRED);
 		args_base = type_info;
 	}
@@ -340,7 +340,7 @@
 
 	/* we call `IndexPred(...ArgTypeInfos..., X, Index)' */
 	for (i = 1; i <= type_arity; i++) {
-		virtual_reg(i) = field(0, args_base, i);
+		virtual_reg(i) = MR_field(0, args_base, i);
 	}
 	virtual_reg(type_arity + 1) = x;
 
@@ -396,16 +396,16 @@
 	x = r2;
 	y = r3;
 
-	type_ctor_info = field(0, type_info, 0);
+	type_ctor_info = MR_field(0, type_info, 0);
 	if (type_ctor_info == 0) {
 		type_arity = 0;
-		compare_pred = (Code *) field(0, type_info,
+		compare_pred = (Code *) MR_field(0, type_info,
 						OFFSET_FOR_COMPARE_PRED);
 		/* args_base will not be needed */
 		args_base = 0; /* just to supress a gcc warning */
 	} else {
-		type_arity = field(0, type_ctor_info, OFFSET_FOR_COUNT);
-		compare_pred = (Code *) field(0, type_ctor_info,
+		type_arity = MR_field(0, type_ctor_info, OFFSET_FOR_COUNT);
+		compare_pred = (Code *) MR_field(0, type_ctor_info,
 				OFFSET_FOR_COMPARE_PRED);
 		args_base = type_info;
 	}
@@ -414,7 +414,7 @@
 
 	/* we call `ComparePred(...ArgTypeInfos..., Result, X, Y)' */
 	for (i = 1; i <= type_arity; i++) {
-		virtual_reg(i) = field(0, args_base, i);
+		virtual_reg(i) = MR_field(0, args_base, i);
 	}
 	virtual_reg(type_arity + 1) = x;
 	virtual_reg(type_arity + 2) = y;
Index: runtime/mercury_stacks.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_stacks.h,v
retrieving revision 1.18
diff -u -b -r1.18 mercury_stacks.h
--- mercury_stacks.h	1999/09/16 09:24:40	1.18
+++ mercury_stacks.h	1999/09/17 02:12:49
@@ -308,7 +308,7 @@
 		** builtin_throw/1), and save the stuff we will		      \
 		** need if an exception is thrown.			      \
 		*/							      \
-		mkpragmaframe((name), 0,	      		      	      \
+		MR_mkpragmaframe((name), 0,	      		      	      \
 			MR_Exception_Handler_Frame_struct,		      \
 			ENTRY(exception_handler_do_fail));		      \
 		/* record the handler's code model */			      \
@@ -345,7 +345,7 @@
 		** so we can avoid this by creating a second frame	      \
 		** above the special frame.)				      \
 		*/							      \
-		mktempframe(redoip);				      	      \
+		MR_mktempframe(redoip);				      	      \
 	} while (0)
 
 
Index: runtime/mercury_string.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_string.h,v
retrieving revision 1.12
diff -u -b -r1.12 mercury_string.h
--- mercury_string.h	1999/08/12 09:58:48	1.12
+++ mercury_string.h	1999/09/17 09:59:47
@@ -63,7 +63,7 @@
 */
 #define make_aligned_string(ptr, string) 				\
 	do { 								\
-	    if (tag((Word) (string)) != 0) { 				\
+	    if (MR_tag((Word) (string)) != 0) {				\
 		make_aligned_string_copy((ptr), (string));		\
 	    } else { 							\
 	    	(ptr) = (string);					\
Index: runtime/mercury_tabling.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_tabling.c,v
retrieving revision 1.10
diff -u -b -r1.10 mercury_tabling.c
--- mercury_tabling.c	1999/09/07 17:58:16	1.10
+++ mercury_tabling.c	1999/09/15 00:58:07
@@ -198,8 +198,8 @@
 MR_TrieNode
 MR_float_hash_lookup_or_add(MR_TrieNode t, Float key)
 {
-	TableNode * p, * q;
-	Word * table = *t;	/* Deref the table pointer */
+	TableNode	*p, *q;
+	Word		*table = *t;	/* Deref the table pointer */
 	Word bucket;
 	Word hash;
 
@@ -464,23 +464,25 @@
     MR_TypeCtorInfo type_ctor_info;
     MR_TypeCtorLayout type_ctor_layout;
     MR_TypeCtorFunctors type_ctor_functors;
-
-    Word layout_for_tag, *layout_vector_for_tag, *data_value;
-    int data_tag, entry_tag;
-
     MR_DiscUnionTagRepresentation tag_rep;
-
     MR_MemoryList allocated_memory_cells = NULL;
+
+    Word		layout_for_tag;
+    Word		*layout_vector_for_tag;
+    Word		*data_value;
+    int			data_tag;
+    int			entry_tag;
 
-    data_tag = tag(data);
-    data_value = (Word *) body(data, data_tag);
+    data_tag = MR_tag(data);
+    data_value = (Word *) MR_body(data, data_tag);
 
     type_ctor_info = MR_TYPEINFO_GET_TYPE_CTOR_INFO(type_info);
     type_ctor_layout = MR_TYPE_CTOR_INFO_GET_TYPE_CTOR_LAYOUT(type_ctor_info);
-    type_ctor_functors = MR_TYPE_CTOR_INFO_GET_TYPE_CTOR_FUNCTORS(type_ctor_info);
+    type_ctor_functors = MR_TYPE_CTOR_INFO_GET_TYPE_CTOR_FUNCTORS(
+                    type_ctor_info);
 
     layout_for_tag = type_ctor_layout[data_tag];
-    layout_vector_for_tag = (Word *) strip_tag(layout_for_tag);
+    layout_vector_for_tag = (Word *) MR_strip_tag(layout_for_tag);
 
 #ifdef	MR_TABLE_DEBUG
     if (MR_tabledebug) {
@@ -503,7 +505,7 @@
 	        int functors = MR_TYPE_CTOR_LAYOUT_ENUM_VECTOR_NUM_FUNCTORS(
 				layout_vector_for_tag);
 	        MR_DEBUG_TABLE_TAG(table, data_tag);
-	        MR_DEBUG_TABLE_ENUM(table, functors, unmkbody(data));
+                MR_DEBUG_TABLE_ENUM(table, functors, MR_unmkbody(data));
                 break;
             }
             case MR_DISCUNIONTAG_UNSHARED: {
@@ -524,14 +526,19 @@
                     new_type_info = MR_make_type_info(type_info,
                         (Word *) type_info_vector[i], &allocated_memory_cells);
 
-                    MR_DEBUG_TABLE_ANY(table, new_type_info, argument_vector[i]);
+                    MR_DEBUG_TABLE_ANY(table, new_type_info,
+                        argument_vector[i]);
                 }
                 break;
             }
             case MR_DISCUNIONTAG_SHARED_REMOTE: {
                 int arity, i;
-                Word *argument_vector, *type_info_vector, *new_type_info;
-                Word secondary_tag, num_sharers, *new_layout_vector;
+                Word    *argument_vector;
+                Word    *type_info_vector;
+                Word    *new_type_info;
+                Word    secondary_tag;
+                Word    num_sharers;
+                Word    *new_layout_vector;
 
                 secondary_tag = *data_value;
                 argument_vector = data_value + 1;
@@ -552,7 +559,8 @@
                     new_type_info = MR_make_type_info(type_info,
                         (Word *) type_info_vector[i], &allocated_memory_cells);
 
-                    MR_DEBUG_TABLE_ANY(table, new_type_info, argument_vector[i]);
+                    MR_DEBUG_TABLE_ANY(table, new_type_info,
+                        argument_vector[i]);
                 }
                 break;
             }
@@ -1167,7 +1175,7 @@
 	** nondet stack fragment. The framevar slot is for use by
 	** table_nondet_resume.
 	*/
-	mkframe(mercury__table_nondet_suspend/2, 1, ENTRY(do_fail));
+	MR_mkframe("mercury__table_nondet_suspend", 1, ENTRY(do_fail));
 
 	table = MR_SUBGOAL(r1);
 	consumer = table_allocate_bytes(sizeof(MR_Consumer));
@@ -1286,7 +1294,7 @@
 	listnode->item = consumer;
 	listnode->next = NULL;
 }
-	fail();
+	MR_fail();
 END_MODULE
 
 MR_Subgoal	*MR_cur_leader;
@@ -1371,7 +1379,7 @@
 #endif
 
 		(void) MR_pop_generator();
-		redo();
+		MR_redo();
 	}
 
 #ifdef	MR_TABLE_DEBUG
@@ -1553,7 +1561,7 @@
 	** computation that existed when suspend was called, the code
 	** that we return to is the code following the call to suspend.
 	*/
-	succeed();
+	MR_succeed();
 
 Define_label(mercury__table_nondet_resume_1_0_RedoPoint);
 	update_prof_current_proc(LABEL(mercury__table_nondet_resume_1_0));
@@ -1637,7 +1645,7 @@
 BEGIN_CODE
 Define_entry(MR_table_nondet_commit);
 	MR_commit_cut();
-	fail();
+	MR_fail();
 END_MODULE
 
 #endif
Index: runtime/mercury_tags.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_tags.h,v
retrieving revision 1.6
diff -u -b -r1.6 mercury_tags.h
--- mercury_tags.h	1999/07/13 05:05:47	1.6
+++ mercury_tags.h	1999/09/07 02:28:40
@@ -66,11 +66,11 @@
 
 #define	MR_mkword(t, p)			((Word *)((char *)(p) + (t)))
 
-#define	MR_field(t, p, i)		((Word *) body((p), (t)))[i]
-#define	MR_const_field(t, p, i)		((const Word *) body((p), (t)))[i]
+#define	MR_field(t, p, i)		((Word *) MR_body((p), (t)))[i]
+#define	MR_const_field(t, p, i)		((const Word *) MR_body((p), (t)))[i]
 
-#define	MR_mask_field(p, i)		((Word *) strip_tag(p))[i]
-#define	MR_const_mask_field(p, i)	((const Word *) strip_tag(p))[i]
+#define	MR_mask_field(p, i)		((Word *) MR_strip_tag(p))[i]
+#define	MR_const_mask_field(p, i)	((const Word *) MR_strip_tag(p))[i]
 
 /*
 ** the following MR_list_* macros are used by handwritten C code
Index: runtime/mercury_trace_base.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_trace_base.c,v
retrieving revision 1.17
diff -u -b -r1.17 mercury_trace_base.c
--- mercury_trace_base.c	1999/08/24 09:40:41	1.17
+++ mercury_trace_base.c	1999/09/07 02:49:13
@@ -401,7 +401,7 @@
 			GOTO(MR_jumpaddr);
 		}
 	}
-	fail();
+	MR_fail();
 
 Define_entry(MR_do_trace_redo_fail_deep);
 #if 0
@@ -429,7 +429,7 @@
 			GOTO(MR_jumpaddr);
 		}
 	}
-	fail();
+	MR_fail();
 
 END_MODULE
 
Index: runtime/mercury_type_info.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_type_info.c,v
retrieving revision 1.21
diff -u -b -r1.21 mercury_type_info.c
--- mercury_type_info.c	1999/08/12 09:58:49	1.21
+++ mercury_type_info.c	1999/09/07 02:45:03
@@ -26,7 +26,7 @@
 	TYPE_LAYOUT_FIELDS
 } mercury_data___type_ctor_layout_pred_0 = {
 	make_typelayout_for_all_tags(TYPE_CTOR_LAYOUT_CONST_TAG, 
-		mkbody(MR_TYPE_CTOR_LAYOUT_PREDICATE_VALUE))
+		MR_mkbody(MR_TYPE_CTOR_LAYOUT_PREDICATE_VALUE))
 };
 
 	/* type_ctor_functors for `pred' */
@@ -38,7 +38,6 @@
 	MR_TYPE_CTOR_FUNCTORS_SPECIAL
 };
 
-
 	/* 
 	** type_ctor_info for `func' 
 	** (this is used for all higher-order func types) 
@@ -94,7 +93,7 @@
 
 /* code for predicate 'builtin_unify_pred'/2 in mode 0 */
 Define_entry(mercury__builtin_unify_pred_2_0);
-	incr_sp_push_msg(2, "private_builtin:builtin_unify_pred");
+	MR_incr_sp_push_msg(2, "private_builtin:builtin_unify_pred");
 	fatal_error("attempted unification of higher-order terms");
 END_MODULE
 
@@ -115,7 +114,7 @@
 
 /* code for predicate 'builtin_compare_pred'/3 in mode 0 */
 Define_entry(mercury__builtin_compare_pred_3_0);
-	incr_sp_push_msg(2, "private_builtin:builtin_compare_pred");
+	MR_incr_sp_push_msg(2, "private_builtin:builtin_compare_pred");
 	fatal_error("attempted comparison of higher-order terms");
 END_MODULE
 
@@ -243,8 +242,10 @@
 int
 MR_compare_type_info(Word t1, Word t2)
 {
-	Word	*type_info_1, *type_info_2;
-	MR_TypeCtorInfo	type_ctor_info_1, type_ctor_info_2;
+	Word		*type_info_1;
+	Word		*type_info_2;
+	MR_TypeCtorInfo	type_ctor_info_1;
+	MR_TypeCtorInfo	type_ctor_info_2;
 	int	num_arg_types;
 	int	i;
 
@@ -304,10 +305,10 @@
 		int num_arg_types_2;
 
 			/* Get number of arguments from type_info */
-		num_arg_types = field(mktag(0), type_info_1, 
+		num_arg_types = MR_field(MR_mktag(0), type_info_1, 
 			TYPEINFO_OFFSET_FOR_PRED_ARITY);
 
-		num_arg_types_2 = field(mktag(0), type_info_2, 
+		num_arg_types_2 = MR_field(MR_mktag(0), type_info_2, 
 			TYPEINFO_OFFSET_FOR_PRED_ARITY);
 
 			/* Check arity */
@@ -325,20 +326,22 @@
 		type_info_1++;
 		type_info_2++;
 	} else {
-		num_arg_types = field(mktag(0), type_ctor_info_1,
+		num_arg_types = MR_field(MR_mktag(0), type_ctor_info_1,
 				OFFSET_FOR_COUNT);
 	}
+
 		/* compare the argument types */
 	for (i = 0; i < num_arg_types; i++) {
-		Word arg_type_info_1 = field(mktag(0), type_info_1,
+		Word arg_type_info_1 = MR_field(MR_mktag(0), type_info_1,
 			OFFSET_FOR_ARG_TYPE_INFOS + i);
-		Word arg_type_info_2 = field(mktag(0), type_info_2,
+		Word arg_type_info_2 = MR_field(MR_mktag(0), type_info_2,
 			OFFSET_FOR_ARG_TYPE_INFOS + i);
 		int comp = MR_compare_type_info(
 				arg_type_info_1, arg_type_info_2);
 		if (comp != COMPARE_EQUAL)
 			return comp;
 	}
+
 	return COMPARE_EQUAL;
 }
 
@@ -503,9 +506,11 @@
 				node->next = *allocated;
 				*allocated = node;
 			}
+
 			type_info[i] = (Word) arg_type_info;
 		}
 	}
+
 	if (type_info == NULL) {
 		return (Word *) (Word) arg_pseudo_type_info;
 	} else {
@@ -519,7 +524,7 @@
 enum MR_DiscUnionTagRepresentation
 MR_get_tag_representation(Word layout_entry)
 {
-	switch ((int) tag(layout_entry)) {
+	switch ((int) MR_tag(layout_entry)) {
 		case TYPE_CTOR_LAYOUT_UNSHARED_TAG:
 			return MR_DISCUNIONTAG_UNSHARED;
 		case TYPE_CTOR_LAYOUT_SHARED_REMOTE_TAG:
Index: runtime/mercury_type_info.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_type_info.h,v
retrieving revision 1.24
diff -u -b -r1.24 mercury_type_info.h
--- mercury_type_info.h	1999/08/12 09:58:49	1.24
+++ mercury_type_info.h	1999/09/07 04:33:36
@@ -117,7 +117,7 @@
 	#define TYPE_LAYOUT_FIELDS \
 		TypeLayoutField f1,f2,f3,f4,f5,f6,f7,f8;
 	#define make_typelayout(Tag, Value) \
-		mkword(mktag(Tag), (Value))
+		MR_mkword(MR_mktag(Tag), (Value))
 #else
 	typedef const Word *TypeLayoutField;
 	#define TYPE_LAYOUT_FIELDS \
@@ -624,7 +624,7 @@
 
 #define MR_TYPE_CTOR_LAYOUT_SHARED_REMOTE_VECTOR_GET_FUNCTOR_DESCRIPTOR( \
 		Vector, N)						 \
-	( (Word *) strip_tag((&((MR_TypeLayout_SharedRemoteVector *)	 \
+	( (Word *) MR_strip_tag((&((MR_TypeLayout_SharedRemoteVector *)	 \
 		(Vector))->functor_descriptor1) [N]) )
 		
 	/* 
@@ -720,6 +720,7 @@
 	void *data;
 	struct MR_MemoryCellNode *next;
 };
+
 typedef struct MR_MemoryCellNode *MR_MemoryList;
 
 Word * MR_make_type_info(const Word *term_type_info, 
@@ -815,6 +816,7 @@
 	String type_ctor_module_name;
 	String type_ctor_name;
 };
+
 typedef struct MR_TypeCtorInfo_struct *MR_TypeCtorInfo;
 
 	/* 
Index: runtime/mercury_wrapper.c
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_wrapper.c,v
retrieving revision 1.42
diff -u -b -r1.42 mercury_wrapper.c
--- mercury_wrapper.c	1999/09/16 09:24:40	1.42
+++ mercury_wrapper.c	1999/09/17 01:46:42
@@ -1031,7 +1031,7 @@
 #endif
 
 	if (benchmark_all_solns)
-		redo();
+		MR_redo();
 	else
 		GOTO_LABEL(all_done);
 
cvs diff: Diffing runtime/GETOPT
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/mercury_calls_fortran
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 samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing scripts
cvs diff: Diffing tests
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/debugger/declarative
cvs diff: Diffing tests/dppd
cvs diff: Diffing tests/general
cvs diff: Diffing tests/general/accumulator
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/exceptions
cvs diff: Diffing tests/hard_coded/sub-modules
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
Index: trace/mercury_trace_browse.c
===================================================================
RCS file: /home/mercury1/repository/mercury/trace/mercury_trace_browse.c,v
retrieving revision 1.7
diff -u -b -r1.7 mercury_trace_browse.c
--- mercury_trace_browse.c	1999/06/07 21:44:54	1.7
+++ mercury_trace_browse.c	1999/09/20 05:43:52
@@ -146,11 +146,11 @@
         MR_TRACE_USE_HP(
 		make_aligned_string(options_on_heap, options);
 
-		imports_list = list_empty();
+		imports_list = MR_list_empty();
 		for (i = num_imports; i > 0; i--) {
 			ConstString this_import;
 			make_aligned_string(this_import, imports[i - 1]);
-			imports_list = list_cons(this_import, imports_list);
+			imports_list = MR_list_cons(this_import, imports_list);
 		}
 	);
 
Index: trace/mercury_trace_declarative.c
===================================================================
RCS file: /home/mercury1/repository/mercury/trace/mercury_trace_declarative.c,v
retrieving revision 1.9
diff -u -b -r1.9 mercury_trace_declarative.c
--- mercury_trace_declarative.c	1999/07/05 04:17:48	1.9
+++ mercury_trace_declarative.c	1999/09/20 05:43:34
@@ -527,8 +527,8 @@
 			MR_TRACE_USE_HP(
 				incr_hp(*Node, 2);
 			);
-			field(mktag(0), *Node, 0) = (Word) name;
-			field(mktag(0), *Node, 1) = args;
+			MR_field(MR_mktag(0), *Node, 0) = (Word) name;
+			MR_field(MR_mktag(0), *Node, 1) = args;
 			break;
 		default:
 			fatal_error("MR_edt_root_node: unknown tag");
@@ -576,15 +576,15 @@
 	}
 
 	MR_TRACE_USE_HP(
-		arglist = list_empty();
+		arglist = MR_list_empty();
 		for (i = argc - 1; i >= 0; i--) {
 			tail = arglist;
 			incr_hp(head, 2);
-			field(mktag(0), head, UNIV_OFFSET_FOR_TYPEINFO) =
+			MR_field(MR_mktag(0), head, UNIV_OFFSET_FOR_TYPEINFO) =
 				edt->MR_edt_node_arg_types[i];
-			field(mktag(0), head, UNIV_OFFSET_FOR_DATA) =
+			MR_field(MR_mktag(0), head, UNIV_OFFSET_FOR_DATA) =
 				edt->MR_edt_node_arg_values[i];
-			arglist = list_cons(head, tail);
+			arglist = MR_list_cons(head, tail);
 		}
 	);
 
Index: trace/mercury_trace_external.c
===================================================================
RCS file: /home/mercury1/repository/mercury/trace/mercury_trace_external.c,v
retrieving revision 1.20
diff -u -b -r1.20 mercury_trace_external.c
--- mercury_trace_external.c	1999/09/15 17:53:42	1.20
+++ mercury_trace_external.c	1999/09/20 05:42:56
@@ -859,7 +859,7 @@
 	var_count = MR_trace_var_count();
 
 	MR_TRACE_USE_HP(
-		var_list = list_empty();
+		var_list = MR_list_empty();
 	);
 
 	for (i = var_count; i > 0; i--) {
@@ -873,11 +873,12 @@
 			incr_hp(univ, 2);
 		);
 
-		field(mktag(0), univ, UNIV_OFFSET_FOR_TYPEINFO) = type_info;
-		field(mktag(0), univ, UNIV_OFFSET_FOR_DATA) = value;
+		MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_TYPEINFO)
+			= type_info;
+		MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_DATA) = value;
 
 		MR_TRACE_USE_HP(
-			var_list = list_cons(univ, var_list);
+			var_list = MR_list_cons(univ, var_list);
 		);
 	}
 
@@ -905,7 +906,7 @@
 	var_count = MR_trace_var_count();
 
 	MR_TRACE_USE_HP(
-		var_names_list = list_empty();
+		var_names_list = MR_list_empty();
 	);
 
 	for (i = var_count; i > 0; i--) {
@@ -915,7 +916,7 @@
 		}
 
 		MR_TRACE_USE_HP(
-			var_names_list = list_cons(name, var_names_list);
+			var_names_list = MR_list_cons(name, var_names_list);
 		);
 	}
 
@@ -943,7 +944,7 @@
 	var_count = MR_trace_var_count();
 
         MR_TRACE_USE_HP(
-		type_list = list_empty();
+		type_list = MR_list_empty();
         );
 
 	for (i = var_count; i > 0; i--) {
@@ -956,7 +957,7 @@
 			type_info_string = ML_type_name(type_info);
 		);
 	        MR_TRACE_USE_HP(
-			type_list = list_cons(type_info_string, type_list);
+			type_list = MR_list_cons(type_info_string, type_list);
 	        );
 	}
 
@@ -987,8 +988,9 @@
 	problem = MR_trace_return_var_info(var_number, NULL,
 			&type_info, &value);
 	if (problem == NULL) {
-		field(mktag(0), univ, UNIV_OFFSET_FOR_TYPEINFO) = type_info;
-		field(mktag(0), univ, UNIV_OFFSET_FOR_DATA) = value;
+		MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_TYPEINFO)
+			= type_info;
+		MR_field(MR_mktag(0), univ, UNIV_OFFSET_FOR_DATA) = value;
 	} else {
 		/*
 		** Should never occur since we check in the external debugger
Index: trace/mercury_trace_help.c
===================================================================
RCS file: /home/mercury1/repository/mercury/trace/mercury_trace_help.c,v
retrieving revision 1.5
diff -u -b -r1.5 mercury_trace_help.c
--- mercury_trace_help.c	1998/11/06 10:35:40	1.5
+++ mercury_trace_help.c	1999/09/20 05:40:58
@@ -48,7 +48,7 @@
 
 	MR_trace_help_ensure_init();
 	MR_TRACE_USE_HP(
-		path = list_empty();
+		path = MR_list_empty();
 	);
 	return MR_trace_help_add_node(path, category, slot, text);
 }
@@ -65,8 +65,8 @@
 
 	MR_TRACE_USE_HP(
 		make_aligned_string_copy(category_on_heap, category);
-		path = list_empty();
-		path = list_cons(category_on_heap, path);
+		path = MR_list_empty();
+		path = MR_list_cons(category_on_heap, path);
 	);
 
 	return MR_trace_help_add_node(path, item, slot, text);
@@ -141,9 +141,9 @@
 	MR_TRACE_USE_HP(
 		make_aligned_string_copy(category_on_heap, category);
 		make_aligned_string_copy(item_on_heap, item);
-		path = list_empty();
-		path = list_cons(item_on_heap, path);
-		path = list_cons(category_on_heap, path);
+		path = MR_list_empty();
+		path = MR_list_cons(item_on_heap, path);
+		path = MR_list_cons(category_on_heap, path);
 	);
 
 	MR_TRACE_CALL_MERCURY(
cvs diff: Diffing trial
cvs diff: Diffing util
--------------------------------------------------------------------------
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
--------------------------------------------------------------------------



More information about the developers mailing list